Log of /PEAK/setup.py

Parent Directory

No default branch
Bookmark a link to HEAD: (view) (download) (as text)

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