Pyro Change Log (archive)

The recent Pyro versions can be found in the regular change log.

Pyro 0.1 has been lost in the dust. It wasn't suited for publication anyway, I guess :-)

Pyro 0.2

Pyro 0.3

• MAJOR: added Dynamic Proxies! Clients don't need to have a precompiled proxy file available any more! Check out core.getProxyForURI/DynamicProxy.
• MAJOR: reworked the configuration possibilities. Check out __init__.py.
• Moved config items to a class in __init__.py. They are accessed using 'Pyro.config.<item>'.
• Made the port and broadcast port configurable independently. The command lines now accept options to specify either or both ports.
• naming: added delay in broadcast loop (wait a little for replies to arrive), Naming Service now returns PyroErrors instead of regular exceptions.
• core: Cleaned up the Pyro exception passing, added DynamicProxy and getProxyForURI
• pyroc: fixed bug in method output code (could forget a comma)
• nsc: fully rewrote the parsing code to use the util.ArgVParser
• scripts: the Window .bat files now use %$
• added util.py, which contains a basic sys.argv parser like getopt().

Pyro 0.4

• naming: changed broadcast server to reflect changes in Python 1.5.2's SocketServer module. Pyro now requires this new SocketServer module (which works with previous Python versions, too, so you could only replace the SocketServer module and keep the rest of your Python installation intact).
• naming: fixed bugs when reporting exceptions ('entry already exists' and 'not found').
• util: added getUUID function, and a script genuuid.
• core: Pyro objects are now identified by a full UUID, instead of a simple Python id(). This should prevent nasty object ID problems, especially later when persistent naming and object activation will be implemented.

Pyro 0.5

• MAJOR: the Pyro Naming Service now is a Pyro object itself, too. It can be accessed through its Pyro interface.
• More specific exceptions (ProtocolError, URIError, DaemonError, NamingError...)
• It is now possible to connect objects without the presence of a Naming Service.
• core: the Daemon can now handle requests for others too, by a callback mechanism. Also removed up the server-side exception trace info when the exception is generated on purpose, and added a nice message when the daemon cannot be started.
• naming: many changes to make the Name Server a Pyro object itself. Finding the NS is now done through the NameServerLocator, which returns a regular Pyro proxy for the NS. No NameServerClient is needed anymore.
• util: tweaked the way the timestamp in URIs is generated.
• config: more configurable items.
• scripts: Pyroc.bat now uses %$, too (oops!)

Pyro 0.6

