[Subversion] / PEAK / CHANGES.txt  

Diff of /PEAK/CHANGES.txt

Parent Directory | Revision Log

version 1629, Sat Jan 24 00:07:51 2004 UTC version 1633, Sun Jan 25 02:32:15 2004 UTC
Line 683 
Line 683 
   
   - The 'peak.util.imports.whenImported' function didn't work.    - The 'peak.util.imports.whenImported' function didn't work.
   
   
   
   
 Fixes and Enhancements since Version 0.5 alpha 1  
   
  Changed, Enhanced, or Newly Deprecated Features  
   
  - Added a 'shellcmd:'  URL scheme that returns a function that calls  
    'os.system()' on the body of the URL.  It's intended for use as a command  
    factory, as is needed by the 'URLChecker' periodic task.  
   
  - You can now define adapters from arbitrary types to 'binding.IBindingNode',  
    and thus be able to use them as part of a component hierarchy - without  
    needing to directly add 'getParentComponent()' or 'getComponentName()'  
    methods to them.  
   
  - Added experimental 'invoke.c' script for POSIX-ish platforms with funky  
    '#!' support, or lack thereof.  
   
    'invoke' is designed to be used like this::  
   
      #!/usr/local/bin/invoke peak somearg otherarg...  
   
    This should work on most sane platforms with a long-enough commandline.  
    (See "this page":http://homepages.cwi.nl/~aeb/std/hashexclam-1.html for  
    details on the insanely incompatible ways different Unixes interpret '#!'  
    lines.)  
   
    The script is not currently built or installed by setup.py.  On the  
    platforms it's targeted at, you should be able to build it with::  
   
      gcc -o invoke invoke.c  
   
    (Yes, it really is that simple of a script.)  
   
  - Added a ZConfig schema for 'running.commands.EventDriven' applications,  
    a ZConfig component definition for adaptive tasks, and a running shortcut  
    called 'EventDriven'.  
   
    It should now be possible to do this::  
   
      #!/usr/bin/env peak EventDriven  
   
    at the top of a ZConfig file formatted according to the new schema, and  
    have it run.  There are two periodic tasks that can be configured and  
    run from such a file: 'CleanupFiles' and 'URLChecker'.  'CleanupFiles' will  
    delete files matching a pattern that are older than a certain age, while  
    'URLChecker' will check to see if the target of a naming system URL is  
    up/available/working, and if not, runs a command to restart it.  As an  
    amusing demo, try specifying a 'file:' URL with a 'shellcmd:touch theFile'  
    to recreate the file, then add a 'CleanupFiles' that deletes the file the  
    checker looks for.  This can be hours (well, minutes) of exciting fun as you  
    watch the dueling daemons undoing each others' work.  
   
  - Added 'zconfig.schema' URL scheme that loads an enhanced ZConfig schema  
    object that can act as a command line interpreter using the 'peak' script.  
   
    To use it, run 'peak zconfig.schema:urlToSchema urlOfConfig'.  Or, add  
    a line like this::  
   
      #!/usr/bin/env peak zconfig.schema:pkgfile:some.package/schema.xml  
   
    to the top of a configuration file, and make the configuration file  
    executable.  Note that the schema specified must convert to an object  
    that's usable with the commands bootstrap framework.  Also note that  
    if you have a local PEAK_CONFIG file, you can add a 'peak.running.shortcuts'  
    entry to shorten the URL reference in your #! line.  E.g.::  
   
      #!/usr/bin/env peak mySchema  
   
    will suffice if you have defined 'peak.running.shortcuts.mySchema' as  
    'naming.LinkRef("zconfig.schema:pkgfile:some.package/schema.xml")'.  
   
    There is also a 'peak ZConfig urlOfSchema urlOfConfig' variant, that was  
    added to support putting '#!/usr/bin/env peak ZConfig' at the top of  
    schema files, but unfortunately that's not valid XML.  
   
  - Standardized file-based URL syntaxes (e.g logfiles and lockfiles) to  
    follow RFC 1738/2396, and Python 'urllib'.  This shouldn't affect much  
    besides the canonical forms of the URLs.  Added 'pkgfile:some.pkg/filepath'  
    URL syntax for ease of referring to files near modules.  (A convenience  
    intended mainly for referencing ZConfig schemas.)  
   
  - 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.  Also, mof2py no longer emits 'config.setupModule()'  
    calls in generated code, as in practice they are not needed.  
   
  - Running 'peak test' from the command line is roughly equivalent to running  
    'unittest.py', except that the test suite defaults to the PEAK test suite.  
    You can, however run any test suite from the command line with a dotted  
    module/attribute path, e.g 'peak test foo.bar.test_suite'.  
   
  - 'binding.Acquire()' now accepts a 'default' value argument, and  
    'binding.New()' no longer accepts the 'bindToOwner' flag.  
   
  - There is a new 'binding.IComponentKey' interface that is used to implement  
    'IComponent.lookupComponent()'.  Now you can implement this interface,  
    or create an adapter for it, in order to make an object usable as an  
    argument to 'binding.lookupComponent()' - and therefore usable as a key  
    for 'binding.bindTo()' or 'binding.bindToSequence()'.  Not that it's  
    necessarily very useful to do so; you're probably better off simply  
    creating a naming scheme.  But it might be useful for lookups done  
    in the context of classes, since naming schemes aren't usable there.  
    (It was actually added in order to factor out all the type testing that  
    'lookupComponent' used to do, so it doesn't matter if it's useful for  
    much else.)  
   
  - PEAK has been refactored to avoid the use of 'isImplementedBy()' and  
    similar introspection, in favor of 'adapt()'.  As a result, some  
    'peak.naming' interfaces have changed.  This should not affect you  
    if you are only subclassing PEAK-provided naming components and not  
    implementing these interfaces "from scratch".  However, the various  
    'isAddress', 'isAddressClass', 'isResolver', and 'isName' APIs have  
    also been removed, as they were based on 'isImplementedBy()'.  
   
  - REMOVED ability to use '__implements__' and '__class_implements__' to  
    declare support for interfaces.  Use 'protocols.advise()' or a related  
    API to do this now.  The 'protocols' package is available automatically  
    from 'peak.api'.  
   
    Similarly, the ability  to use 'isImplementedBy()' with interfaces declared  
    by PEAK is REMOVED.  You can still use 'isImplementedBy()' with Zope  
    interfaces, of course, but we recommend you switch to 'adapt()', which  
    should work with both PEAK and Zope interfaces.  
   
  - Replaced all use of 'zope.interface' with 'protocols' package because  
    the 'protocols' package:  
   
    * is considerably smaller and simpler than 'zope.interface'  
   
    * produces Interface objects that can be inspected with the Python  
      'pydoc' and 'help()' tools  
   
    * supports and implements the PEP 246 'adapt()' protocol  
   
    * transparently supports transitive adaptation - i.e. if adapter AB  
      adapts from A to B, and adapter BC adapts from B to C, then an adapt(x,C)  
      where 'x' is an 'A', will be implemented as BC(AB(x)).  
   
    * Supports "open protocols" that allow you to "superclass" a protocol  
      to create a subset protocol; objects that support the first protocol  
      will automatically support the subset protocol.  For example, if one  
      person defines a "dictionary" protocol, someone else can create a  
      "read-only dictionary" protocol, and all objects supporting the  
      "dictionary protocol" will be considered to implement the "read-only  
      dictionary" protocol.  
   
    * can interoperate with other interface packages, including Zope's, but  
      does not require them  
   
    * works with module inheritance (for everything but moduleProvides(), and  
      we should get to that by 0.5a2)  
   
    * lets you use Interfaces as abstract base classes (i.e., you can  
      inherit from an interface and turn it into an implementation, and  
      you can define default attribute values or method implementations in  
      your interfaces  
   
    * Lets you mix interface declarations from any number of frameworks and  
      any number of interface types, in a single 'implements()' or  
      'classProvides()'  
   
    * uses adaptation as the fundamental approach to dealing with interfaces,  
      and avoids the use of 'isImplementedBy()'.  In the *rare* case that you  
      need to introspect rather than adapt, you can always call adapt() and  
      check the result.  (But introspection usually means that you're using  
      interfaces as a form of metadata; it's better to create an explicit  
      interface that provides the metadata you seek, and adapt to that  
      interface, than to use interfaces as data.)  
   
    Most of these features are unavailable in 'zope.interface', and some have  
    been declared by the Zope Pope to be unacceptable or undesirable features  
    for Zope interfaces.  (Others may be available in some form in future  
    versions of Zope X3.)  So, we no longer require or distribute  
    'zope.interface'.  
   
  - The signatures of the 'getObjectInstance()', 'getStateToBind()', and  
    'getURLContext()' methods in the 'peak.naming' package have changed, to  
    place the context or parent component as the first, non-optional argument.  
    (If you don't know what these methods are for, you don't need to do anything  
    about this, as they are part of the naming package's extensibility  
    framework.)  
   
  - 'binding.bindTo()' now accepts a 'default=' argument, whose value will be  
    used in case of a 'NameNotFound' error.  
   
  - DEPRECATED 'naming.ParsedURL'.  It will disappear in 0.5 alpha 3 or beta.  
    It is replaced by the new 'naming.URL.Base'.  The 'naming.URL' package  
    provides a new URL parsing framework based on 'peak.model'.  Upgrading from  
    'ParsedURL' to 'URL.Base' is trivial for ParsedURL subclasses that used  
    only the 'scheme' and 'body' fields, and in fact may not require any  
    changes except for the choice of base class.  Also, the 'retrieve()' method  
    of URLs is deprecated; please begin defining the 'getObjectInstance()'  
    method instead.  This is to cut down a bit on the number of ways that the  
    naming package spells the idea of retrieving something!  
   
    For more complex URL classes, the '__init__' methods go away, 'parse'  
    methods change slightly, and explicit field definitions (using  
    'model.structField' or similar) are required.  See PEAK's 'URL.Base'  
    subclasses for examples.  There is also a sophisticated parsing and  
    formatting framework (see the 'peak.naming.URL' and 'peak.util.fmtparse'  
    modules) that can be used in place of the old regex-based approach.  
   
  - Added 'peak.util.fmtparse', a parsing and formatting framework, and  
    integrated it with 'peak.model' so that any element type can have a  
    syntax for parsing from, or formatting to, a string.  
   
  - Added 'binding.whenAssembled(...)' as syntax sugar for  
    'binding.Once(...,activateUponAssembly=True)'.  
   
  - Removed 'LOG_XYZ' convenience functions from 'peak.api', and refactored  
    'peak.running.logs' to use a PEP 282-like interface, 'running.ILogger'.  
    Under the new scheme, messages must be sent to a specific entry point  
    (e.g. 'self.logger.warning("foo")').  Components can bind an attribute  
    directly to a logger object, or via configuration properties or utilities.  
    PEAK components that do logging all define a 'logger' attribute, bound  
    to a configuration property in the 'peak.logs' property namespace.  By  
    a default in 'peak.ini', 'peak.logs.*' is configured to output messages  
    of 'WARNING' priority or higher to 'sys.stderr'.  
   
    For compatibility with the PEP 282 logging package, a 'logging.logger:'  
    URL scheme has been added; looking up the URL '"logging.logger:foo.bar"'  
    is equivalent to 'logging.getLogger("foo.bar")', unless the 'logging'  
    package is not available, in which case the configuration property  
    'peak.logs.foo.bar' will be looked up in the target context of the  
    lookup.  Optionally, you can configure the 'logging.logger' URL scheme so  
    that it only uses PEAK loggers, and never uses the PEP 282 loggers.  
   
  - Added 'binding.metamethod()' wrapper for metaclass methods that might  
    not be accessible from their instances if the instances (classes) also  
    defined the method for *their* instances.  You must now use this wrapper  
    on any such metaclass-defined methods, as PEAK no longer works around  
    this via the 'x.__class__.foo(x,...)' trick that was used previously.  
    In particular, if you have metaclass definitions of 'getParentComponent',  
    '_getConfigData', 'getComponentName', or 'notifyUponAssembly', you need  
    to wrap them with 'binding.metamethod' now.  
   
  - Made 'NOT_GIVEN' and 'NOT_FOUND' recognizable by humans (they 'repr'  
    and 'str' to their names) and by Python (they can be pickled, and  
    when restored they come back as the same object).  
   
   
  Corrected Problems  
   
  - Fixed a problem in ZConfig 'schema.dtd'; I used 'PCDATA' where I should've  
    used 'CDATA'.  
   
  - Fixed a problem with 'binding.supertype()' not working correctly if the MRO  
    it was searching contained a "classic" class.  Now 'supertype()' skips any  
    classic classes it finds.  (It probably should be rewritten entirely.)  
   
  - Fixed misc. problems with 'fromZConfig()' component constructor  
   
  - Fixed source distributions missing essential setup files  
   
  - Fixed a problem with assembly events, where a parent component that didn't  
    need assembly notification, wouldn't ever notify its children of assembly  
    if they requested the notification after the parent had already received  
    it.  
   
  - Fixed a bug in automatic metaclass generation that caused extra unneeded  
    metaclasses to be generated.  
   
  - Fixed 'naming.lookup()' and related APIs not setting the parent component  
    of created objects without an explicitly supplied 'creationParent' keyword  
    argument.  This used to "sort of work" when we had implicit configuration  
    parents, but was broken when we went "all explicit" for 0.5 alpha 1.  
   
  - Fixed a problem where initializing single-valued immutable fields of  
   'peak.model' types did not perform type/value normalization.  
   
  - Fixed a problem where bindTo would use the attribute name as the  
    default value for a lookup, if the requested name/property/utility  
    was not found.  
   
  - Fixed 'mof2py' generator script not working  
   
  - Fixed model.Element not getting parent component set when passed as a  
    constructor argument.  
   
  - Fixed property/utility lookups not working correctly on model.*  
    objects.  
   
  - Fixed IndentedStream generating all-whitespace lines  
   


Generate output suitable for use with a patch program
Legend:
Removed from v.1629  
changed lines
  Added in v.1633

cvs-admin@eby-sarna.com

Powered by ViewCVS 1.0-dev

ViewCVS and CVS Help