No default branch
Bookmark a link to HEAD: (view) (download) (as text)
In order to support obtaining the line and column locations of problems in XML files, we are now using Python 2.4's version of the 'pyexpat' module, built as 'peak.util.pyexpat'. Also, added "empty" option to negotiating XML parser, so that tags which don't want any children can force an error if a child element appears within them.
The 'persistence' package has been moved to 'peak.persistence' to avoid conflicts with ZODB3 and the latest version of Zope 3. It will eventually be phased out, but for now this move is the simplest way to get it out of the way.
Fix not installing 'schema.dtd' for ZConfig.
Sync to setuptools
Overhaul setup.py to simplify installation and maintenance. It's no longer necessary to manually add packages or files to setup.py. Optional features can now be controlled with '--with-X' and '--without-X' options. Bumped version number to 0.5a4. (XXX Need to update INSTALL.txt w/options info!)
Sync to setuptools.
Initial skeleton of 'setuptools' package, for installing dependencies, etc. Cleaned up data file installation handling: we now just set extensions, and all data files contained in packages are installed automatically. Additional wildcards or filenames can be defined on a per-package basis. Also, fixed some broken installation bits for ZConfig.
Fix 'version' tool breakage caused by promotion of running.tools; misc. release prep.
Fix not installing resource_defaults.ini for DDT, and fix FastCGI accepter loop exiting whenever an error occurs.
Use uuidgen() system call where available
Fix missing test data file.
Documenting the examples on the API docs page wasn't such a hot idea. They should go somewhere else.
Document 'examples', but not 'datetime' or 'csv'.
Move 'csv' from a module to a package, so that setup.py will work. :(
First draft of 'peak.ddt', a "Document-Driven Testing" framework. Similar to FIT (http://fit.c2.com/), 'peak.ddt' can parse HTML documents, run the tests described by tables therein, then output an annotated version of the document with the results of each test, suitable for posting on a project website. This is an early draft that only supports colorizing of table cells, and doesn't incorporate any "runners" or "fixtures" yet. But the basic domain model is quite complete, as is the HTML-parsing DM class.
Fix 'setup.py' not installing 'csv.py'.
Fix missing ZConfig 'schema.dtd', so that people using pyxml don't get errors.
Added automatic installation of 'csv' module for Python < 2.3. This is preparatory to adding cursor formatting using csv, and maybe eventually a csv "connection" type to peak.storage. Both should be useful for extract-transform-load-test operations and for doing TinyTable-like things.
Added 'peak.events' and 'peak.events.tests' to setup.py.
Fixed missing 'tools.supervisor' package.
Give peak.running.tools a promotion... it's now just peak.tools
Added 'peak.metamodels.ASDL', a metamodel for the Zephyr Abstract Syntax Description Language. ASDL is a convenient way to describe a domain model for an abstract syntax tree (AST), and the models generated with the new ASDL tool can be combined with concrete syntax to create a complete parsing solution for "mini languages", possibly including the Python language itself. (Future versions of the Python and Jython compilers are likely to use AST models based on ASDL, and in the current Python CVS sandbox there's already an ASDL model of Python's AST available.)
Initial checkin of 'peak.query' package. So far it's just a package skeleton and a couple of interfaces for relation variables and conditions.
Fixed not installing "version" app's .ini file -- and code!
Added new 'version' tool that automatically edits files to update version information in them. Just execute the 'version' file in the main PEAK source directory. (Use '--help' for help.) You can use this tool with your own projects by creating 'version' and 'version.dat' files in your project directory, similar to the ones used by PEAK. The 'version' file is a ZConfig file that describes your project's version numbering scheme(s), formats, and the files that need to be edited, while the 'version.dat' file contains the current version number values. Source for the tool, including the configuration file schema, is in the 'peak.running.tools.version' package. (Error handling and documentation, alas, are still minimal.) Also, bumped PEAK version stamps to 0.5a3, using the new tool. (Yay!)
Introduce peak.net for implementations of network protocols and other general networking-related features that don't really fit into storage, naming, etc. Also, an icb protocol implementation work-in-progress. ICB ("Internet CB") is an ancient chat protocol that's not widely used anymore except in some circles. This is more of an example than something likely to be useful by many people, but I have a use for it. Still needs work, though.
Added 'url.*' family of DOMlets. 'url.foo' causes the tag's 'foo' attribute to be replaced with the absolute URL of the current traversal location. 'url.foo+bar' caused the attribute 'foo:bar' to be replaced. 'url' alone replaces the contents of the tag, and 'url.notag' replaces the entire element with just the URL. (The spelling for these latter behaviors may get tweaked a bit.) Testing this shook a few typos and other bugs out of the woodwork. Also, this gives an example of how to create a DOMlet factory that isn't a class, but a function that decides what class to create.
Fix more typos found by Ulrich.
Lots of peak.web enhancements for resources and templates: - Added 'web.bindResource("name")'. - Documented IWebTraversable.preTraverse() better. - Made IWebTraversable.getObject() take the interaction as a parameter; this is ugly but was necessary in order to get bindResource to work. - Added TestInteraction.simpleTraverse(), to minimize duplicated code in interaction-driven tests. - Made interactions deal in lists of objects traversed so far, rather than keeping only the last object. This was needed so that resources used as methods can be bound to their context (the object whose method they are) rather than their container (a layer of the skin). This is also ugly but necessary. :( - Added caching to ResourceDirectory and Skin, to prevent repeated object creation and retrievals. - Created 'TemplateResource', so you can 'bindResource()' to peak.web template files. Made '.pwt' file extension map to 'TemplateResource'. At this point, it's clear to me that the traversal mechanisms used by 'peak.web' are ugly as sin and need critical review. It is *very* hard to reason clearly about what traversal components do, in part because they may or may not be decorators over some "real" object. Skins and Resources further complicate matters by possibly having different parents, or mixing MultiTraversers into the mix. Right now, things seem to work okay, but I'd feel more comfortable if I could predict/visualize *how* they work. I keep finding things not working as I expect, and although I'm able to understand how they actually work long enough to make them do what I want, I forget soon afterwards because it's just too darn complicated! On the bright side, we now have the minimum required functionality, so perhaps we can now understand the detailed requirements enough to be able to refactor the implementation appropriately.
Draft implementation of resource directories. We really need some tests for this stuff, which means creating a TestInteractionPolicy, TestRequest, and some other suchlike classes. We also need files to be renderable, a factory for template files, and a 'bindResource()' operation. But, the basic structure is now in place.
Added "smart properties" support, w/tests. You can now use 'naming.LinkRef' and 'naming.Reference' in .ini files and have them work, even without using peak.naming to look up the properties. Also, it should be possible to create useful caching rule objects, such as we will need for peak.web templates. Also, fixed a typo in peak.naming.arithmetic that caused certain name subtractions to fail.
The templates have landed! We can parse and render templates, and use them as web methods on locations. There's even a (yes, just one) unit test. Big TODO lists both in the package and its test suite, but at least it's working. Made minor adjustments to publishing algorithms so that locations know their parent locations, and methods know the location that they were found in. Bumped package version to 0.5a3, since we've been in the alpha 3 cycle for a while now.
Initial import of N2 (Namespace Navigator) utility. This is a sort of all-purpose Swiss Army Knife for PEAK. It's a sh-like shell for navigating peak.naming contexts, complete with IO redirection! It's an enhanced Python interactive command line! It's a sqsh-like interactive database shell ! It's an extensible environment for interacting with any python object! It's a floor wax, and a desert topping! This is an almost total rewrite of the (unreleased) original. It was completely refactored to take advantage of adaption , changes in peak.naming, the peak.running commands stuff, completely rewritten argument parsing code, and more. This fixed all sorts of ugliness in the original code, and made it much more extensible. Note that this has not been tested much, especially the namespace shell, because "nis:" has stopped working and that was my primary test case. It also needs documentation and there are still some things to do to the code... But you can play with it now. usage: peak n2 [-e] [-p] [name] -e if name lookup fails, go into python interactor anyway -p use python interactor even if there is a more specific interactor (implies -e)  The SQL interactor has not been ported from the old code yet, but that's coming soon.  Phillip makes fun of me for saying adaption instead of adaptation, but dictionary.com say "adaption" is OK. :-) Besides, "adaption" sounds like it goes with adapt(). Seems like adaptation would have a function called adaptate() ;-). And for that matter, shouldn't Canadians come from a country called Canadia?
Added Python/Zope 'datetime' package.
'peak.web' is born; just interface sketches and a draft of 'BaseInteraction' for now. CGI support has been moved from 'peak.running.zpublish' into 'peak.running.commands' (for "raw" CGI/FastCGI) and 'peak.web' (for the PEAK high-level publishing framework). You can use 'peak CGI someName' to adapt 'someName' to a 'running.IRerunnableCGI' and run it as a CGI/FastCGI. This will form the basis for creating the web version of an app later; you'll do something like:: class MyAppAsCGI(web.CGIPublisher): app = binding.New(MyAppClass) And then use 'peak CGI import:somepkg.MyAppAsCGI' to run it. Or, if your app wants to exec a config file, you might define your CGIPublisher subclass as an adapter from MyAppClass to IRerunnableCGI, rather than invoking it directly.
Initial draft of security system for 'peak.web', et al. You can declare abstract permission types, then declare application-specific rules for checking those permissions, for a given subject type. Rules can delegate to other rules, and user objects can also have global permission grants or denials.
Add PyProtocols '_speedups' to extensions built.
Moved 'peak.util.advice' tests to 'protocols.tests'.
Misc. edits preparing for 0.5a2
Fixed not installing ZConfig schema .xml files
Added the UML 1.4 metamodel, and thus the ability to load UML 1.4 models encoded in XMI 1.1. Added support in the mof2py code generator for "unprefixing" enumerated values, so that UML and other metamodels' enumerations work correctly when loading from XMI. Fixed source distributions missing essential setup files. Rescheduled UML 1.5 and CWM support to version 0.6. Hardly any tools use UML 1.5 yet, and we can't do anything useful with CWM until we have XMI writing, and some type of UI for editing models.
Added a 'peak.running.shortcuts' command to run the unit tests. Now I'm also testing the command subsystem every time I run the tests... :)
Began the move of 'peak.interface' to a separate 'protocols' package for ease of distribution independently of PEAK. Also, removed caching of success/failed adapter lookups, because there was no way for them to be cleared when declarations were made for base classes of a class whose lookup was cached. (To do caching, I'll have to add a separate cache.) In the next pass, I'll add the new declaration API that Ty and I designed, and then change PEAK to use it, factoring out the interim API, and changing the few remaining introspections in PEAK to work via adapation. Then, it's off to documentation, unit tests, and packaging for the 'protocols' package.
Fixed nits. We probably need a way to do classProvides() that doesn't require you to have classAttr()s.
Farewell, 'zope.interface'. You served us well.
Added 'fcgiapp' to distribution; this should be the final checkin for 0.5a1, barring any bug or doc fixes that come up while prepping the release.
Fixes for documentation generation - docs for third party packages were being generated, and peak.metamodels was claiming it was still obsolete and unsupported!
Updating README/INSTALL/setup for 0.5a1. INSTALL was out of date on some matters; edited README for clarity in a couple of places.
Semi-final draft of the 'peak.running.commands' framework. It's now possible to bootstrap almost anything to run as a PEAK command object; see 'running.IExecutable'. Added new 'peak' script (Posix-like OSes and Cygwin only) that can bootstrap execution of any URL or .ini-defined shortcut. Moved CGI/FastCGI publishing command objects to 'peak.running.zpublish', since they aren't useful without the ZPublisher stuff anyway. Added "usage" capabilities for commands to display usage help and to be able to distinguish invocation errors from execution errors. Note: the diffs for this are going to suck from a readability POV, because diff doesn't deal well with the removal of a huge block of code in the same revision as significant doc rewrites or refactoring within classes. :(
Split out more generally-useful "setup" code fragments into a reusable "prologue" file.
Fixed installing deleted packages and not installing some new ones.
PEAK-Zope namegeddon, phase 2. Switched to 'zope.interface' and 'persistence', using Zope X3 Milestone 2 as a basis. Early-draft "setup" support with autodetection of an existing Zope installation. This still needs a lot of work. Since I did this on Linux, I now see the problem Ulrich was talking about on tests failing. I have some ideas about it but I still need to track it down. Probably this will mean revising the format of PEAK "import strings", which is just as well because I've wanted to clean them up anyway. (The ':' will go away, basically.)
Factored out useful setup classes for use in other Eby-Sarna distributions
REINSTALL WARNING: a package was removed from setup.py on this change, so be sure to *delete* your PEAK installation from 'site-packages' before reinstalling. Also be sure to update your checkout with 'cvs update -dPA'. Change notes: * It's now possible to use 'config.declareModule()' to patch third-party (i.e. non-PEAK) modules, and also to pre-declare inheritance or patch data for modules inherited via package inheritance. This was done to make PEAK/Zope reusage/patching easier, and also to ease patching of large generated-code models (like UML and CWM). * The patches to add "Pythonic features" to UML models are now in a separate module, 'peak.metamodels.core_addons', so that they can be shared amongst all UML versions. This was made possible by the new 'declareModule()' function. * Cleaned up and removed the now-unnecessary subpackage of UML13 that was there just to provide a home for the patches that can now be applied by "remote control", so to speak. * 'lazyModule()' now has an extra parameter that can be used to hook the initial loading of a module. This was added so that 'declareModule()' can patch modules when they are loaded.
Fixed certain setup.py operations failing if HappyDoc isn't installed; minor updates to copyright notices and installation instructions.
Re-organized setup script to allow leaving out tests, metamodels, or both. This should make it possible for people who want a compact install for "embedded" use (e.g. inside an application distributed as a binary). Tests aren't needed once PEAK is verified for your target platform, and the metamodels package will only be needed if your application works directly with MOF, UML, CWM, etc. For example, if it's a code generator, documentation utility, or a model editing program. Mostly, though, I'm adding these options so I can excuse the later addition of reams of generated code to the 'peak.metamodels' package to support UML 1.4, MOF 1.4, CWM 1.0, etc. I can always say to somebody who complains, "if you don't need it, edit the setup.py before you install". ;)
Finally replaced the old 'peak.metamodels.uml' package, with the new 'peak.metamodels.UML13' package, which is a merger of code generated using 'peak.model.mof2py' and an inheriting package which extends the generated code with a few convenience methods. The main impact on existing code is the fact that the new metamodel uses singular names (e.g. 'item.ownedElement') where plurals were previously used. Also, the test suite runs significantly faster, apparently because of the use of lazily-imported nested packages in the new generated code. (The UML model used by the test suite doesn't include any "behavioral elements", so a lot less of the UML metamodel has to be imported and run through the module inheritance machinery than before.) Be sure to 'cvs update -dPA', clean up any leftover 'build' directories, and uninstall/reinstall PEAK after this change, otherwise ghosts of the removed files and directory may hang around to haunt you.
Removed outdated TransWarp 'mof' package, since 'MOF131' works great so far. Re-enabled generation of documentation for the 'peak.metamodels' package. Be sure to use 'cvs update -dPA' to refresh your checkout, and delete PEAK from your Python 'site_packages' directory before re-installing.
Completed conversion to C of the base class descriptor methods for 'Once' attributes. Due to constraints in how Pyrex creates extension types, it was not possible to continue support for the (deprecated anyway) 'OnceClass' and 'AutoCreatable' metaclasses. This is now cleaned up pretty decently and runs the tests at least as fast as before I began the metadata refactoring yesterday (~4.1 seconds on my Windows PC). Note that if you want to build from Pyrex source or have Pyrex installed, you *must* patch Pyrex.Compiler.TypeSlots so that these two lines: descrgetfunc = Signature("TOO", "O") # typedef ... descrsetfunc = Signature("TOO", "O") # typedef ... Look like *this* instead: descrgetfunc = Signature("Tpp", "O") # typedef ... descrsetfunc = Signature("TOp", "i") # typedef ... This is a work-around for improper generation of descriptor __get__/__set__ code by Pyrex.
Refactored to allow "lazy" metadata computation, using bindings. This means that you can use attribute bindings in metaclasses to assemble metadata registries, such as those needed for XMI. Unfortunately, for this to work on types, I had to change the fundamental implementation of attribute bindings to a new implementation in Pyrex/C. The problem is that only *data* descriptors from a metaclass are invoked if there is an attribute value available in the type's dictionary or the dictionary of one of its base types. This means that trying to have 'Once' bindings that attach to classes via their metaclass, is inherently unstable unless you make use of the bindings in strict reverse __mro__ order! This problem has actually existed ever since I added the ability to use bindings in metaclasses, but because of the way things were being used, it "just happened" to look like it was working. So I had to make 'Once' a data descriptor; unfortunately this means that it has to check whether the value appears in the object's dictionary *every* time the attribute is accessed. That's still doable from Python, but the bigger problem is that type dictionaries aren't accessible from pure Python code, and the only way to implement the __set__ function on a 'Once' descriptor is by writing to the dictionary. So I wrote a Pyrex extension type to support getting at the object's true dictionary, and to implement a (relatively) fast __get__ method. The result seems to perform about as well as the old version, although I'm tempted to redo some of it in pure C to get rid of a lot of overhead that would be avoidable if Pyrex properly supported the '__get__' signature for extension types. Up next: standardizing the metaclass naming convention, documenting all this stuff, then maybe on to XMI writing...
Major speedup for module inheritance, thanks to Pyrex! The 'codeIndex()' object and associated iterators are now in C, and the speedup is quite visible. It's still not as fast as I'd like, but the next step would be to rewrite 'prepForSimulation()' in Pyrex, and it's a lot more complex than the 'codeIndex' class. Unfortunately, you can't just copy your code into a .pyx file and expect a speedup; you have to think in C even if the syntax is Pythonic. Nonetheless, module inheritance spent so much time in the old 'codeIndex.__init__' method that it was worth the hour or two it took to convert. Added support for Pyrex.Distutils to automatically build from .pyx; if you're using 'mingw32' and Greg hasn't released my fixes yet, you may want to edit setup.py to force it to compile from .c files instead and run 'pyrexc' manually against the '.pyx' files. If you want to tinker with the 'pyx' source files, you'll want to install Pyrex 0.4.6 or better.
Added 'peak.util.buffer_gap.Buffer' a "mutable string" extension type. This may later form the basis for C implementations of the 'peak.util.Code' module and module inheritance. I'm including the C code so that people without Pyrex (especially those lacking my mingw32 patches for Pyrex.Distutils) can play with it.
Refactored to remove peak.metamodels.xmi.Reading as a mixin module. There is now a peak.model.xmi module (accessible as 'model.xmi') that provides XMI loading services, and XMI metadata is now generated automatically by model classes. Note that this change also changes the signature of 'ActiveDescriptor.activate()' to better support 'super()' calls between co-operative descriptor mixins.
Updated metadata for upload to the prototype PyPI system
Added [Load on demand] rules section, and made running.clusters use it. Also added basic unit tests for peak.running.clusters.
Reorgs and and misc. cleanups; updated TODO for 0.5a1 vs 0.5final Moved ActiveDescriptor(s) classes from binding.meta to binding.once and the rest of binding.meta to model.method_exporter. Moved the method-exporter tests that lived in metamodels.tests.General to model.tests, where they really belonged, and added model.tests to the install and API test suite.
Removed OpaqueURL and refactored ParsedURL for simpler creation of URL classes. This may need another pass or two to get everything completely cleaned up. Added a test suite for peak.naming to do parse tests on a variety of the built-in URL classes, which really needs a lot more test examples. The URL classes also need better parse error messages. Last, but not least, we may need a way to map from URLs back to their strings, if they are created from arguments instead of a string. But that's probably lower priority.
Added unit tests for transactions, covering just about everything but the 'info' mapping, and error handler processing.
Adjusted HappyDoc options to suppress documentation for the unsupported-for-now 'metamodels' subpackage. This should be the last item before I can update the API docs on the web site.
Misc. doc fixes for HappyDoc.
Added a basic configuration file format, and used it to replace the schemes dictionary in peak.naming.factories, by adding a "peak.ini" global configuration file for PEAK builtins. This means that the factories subpackage is pretty much useless now; the URL classes can easily move anywhere now, like to the same modules as the implementations. It should now be easy to add lots of address schemes to PEAK. Also, subclasses of GlobalConfig can change the list of filenames used to load configuration settings, and thus perhaps read a ~.peakrc or /etc/peak.ini file, or an app-specific global configuration file. The file format is very primitive right now: ConfigParser with eval() of the settings done at file load time. Ultimately, this should move to a true lazy evaluation mode, and there are some syntactic sugar features that should be added. For right now, however, all we need are constant expressions. Last, but not least, fixed a bug in the fromURL() method of ParsedURLs.
Added Interface.Registry packages to the subpackage list. This is rather cool, since I think with a little work I can base the EigenRegistry stuff off of one of the registry types, without duplicating all the algorithmic complexity, the way I'm doing now. It might also be nice to have adapter registries in PEAK, although I'm going to wait until there's a *really* good use case before I try that one!
Added stub of Zope 3 "Persistence" package to setup; PEAK will now install it along with "kjbuckets" and "Interface".
Fixed an issue on installing to a non-standard package directory (i.e. using --install-lib or --install-platlib). Setup will now always install data files relative to wherever the distutils is actually installing the package. This used to only work if you used --install-purelib, and once kjbuckets was added to the distribution, it stopped working unless you supplied both platlib and purelib. Now it should work correctly no matter what you do, or at least as correctly as distutils itself does. (Distutils may ignore --install-purelib if the package contains any C extensions.)
Created a peak.api.tests module, which just runs tests on API packages (like binding, config, naming, etc.) and skips the old tests (metamodels) and the utils tests. Changed the "setup.py test" default to use this shorter and MUCH faster subset of tests. You can still run the full suite with "setup.py test -m peak.tests", but on my Windows machines the extra tests can add up to 20 seconds to my test times, and I rarely change anything that affects the utils or metamodel tests. I'll save those for checkin testing, and use the API-only tests for running as I change things.
Fixed up some MANIFEST settings for PEAK (had TW-specific stuff in it). Also added an 'sdist_nodoc' command to build a source distribution without docs, when HappyDoc isn't available/installed.
Added 'kjbuckets' extension to setup.py; updated installation doc and copyright notices accordingly.
Moved module inheritance/advice tests to peak.config.tests.
Changing docs from TransWarp->PEAK, referenced new site at http://www.telecommunity.com/PEAK/, prepping docs for 0.5a1 release.
Changed to not generate docs for Zope Interface package.
Made peak.storage a proper package and added it to setup.py. Added a 'finishTransaction()' message to the participant API, so that objects can be sure a transaction is really, and completely, over. Made the abstract TransactionService concrete by finishing out a few more methods and making it a binding.AutoCreated component. Now adding a transaction service to an application is as easy as 'myTxnAttribute = storage.TransactionService' in a high-level component. Also added a 'TransactionComponent' base class for things like managed connection objects and Racks. Instances automatically register with their nearest transaction service as soon as they're added to a component hierarchy. Last, but not least, I fleshed out the transaction metadata implementations for both the basic transaction service and the ZODB-compatible one. The ZODBTransactionService will interpret the names 'note', 'user_name' and 'user_path' as special, and call the note() and setUser() methods of the underlying ZODB transaction, accordingly. All other info items will be set via setExtendedInfo() on the underlying ZODB transaction.
Moved config to its own top-level subpackage, peak.config, since it doesn't really fit well with the rest of 'running' as it's shaping up. Also, removed lockfiles and dameons from the running.api, as they aren't really part of the API. Lockfiles will normally be instantiated via a URL reference, as will most Daemon providers. To create daemons, the preferred method will be: from peak.running import daemons class MyDaemon(daemons.AbstractDaemon): .... Similarly, when we have logging base classes, 'from peak.running import logs' and 'aLog = logs.SomeLogger()' will be reasonable usage as well, since logs will also normally be instantiated via URL references.
Added config package, and integrated it into binding.Component's acquireUtility() method. Note that the config API signatures ended up slightly different than in the implementation plan posted to the mailing list; notably, it didn't make sense to have 'forRoot' as an optional parameter, since *every* root needs its own local configuration, unless you manually set the same one for a bunch of them.
Added Interface package to setup. (If you're tracking CVS, be sure to "cvs update -dPA" to get the Interface directory to show up.)
Moved module inheritance from 'peak.api' to 'peak.binding', and reformatted peak.api package accordingly. Applied the following name changes:: .getSEFparent() -> .getParentComponent() ._setSEFparent() -> .setParentComponent() .getService() -> .lookupComponent() setupModule() -> binding.setupModule() adviseModule() -> binding.patchModule() configure() -> binding.configure() Also made the default '__proceed__' value a built-in, so that it's not necessary to import it. This concludes the essential code-level transformations from TransWarp to PEAK. Almost everything should be in its long-term home now, with its long-term name, although the 'model' package may receive some adjustments by the time a tutorial is written for it. Following this check-in, the repository will be considered stable, and CVS checkouts of PEAK will be possible.
Added naming package to setup, fixed a syntax error.
Hacked on it until all tests pass... But still a lot of re-name, re-doc, re-org to go. Still need to move Caching over, and there are some test package splits that need to be done (metamodels->model). Need to make the Once and other peak.binding package import idioms consistent, too. But at least the tests run. The repository is not yet stable, however.
First pass of random conversions from TW -> peak
Added 'TWX' package for extensions; added 'TWX.Diagrams.GraphViz' diagramming utility module. Very hacky and first-draft, with no unit tests, but I've manually verified most of the functionality so far.
Documented setup.py 'test' command, and added an option to specify which test module should be run.
Added a 'test' command to 'setup.py' that installs and then tests all of TransWarp. (It saves me time running the unit tests while I'm writing new code.)
Fixed 'happy' command not to build docs for 'tests' packages.
Many changes in preparation for 0.2 final, including: * Added 'SEF.bindToParent()' and 'SEF.bindToNames()' specifiers to allow more flexible component parameter bindings. * Fixed the base class "rebind by name" bugs in module inheritance, and updated the documentation to more clearly reflect what it is that metaclass generation and module inheritance does and does not do. Added test cases to prevent regression of the rebind-by-name problem. * The 'setup.py' script features a new command, 'happy', which can be used to generate the API reference docs, and this command runs as part of the 'sdist' command to build source distributions. * The API reference docs in the source distribution has been moved from the 'doc' directory to 'docs/html/reference'. * Added 'CHANGES.txt' file.
Updated website URL, and fixed MANIFEST.in to avoid including the (currently out-of-date) examples directory.
Misc. Documentation fixes, clarifications, and enhancements.
Pre-release documentation and cleanup sweep, part 3. Rearranged all the test stuff to meet Zope.org's test packaging conventions. Added module docstrings to the Database package, and shuffled a few things around there to break up the code better. Looks like the last package left for this treatment is Utils...
Pre-release documentation and cleanup sweep, part 2. Cleaned up the rest of the 3-letter packages (SEF, MOF, and API), replacing StructuralModel with SEF along the way. Also moved some of the key metaclasses into their own module, TW.API.Meta.
Fixed the %&$#(@%& distutils data file path problem, after much Googling and Use of The Source.
Fixed bad data file path
Initial (untested) setup.py
Powered by ViewCVS 1.0-dev