• Added xnsc, a naming service control tool with a GUI (uses Tkinter).
• The naming service can be launched in 'persistent mode': it will keep the naming directory in a persistent database on disk. EXPERIMENTAL!
• core: added 2 configuration variables in Pyro.config: PYRO_PATH and PYRO_STORAGE.
• core: added method to ObjBase to set a fixed (persistent) object UUID.
• core: slight change in the init code of PyroURI, it can now be created directly from a URI string, instead of using initFromString.
• core: the Daemon now has preliminary support for persistent objects: connectPersistent and disconnectPersistent methods were added. LIKELY TO CHANGE!
• naming: added a persistent name server class PersistentNameServer. Also added some code to deal with this when using the 'ns' command line tool: a new option '-db' has been added to specify persistent mode.
• naming: the broadcast server now binds on '' instead of the hostname. This appears to be more compatible (on some systems it was impossible to connect to the broadcast server).
• naming: implemented graceful shutdown command. The server also uses a timeout loop for the requests (because otherwise ^C wouldn't break gracefully on WinNT - Duh).
• scripts: nsc (and xnsc) now print a sorted list (and have the shutdown command).
• scripts: the .bat files now won't echo the python command anymore.
• utils: ArgParser changed to use None instead of 1 when no arguments are given to a certain option.
• test: testclient will use dynamic proxy automatically if no static proxy is found. Also, it will try a direct connect if the NS lookup by broadcast fails.

Pyro 0.7

• bumped all versions to 0.7
• NOTE: because of some changes you will have to generate your proxies again with pyroc!
• core: separated the Exception types and the protocol adapters to errors.py and protocol.py.
• util: added a Logger object, Log. It is used throughout Pyro to log messages, warnings and errors. You can configure the logfile and the trace level settings with some new configuration options. Ofcourse you can use it for your own logging purposes too.
• init: changed the way configuration items are set up. If a corresponding environment variable exists, that value is used. Otherwise the default applies. This works for all configuration options except PYRO_NS_NAME because that is a registered name and should not be changed.
• naming: the naming server now writes its URI to a special output file. This can be used to contact the naming server if you can't use the broadcast locator for some reason.
• uuids: renamed UUID to GUID (Globally Unique ID). You can never be sure that your ID is Universally Unique, so I changed the name. Also, the genuuid scripts have been renamed to genguid.
• changed default pickling mode to binary, to improve performance. A new configuration option lets you choose between ASCII or binary.
• pyroc: fixed a problem where the 'self' argument of a member function had a different name. Pyroc now uses 'S' everywhere.
• pyroc: added support for inherited classes. A module within a Python package is not yet supported as input!
• pyroc: explicit checks against special Python methods __xxx__. They are not allowed in the proxy code.
• MAJOR documentation update.

Pyro 0.8

• A few fixes in the source comments.
• Added separate user logging facility and fixed small bug in logger code (it was too picky on the arguments).
• Moved some protocol dependent code from core.py to protocol.py
• New exception model! See documentation! Basically, every exception on the server side will be catched and raised on the client side.
• Naming server and the nsc and xnsc tools are stricter with the names and URIs they allow.
• GUIDs are now 128 bit (instead of 144) and Pyro can use Windows GUIDs on the Windows platform. This is configurable trough a new configuration item PYRO_USE_WIN32GUID. This is not the default and will work only on the Windows platform, because the Python COM extension is used for this.
• New genguid script with '-w' argument to generate a Windows GUID if possible.
• Fixed some things to allow for special 'localhost' optimization (the reduced overhead of some network implementations when using 'localhost' instead of the real hostname). The changes are:
  • Pyro daemon now binds on '' instead of hostname. Previously, URIs with the 'localhost' hostname couldn't be bound.
  • The PyroURI class has a new optimizeLocalhost method, which -if possible- optimizes the URI for localhost addressing.
  This also paves the way for more optimizations might be added when Pyro detects a local URI. (for instance, using IPC instead of going trough the network)
• Implemented Delegate pattern for remote object implementations. Instead of subclassing your object implementation from Pyro.core.ObjBase, you just create a Pyro.core.ObjBase object and tell it to use another object as a delegate.
• New ArgParser in util.py, to support more convenient script arguments. A few scripts have slightly altered syntaxes now, which should be more convenient. The old syntax should still work however.
• Documentation updates. Major addition is the new chapter with a practical guide about how to develop Pyro programs.

Pyro 1.0

• MAJOR: Reimplemented the PYRO protocol. It now uses a MUD-like system instead of a webserver-like system. The protocol used to create a new socket connection for each method call. This is inefficient and resource hungry. The new implementation uses a single socket for each Pyro object, and all method calls and replies are passed over this connection. The connection remains active until the object is no longer needed. The new implementation no longer has the serious problem that the previous implementation had on most machines: when a lot of method calls were made, the system would crash with some sort of 'resource unavailable' or 'out of memory' error. The new protocol is also faster than the previous one on all systems.
• Because of the new protocol, I think Pyro now deserves the version 1 status: bumped all version numbers to 1.0
• The Pyro Daemon inherits from the new TCPServer base class (in protocol.py). This server replaces the SocketServer.TCPServer. The new server keeps a list of active connections, while the old one operated like a webserver: it created a new socket connection for each request.
• Pyro Daemon has been adapted to the new protocol.
• NOTE: The new PYRO protocol is incompatible with the older versions. Communication is impossible between different Pyro versions. You should upgrade all Pyro installations to the new version. However, user code does not have to be changed. Old code still runs on top of the new implementation (the API has not been changed).
• The Windows .bat scripts now use #* instead of #$ (which didn't work on the standard Windows95/NT command prompt).
• xnsc handles communication errors better.
• Organized the tests in the test directory and added some readme files. Also added some more tests/examples.
• Moved some socket code out of other modules to protocol.py. Now only naming.py and protocol.py have socket code.
• Removed the NULLAdapter.
• Removed the pickling of NS system commands. They're simple strings now.
• Added socket send/receive helper functions in protocol.py for robust data transmission. The new protocol code uses them. Performance is lower but the new code should guarantee correct behaviour even at high network loads with many packet losses and fragmentations.
• New exceptions SocketClosedError and ServerFullError.
• Removed RemotePyroException (unused).
• Small change in the xnsc GUI: better resizing
• The new protocol enforces a limit on the number of simultaneous connections to each Pyro daemon. This is for protection of the server machine. There is a new configuration item PYRO_MAXCONNECTIONS that sets this limit. Currently the default is 200.
• The unregister method of the naming service now raises a NamingError when the name is not known. I added this because usually this signals a typo in the calling code (it should never unregister an unknown name).
• Documentation updates; manual is finished except for the implementation chapter.

Pyro 1.1

• MAJOR: Naming Service now has a hierarchical namespace. It has groups, which can contain other groups or names. By default, a dot ('.') in a name is the group separator, so that "group1.group2.name" is a hierarchical name. Notice that this is much like DNS's host/domain name scheme, but in reverse order, rather like a directory structure in a disk file system. The big gain from all this is that you can have different "domains" (namespaces) in your Pyro environment. With a simple change of the default namespace group your system uses a different "domain" and the object names will not interfere with other systems (provided your namespace group is unique). For an application of this, see the new test programs, which now all use the ':test' namespace group. Also, it opens the gates for an even more sophisticated naming service: a distributed federated hierarchical nameservice (wow!! :-)
• The default or de facto namespace group is ":Default". This means that Pyro code that does not (yet) use the new naming scheme will wind up registering all its object names in this namespace group. That's nice because this is a simple way to avoid name clashes with legacy Pyro code and new code.
• Adapted the NS proxy to enforce the default group on all names that are not absolute from the root. It is now required that all names passed to the NS are absolute (fully expanded), the hand coded NS proxy takes care of this. Note that a proxy obtained for the NS by other means does not have this feature and will likely break your code! Notably, the use of a dynamic proxy for the NS will no longer work correctly. Always use the static proxy from the naming module.
• Added configuration item PYRO_NS_GROUPSEP, which is the character that separates groups in names. By default it is a dot ('.'), but if this proves incompatible with existing naming schemes (that use dots in the names), just change it to something else. Notice that this item is only examined once: at startup time. You have to restart the Naming Service if you change this item.
• Added configuration item PYRO_NS_DEFAULTGROUP, which is the default group name in which names are located. This simplifies partitioning your name space greatly. Notice that the Name Server proxy code is hand crafted to enforce this name.
• Added configuration item PYRO_NS_ROOTCHAR, which is the default escape character at the beginning of names, which indicates the name is absolute from the root.
• Changed the config item for the name server name to include a root character. Existing code should not break (if it does, you probably didn't use PYRO_NS_NAME...
• Extended the name server object with three new remote methods for hierarchical naming support: createGroup, deleteGroup and list. Furthermore, status has been renamed to flatlist. This suggests better what it does: return a flat dump of the namespace.
• Extended nsc and xnsc with the new naming service features: list, creategroup and deletegroup commands. (The old list command was renamed to listall).
• Simplified dynamic proxy. It used to create a invocation object with each method call, this is no longer so.
• Fixed bug in protocol.py where a KeyError in a method invocation was always treated as if a method call on an unknown object was tried, even when the object was correct (but raised a KeyError)
• Naming service will no longer crash when an unexpected exception occurs while it is running. It will log and print the error and resume operations. A ctrl-c (KeyboardInterrupt) will still abort it, however, as will sending a shutdown command.
• Small change in the Daemon in core.py. If a ProtocolError is detected (for instance, an invalid header), the connection is dropped and operations are resumed. Pyro used to block or crash when a non-Pyro client connected, such as a plain telnet or a web browser pointed at Pyro's socket.
• Test servers and clients are now using common code bases. They're registering their names in a new ":test" group (namespace) too, to help avoid conflicts with your own names. Servers will no longer crash if their name is already registered (they just register again).
• Fixed a few small errors in some of the test programs, and created an electronic banking example to be a nice starting point for Pyro applications.
• Fixed bug in some default arguments to functions, where config items were used. Now they are parsed at use instead of at module import time.
• Added '-k' switch to ns that will start the NS in a mode in which it ignores shutdown requests sent by nsc. This is a crude form of security, to protect the NS for malicious shutdowns.
• Documentation updates about the new naming scheme.
• New example added that uses the new naming functions.
• Configuration files! You can now use a configuration file that contains all required Pyro config options. It's no longer necessary to use a big list of environment variables.
• New configuration item PYRO_CONFIG_FILE. Only useful as environment variable, it points to the configuration file Pyro has to use.

Pyro 1.2

• Fixed bug in TCPserver code (could skip connections). Please update all Pyro installations because this was a rather nasty bug.
• Daemon.connect now returns the URI it connects the object as. This is convenient for servers that want to use the URI immediately without having to consult the nameserver.
• It's now possible to get/set attributes on Pyro objects with normal Python syntax! (changes to ObjBase and new DynamicProxyWithAttr) You have to update all Pyro installations if you want to use this new feature. If you don't use it, Pyro 1.2 should work together with version 1.1. Notice that there is a performance hit of a few percent when you use DynamicProxyWithAttr instead of the regular DynamicProxy to support the attribute feature.
• Server objects can now create new Pyro objects and marshal Proxy objects to the clients! (changes to DynamicProxy: it delays binding until actually needed, and they can now be safely pickled).
• Added two new examples to show the use of the new attribute getting/setting, and the creation of new Pyro objects on the server.
• Fixed bug in proxy code: nested method calls didn't work. For instance, obj.setCount(obj.getCount()+1) now works correctly.
• Daemons (servers) now have a port range. This means that they try to obtain a network port within a range, instead of a single configured port as it was before. The port range allows you to start multiple daemons/servers on a single machine, they now automatically select the next available network port.
• New configuration item for the port range: PYRO_PORT_RANGE.
• Upgraded pyroc to 1.2; static proxies now also support direct attribute access.
• Documentation updates for new features.

Pyro 1.3

• Removed the DaemonSlave class. Moved it into the Daemon class. Also required small change to TCPServer.
• GUID format changed: internally, GUIDs are now treated as a 128 bit binary number (represented as a string of 16 8-bit characters). This saves memory and network bandwidth. Visually, the number is printed as 4 chunks of unsigned 32 bit hex, separated by a dash.
• Because of the previous change, the PYRO protocol is no longer compatible with the previous versions. It identifies itself with version 1 rev 3 and raises "incompatible version" exceptions if you try to connect with other protocol versions. Please update all Pyro installations to version 1.3
• To handle versioning things better, a few changes in protocol.PYROAdapter were also necessary.
• Added optional hostname argument to TCPServer and Pyro.core.Daemon. The ns command has a new option "-n" to specify a specific hostname to bind the server on.
• Removed optimizeLocalhost method from PyroURI
• URIs no longer use hostnames, they now encode the IP addresses directly. This solves some problems when a DNS service is not available. PyroURI consequently has an address member instead of the previous host member. There are some small changes throughout the code to support this.
• Removed 1.5.2 dependency on os.path.abspath.
• Fixed bug in Daemon handleRequest loop: in contrast to what the documentation says, it didn't return after a request had been processed. It now does.
• WIN32 GUIDs have been removed, and the corresponding configuration item too (PYRO_USE_WIN32GUID).

Pyro 1.4

• One word: multithreaded. A few changes in the TCPServer allows it to run in multithreaded mode on systems that have Python threads. Please read the Rules and Limitations chapter for more information. Note that the multithreaded capabilities have not yet been tested very much and probably aren't very stable.
• Added PYRO_MULTITHREADED config item to specify whether a Pyro server should be multithreaded or single threaded. It defaults to 1 (multithreaded) on systems that support this.
• Fixed a socket bind() error in the NS; it now correctly pays attention to a supplied specific hostname to bind the server on (the BroadcastServer still used to bind on '' - fixed).
• Removed a socket bind() call from the NameServerLocator.
• Fixed small typo in xnsc: the port number of the NS is now correctly displayed.
• Added "quickstart" example that uses John Wiegley's remote.py module. It makes using Pyro extremely easy: look at the client and server code!
• Added "multithread" example that shows the need of a multithreaded server (as supported since this release).
• Added __copy__ method to the proxy code, which creates a local copy of a proxy object (with a new connection to the remote object).
• Fixed bind() and connect() calls in protocol.py to be compatible with Python 1.6.
• Fixed possible socket binding error in Pyro servers by setting socket option to reuse local address.
• Fixed problem with binary GUID: int2binstr could return a string with less bytes than expected which creates an invalid binary GUID. The code now passes a required string size and the GUID is now always 4*4 bytes.
• Fixed bugs that prevented the use of AttrProxies with delegated objects. You can now use direct attribute access with objects subclassed from ObjBase or delegated objects.

Pyro 1.5

• Fixed multithreading issues, most notably the protocol errors ("invalid header"). (An incoming request is now fully read from the socket before a thread is dispatched to process the method call).
• Protocol update. You must update all Pyro installations because the new PYRO protocol is incompatible with the previous one.
• PYRO protocol can now compress the messages to save bandwidth, for instance over low-speed connections such as modem. You can control this with the new configuration item PYRO_COMPRESSION. However, the current solution is temporary and is likely to be replaced with a more general implementation. The zlib module is used for compression. If you don't have zlib, Pyro still works, but without compression.
• Fixed a reference cycle in ObjBase when not using delegate.
• Small change to examples/quickstart: existing name is silently overwritten in Name Server.
• Small change in Pyro_dyncall method of ObjBase that makes it a little more generic when checking for 'local' attributes.
• Small change in error message for INVALID HEADER in protocol.py, now prints socket address.
• Xnsc tool is now a bit wider so more text fit in the window without wrapping.
• Removed __call__ method from DynamicProxy. I assume nobody ever used the only benefit it provided (that proxy('method') was slightly faster than proxy.method()).
• Configuration files are handled a little different at startup. If you don't specify a specific config file with the environment setting, Pyro checks for a Pyro.conf file in the current directory. If it exists, Pyro uses it as a configuration file. If it doesn't exist, Pyro uses the default built-in config. Furthermore, Pyro now raises a PyroError if somehow a config file can't be read.
• Daemon prints a more verbose error message if it can't start.
• Pyro server now raises a PyroError if it can't load the Python module that is needed for the code of objects that were passed in a remote call.
• "quickstart" example has been extended. New version of remote.py and a very convenient pyrorun script. (John Wiegley)
• Mobile agent example added; "agent" (it comes close but it is not yet a real mobile agent - the code doesn't yet travel across the network)
• Small documentation updates and fixes.

Pyro 2.0

• NEW MAJOR VERSION. Because of all new features mentioned below.
• True mobile agent support! Pyro can now automatically push Python code across the network to make mobile agents possible. See the "agent2" example.
• Persistent Naming Service. See relevant documentation! (the new name server chapter)
• Added rns script; this script restarts the NS automatically after a shutdown or crash.
• Documentation updates (examples + new name server chapter + feature chapter contains much more info).
• Changed old persistence code in core.py.
• Added PersistentNameServer class in naming.py, which implements a NameServer that uses the hierarchical file system on your disk to store its database in a persistent way.
• NameServer now always returns PyroURI instances from resolve. In the past it could also return URIs as strings.
• It's no longer possible to delete the root group from the NS.
• Removed Python 1.5.1 workarounds ('extra' dir with socketserver module, abspath workaround in config module). Please upgrade to at least Python 1.5.2.
• Socket code no longer throws socket.error but Pyro.errors.SocketClosedError exceptions.
• PYROAdapter has new rebindURI method to support the new auto reconnect/rebind feature when a network problem occurs.
• PYROAdapter now raises a ProtocolError when it receives a request for an unknown object ID.
• ServerFullError exception has been removed!!! You must change your code that used it. It has been replaced by a more general ConnectionDeniedError exception.
• Generalized new connections check: the daemon now has a new connections validator, which can be replaced by a custom version. The default version implements the old behaviour; checking if the number of connections is less than the maximum amount configured in PYRO_MAXCONNECTIONS. See relevant documentation about the validator.
• Added "denyhosts" example to show custom connection validator feature.
• Added "autoreconnect" example to show auto reconnect feature.
• Name Server now has security plugins; one for validating broadcast requests, and one new connection validator as described above. See relevant docs.
• Added "NS_sec_plugins" example to show the NS security plugin feature.
• Added "agent2" example with true mobile agent code.
• Added PYRO_MOBILE_CODE config item to enable mobile code.
• Added PYRO_DNS_URI config item to use symbolic DNS hostnames in URIs instead of fixed IP addresses
• Added support for mobile code in Pyro.core.ObjBase.
• Performance tuning in core.py; PROTOCOL IS INCOMPATIBLE with previous version.
• Slight addition to Pyro.core.Daemon: extra publishhost argument to use in case of firewall situation. See Features chapter.

Pyro 2.1

• Pyro is now under the GNU LGPL. See "LICENSE".
• Fixed spelling errors in the documentation.
• Removed some config items to make things less complex. You have to remove them from your Pyro.conf files too:
• Removed config item PYRO_NS_NAME; it is now hardcoded and available (if needed) as Pyro.naming.NS_NAME.
• Removed config item PYRO_NS_GROUPSEP; it's now hardcoded as '.'.
• Removed config item PYRO_NS_ROOTCHAR; it's now hardcoded as ':'.
• Added the Event Service (Pyro.EventService.*). See the chapter on Pyro Services. There is an example too: "stockquotes".
• Fixed the "naming" example.
• Translated the TODO list from Dutch to English, so everybody can read it now.
• Enhanced DynamicProxy; it can now be used as a key in a dictionary. This was needed for the Event Servive.

Pyro 2.2

• GUIDs are now constructed using the Python process ID (PID) too. This gives extra safety against double GUIDs possibly generated by multiple python processes on the same machine.
• Renamed SocketClosedException to ConnectionClosedException. The new name is more independent of the actual implementation.
• Removed some references to the socket module and socket.error. This makes the rest of the code more independent of the actual protocol implementation. A future Pyro release may contain even more changes to fully support multiple protocol implementations (not only sockets).
• Documented the pickle trojan vulnerability in the 'Features and Guidelines' chapter.
• Included setup script by Alexandre Fayolle.

Pyro 2.3

• Pyro now requires at least Python 2.0.1, but Python 2.1.1 or later is recommended. Anything older than Python 2.0.1 is no longer supported.
• Added PYRO_NS_HOSTNAME config item, for direct hostname lookup when the NS can't be found using broadcast.
• Documentation and examples changed to reflect the above enhancement.
• Grand renaming: Naming Service is now called Name Server everywhere. Event Service stays.
• Logger now uses YYYY-MM-DD hh:mm:ss date/time format.
• Event Service improved, but it now requires threads to work. Major problems have been fixed regarding re-subscribing and unsubscribing while processing events.
• Improved rich comparison and hashing of proxies. They can now be a key in a dictionary, and proxies that refer to the same object GUID, compare the same. Sadly, this largely breaks the hashing and rich comparison possibility of the remote Pyro objects. You're not comparing those objects, you're comparing the proxies... The hashing and rich comparison didn't work for remote objects in Pyro 2.2 too (same reasons) so this is not too bad.
• Dramatically improved the speed when sending large messages: the sock_recv code now uses a list of chunks and joins them at the end, instead of string concatenation. You will see the difference in the hugetransfer example: the message size has been increased tenfold, but the time it takes is almost unchanged :-)

Pyro 2.4

• Preliminary Jython support, workarounds/hacks to fill in for missing features such as select, errno and getpid. Only PYRO clients in Jython currently, because servers need select!
• Fixed docs about removed config items in Pyro 2.1
• Fixed time format string in logger, now the loggings includes the time again on Windows
• Fixed indentation errors in quickstart example's remote.py and it should work again on Windows (signals).
• Fixed the log file configuration options, they now work as documented. When changing PYRO_LOGFILE or PYRO_USER_LOGFILE, all following log messages are written to the new location. If the filename isn't an absolute path, it will be made relative to the current PYRO_STORAGE location.
• Slightly clearified the docs on the PYRO_STORAGE config item.
• Updated the example chapter to use Pyro 2.4.
• One additional small change to the proxy code: __nonzero__ has been defined in the proxy.
• Pyroc now also generates proxy code with the various comparison and hashing functions.
• Oneway invocations support added. See the chapter on features and guidelines.
• New event service example "countingcars" that shows a client that changes its topic subscriptions.
• New "callback" example that shows callback invocations to clients and the new Oneway call.
• Event service now sets correct (publish) timestamps on events, also with slow clients.
• Event service uses oneway invocations to publish the events and to decouple from slow or buggy clients. They no longer stall the publication thread in the ES.
• Documentation updates on the new features.

Pyro 2.5

• Slight change in names in the example chapter to avoid ambiguity between 'test' object and 'test' module.
• Rewrote PYRO_STORAGE directory checking to something much simpler. Should work on all platforms now.
• Navbar also at bottom of documentation pages for easier navigation.
• New config option PYRO_CHECKSUM to enable a quick Adler32 checksum on the messages. (Why Adler32 and not CRC32? Adler is faster, and we need speed).
• Now using regular expression to parse Pyro URI strings.
• New URI PYRONAME://nshostname:port/objectname for very easy automatic object lookup. nshostname and port are optional.
• New URI PYROLOC://hostname:port/objectname for very easy object binding without using a Name Server. port is optional.
• The Pyro Daemon itself is now a Pyro object too. This was needed for the PYROLOC: resolving, but it might prove valuable too in a later version when you might want to access it to get information on server objects, for instance. The Daemon has a fixed builtin GUID, Pyro.core.INTERNAL_DAEMON_GUID. I'm not sure if this feature stays, because it might also be a huge security/stability hole. (please advise?)
• Improved documentation here and there.
• The setup.py script no longer overwrites system tools blindly, it warns you of this issue and it asks you to specify the path were the Pyro scripts have to be installed.

Pyro 2.6

• Fixed mobile code (agents). Internal exception caused socket to shutdown, causing connection lost error.
• Minor changes to the docs, documented the mobile code module restriction, a bit more details on auto rebind.
• Fixes to some small and a few nasty bugs that had crept in. Some bugs detected by pychecker, yay
• Moved constants to new module Pyro.constants to avoid import conflicts.
• Renamed and moved the internal Pyro names: Pyro.constants.NAMESERVER_NAME and Pyro.constants.EVENTSERVER_NAME. (previously NS_NAME and EVENTSERVICE_NAME)
• Fixed StringTypes that was a Python 2.2 dependency.
• Event Server clients will now correctly terminate (the request loop no longer hangs)

Pyro 2.7

• Pyro is close to a major new release (3.0). It appears that 2.x has no more big issues.
• Mobile code improved: can now transmit modules from packages! Agent2 example changed to reflect this.
• Added two more examples: chatbox with and without using the Event Server.
• Finally documented the Name Server Pyro object methods.
• Minor other changes and additions to the docs.
• Fixed some leaks when handling exception tracebacks.
• Added logic to transfer remote exception tracebacks to clients and to print them on the client. See Pyro.util.getPyroTraceback.
• The NameServerLocator no longer performs a broadcast lookup if the hostname is specified in the getNS call, or if the PYRO_NS_HOSTNAME config item is specified.
• Added host and port options to Event Server start script.
• Event Server now has nice error handling and cleanup, like the Name Server.
• No longer does SO_REUSEADDR on sockets when running under Windows, because Windows has a quirk with this that allows multiple processes to listen on the same socket.

Pyro 2.8

• Fixed import Pyro.protocol error by moving RIF_* flags to constants module.
• Completed chapter 6 - implementation. Not as much info as I would like, but it's enough to get a quick idea of how Pyro's implemented.
• Compressed the example chapter to make it easier to understand.
• Changed preferred way of dealing with the daemon's request loop to requestLoop, instead of handleRequests (Don't worry, the latter still exists!). Updated most examples.
• Fixed ^C handling of chatbox examples.
• Fixed bug when both compression and checksumming were enabled.
• Setup script should work again under Win98, also, entering no path for the location for the script files takes the distutils default path.
• Fixed old bug in pyroc generated proxy code (method names for remote attribute access were wrong)
• Added agent docs on module dependencies: imports of other unknown modules don't work in agents.