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 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).