Merge lp:~exarkun/divmod.org/remove-epsilon-1325289 into lp:divmod.org

[Jean-Paul Calderone]

https://github.com/twisted/epsilon

[Tristan Seligmann (mithrandi)]

review: Approve

=== modified file 'Divmod.pth'
--- Divmod.pth	2014-06-08 12:14:35 +0000
+++ Divmod.pth	2014-06-28 16:02:12 +0000
@@ -1,7 +1,6 @@
-# -*- test-case-name: axiom,combinator,epsilon,xmantissa,xquotient,reverend,sine,hyperbola -*-
+# -*- test-case-name: axiom,combinator,xmantissa,xquotient,reverend,sine,hyperbola -*-
 Axiom
 Combinator
-Epsilon
 Mantissa
 Quotient
 Reverend

=== removed directory 'Epsilon'
=== removed file 'Epsilon/.coveragerc'
--- Epsilon/.coveragerc	2014-01-13 11:18:20 +0000
+++ Epsilon/.coveragerc	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-[run]
-branch = True
-source =
-    epsilon
-
-[report]
-exclude_lines =
-    pragma: no cover

=== removed file 'Epsilon/LICENSE'
--- Epsilon/LICENSE	2005-12-10 22:31:51 +0000
+++ Epsilon/LICENSE	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-Copyright (c) 2005 Divmod Inc.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
\ No newline at end of file

=== removed file 'Epsilon/MANIFEST.in'
--- Epsilon/MANIFEST.in	2014-01-15 10:08:27 +0000
+++ Epsilon/MANIFEST.in	1970-01-01 00:00:00 +0000
@@ -1,3 +0,0 @@
-include LICENSE
-include NAME.txt
-include NEWS.txt

=== removed file 'Epsilon/NAME.txt'
--- Epsilon/NAME.txt	2005-08-27 23:09:07 +0000
+++ Epsilon/NAME.txt	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-
-See: http://mathworld.wolfram.com/Epsilon.html
-
-The constant 'epsilon' is a value that is as close as possible to zero without
-being zero.  It is frequently used by computer scientists to refer to values
-which are negligeable.
-
-Divmod Epsilon is named for that because it is a small body of code upon which
-all of our other projects depend.  It has no particular theme associated with
-it, except to remain small and lightweight, and enforce certain conventions and
-to provide common conveniences that do not belong in any lower level of
-infrastructure.
-

=== removed file 'Epsilon/NEWS.txt'
--- Epsilon/NEWS.txt	2014-01-15 10:21:17 +0000
+++ Epsilon/NEWS.txt	1970-01-01 00:00:00 +0000
@@ -1,113 +0,0 @@
-0.7.0 (2014-01-15):
-  Major:
-
-  - Only Python 2.6 and 2.7 are supported now. 2.4, 2.5 is deprecated.
-  - setup.py now uses setuptools, and stores its dependencies. This
-    means you no longer need to manually install dependencies.
-  - setup.py no longer requires Twisted for egg_info, making it easier
-    to install Epsilon using pip.
-  - Significant improvements to PyPy support. PyPy is now a supported
-    platform, with CI support.
-  - epsilon.release is now removed. It relied on a bunch of machinery
-    specific to divmod that no longer existed.
-  - epsilon.sslverify is now removed. Use twisted.internet.ssl instead.
-  - epsilon.asTwistedVersion takes a string version ("1.2.3") and
-    turns it into a twisted.python.versions.Version.
-
-  Minor:
-
-  - Several deprecation warnings have been cleaned up.
-
-0.6.0 (2009-11-25):
-  - Disable loopback hotfix on Twisted 8.2 and newer.
-  - Remove the implementation of Cooperator and use Twisted's implementation
-    instead.
-  - Use Twisted's deferLater implementation.
-  - Add a service for communicating via stdio.
-  - Add a `precision` argument to `Time.asHumanly` to control the precision
-    of the returned string.
-
-0.5.12 (2008-12-09):
-  - Added support for AMP authentication via one-time pads.
-
-0.5.11 (2008-10-02):
-  - epsilon.amprouter added, providing support for multiplexing
-    unrelated AMP communications over the same connection.
-
-0.5.10 (2008-08-12):
-  - Added the epsilon.caseless module, with case-insensitive string
-    wrappers.
-  - Better repr() for epsilon.structlike.record added.
-  - epsilon.juice now uses twisted.internet.ssl instead of epsilon.sslverify.
-
-0.5.9 (2008-01-18):
-
-0.5.8 (2007-11-27):
-  - extime.Time.asHumanly() no longer shows a time of day for all-day timestamps.
-
-0.5.7 (2007-04-27):
-  - view.SlicedView added, allowing slicing and indexing of large
-    sequences without copying.
-
-0.5.6 (2006-11-20):
-  - Added a --quiet option to Epsilon's certcreate and use it in a few unit
-    tests to avoid spewing garbage during test runs.
-
-0.5.5 (2006-10-21):
-  - extime.Time now accepts RFC2822-like dates with invalid fields: it
-    rounds them to the nearest valid value.
-
-0.5.4 (2006-10-17):
-  - extime.Time now accepts RFC2822-like dates with no timezone.
-
-0.5.3 (2006-09-20):
-  - structlike.Record now raises TypeError on unexpected args.
-
-0.5.2 (2006-09-12):
-  - extime.Time now avoids time_t overflow bugs.
-
-0.5.1 (2006-06-22):
-  - Added hotfix for twisted.test.proto_helpers.StringTransport.
-
-0.5.0 (2006-06-12):
-  - Replaced '%y' with '%Y' in Time.asHumanly() output - the year is now
-    four digits, rather than two.
-  - Added new 'epsilon.structlike' functionality for simple record.
-  - All uses of defer.wait and deferredResult were removed from the tests.
-  - Added epsilon.juice, an asynchronous messaging protocol slated for
-    inclusion in Twisted.  Improved a few features, such as the repr() of
-    JuiceBox instances.  This was moved from Vertex.
-  - Added epsilon.sslverify, a set of utilities for dealing with PyOpenSSL
-    using simple high-level objects, performing operations such as signing and
-    verifying certificates.  This was also moved from Vertex, and slated for
-    inclusion in Twisted.
-  - Added epsilon.spewer, a prettier version of the spewer in
-    twisted.python.util.
-  - Added "benchmark" tool for measuring and reporting run-times of python
-    programs.
-
-0.4.0 (2005-12-20):
-  - Disabled crazy sys.modules hackery in test_setuphelper
-  - Added module for creating a directory structure from a string template
-  - Added support for 'now' to Time.fromHumanly()
-  - Added a structured "hotfix" system to abstract and formalize monkey
-    patches and version testing logic away from code which requires it.
-
-0.3.2 (2005-11-05):
-  - Added automatic support for Twisted plugins to autosetup
-
-0.3.1 (2005-11-02):
-  - Removed bogus dependency on Axiom.
-
-0.3.0 (2005-11-02):
-  - Added SchedulingService, an IService implementation, to epsilon.cooperator
-  - Added autosetup, a utility to actually include files in distutils releases,
-    to epsilon.setuphelper
-
-0.2.1 (2005-10-25):
-  - Added 'short()' to epsilon.versions.Version
-  - fixed setup.py to use epsilon.version.short() rather than static string.
-
-0.2.0 (2005-10-25):
-  - Added epsilon.modal.ModalType, metaclass for writing classes that
-    behave in some respects like state machines

=== removed file 'Epsilon/README'
--- Epsilon/README	2006-06-14 11:54:41 +0000
+++ Epsilon/README	1970-01-01 00:00:00 +0000
@@ -1,9 +0,0 @@
-
-Divmod Epsilon
-==============
-
-Epsilon is a set of utility modules, commonly used by all Divmod projects.
-
-This is intended mainly as a support package for code used by Divmod projects,
-and not as an external library.  However, it contains many useful modules and
-you can feel free to use them!

=== removed directory 'Epsilon/bin'
=== removed file 'Epsilon/bin/benchmark'
--- Epsilon/bin/benchmark	2006-05-19 15:23:46 +0000
+++ Epsilon/bin/benchmark	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-#!/usr/bin/python
-
-from epsilon.scripts import benchmark
-benchmark.main()

=== removed file 'Epsilon/bin/certcreate'
--- Epsilon/bin/certcreate	2006-06-08 19:22:15 +0000
+++ Epsilon/bin/certcreate	1970-01-01 00:00:00 +0000
@@ -1,5 +0,0 @@
-#!/usr/bin/python
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-
-from epsilon.scripts import certcreate
-certcreate.main()

=== removed directory 'Epsilon/doc'
=== removed file 'Epsilon/doc/amp-auth.xhtml'
--- Epsilon/doc/amp-auth.xhtml	2008-11-27 07:37:39 +0000
+++ Epsilon/doc/amp-auth.xhtml	1970-01-01 00:00:00 +0000
@@ -1,115 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <title>AMP Authentication</title>
-  </head>
-  <body>
-    <h1>AMP Authentication</h1>
-
-    <h2>Overview</h2>
-
-    <p>
-      <code class="API">epsilon.ampauth</code> integrates Twisted Cred with
-      <code>twisted.protocols.amp</code>, providing support for selecting a
-      <code>IBoxReceiver</code> based on the result of a Cred login.
-    </p>
-
-    <p>
-      Readers should familiarize themselves with the following concepts in
-      order to understand all sections of this document:
-    </p>
-
-    <ul>
-      <li>
-        Twisted <a
-        href="http://twistedmatrix.com/projects/core/documentation/howto/clients.html">TCP
-        clients</a> and <a
-        href="http://twistedmatrix.com/projects/core/documentation/howto/servers.html">TCP
-        servers</a>
-      </li>
-      <li>
-        <a href="http://twistedmatrix.com/projects/core/documentation/howto/defer.html">
-        Using Deferreds
-        </a>
-      </li>
-      <li>
-        Twisted <code class="API" base="twisted.protocols.amp">AMP</code>
-      </li>
-      <li>
-        <a href="http://twistedmatrix.com/projects/core/documentation/howto/cred.html">
-          Twisted Cred
-        </a>
-      </li>
-    </ul>
-
-    <h2>Servers</h2>
-
-    <p>
-      <code class="API" base="epsilon.ampauth">CredAMPServerFactory</code>
-      is a factory for the <code class="API"
-      base="epsilon.ampauth">CredReceiver</code> protocol, an
-      <code>AMP</code> subclass which implements responders for commands
-      which allow a client to prove their identity.  It uses a
-      <code>Portal</code> to handle these commands and retrieve an <code
-      class="API" base="twisted.protocols.amp">IBoxReceiver</code> which
-      will be used to handle all further AMP boxes it receives.
-    </p>
-
-    <a href="listings/amp/auth_server.py" class="py-listing">
-      AMP server with authentication
-    </a>
-
-    <p>
-      <code>Add</code> and <code>Adder</code> together define a simple AMP
-      protocol for adding two integers together.  <code>AdditionRealm</code>
-      provides the necessary integration between this AMP protocol and Cred,
-      creating new <code>Adder</code> instances whenever an
-      <code>IBoxReceiver</code> is requested - which will be whenever a client
-      attempts to authenticate itself to the server.
-    </p>
-
-    <h2>Clients</h2>
-
-    <p>
-      AMP clients can authenticate with an AMP server using <code class="API"
-      base="epsilon.ampauth">login</code>.  <code>login</code> takes a
-      connected AMP instance and a credentials object as arguments and returns
-      a <code>Deferred</code> which fires when authentication finishes.
-    </p>
-
-    <a href="listings/amp/auth_client.py" class="py-listing">
-      Authenticating AMP client
-    </a>
-
-    <p>
-      The TCP connection is set up as usual, and the <code>Add</code> command
-      is also issued in the usual way.  The only change from a normal AMP
-      client is the use of <code>login</code> after a connection has been set
-      up but before any commands are issued.
-    </p>
-
-    <h2>One-Time Pad Authentication</h2>
-
-    <p>
-      <code class="API">epsilon.ampauth</code> includes an <code class="API"
-        base="twisted.cred.checkers">CredentialsChecker</code> for validating
-      one-time pads: <code class="API"
-        base="epsilon.ampauth">OneTimePadChecker</code>.  If this checker is
-      registered with the portal, clients may use the <code class="API"
-        base="epsilon.ampauth">OTPLogin</code> command to authenticate.
-    </p>
-
-    <a href="listings/amp/amp_auth_server.py" class="py-listing">
-      AMP server with OTP authentication
-    </a>
-
-    <p></p>
-
-    <a href="listings/amp/amp_auth_client.py" class="py-listing">
-      OTP-authenticating AMP client
-    </a>
-  </body>
-</html>

=== removed file 'Epsilon/doc/amp-routes.xhtml'
--- Epsilon/doc/amp-routes.xhtml	2008-08-29 16:02:56 +0000
+++ Epsilon/doc/amp-routes.xhtml	1970-01-01 00:00:00 +0000
@@ -1,180 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <title>AMP Routes</title>
-  </head>
-  <body>
-    <h1>AMP Routes</h1>
-
-    <h2>Overview</h2>
-
-    <p>
-      Normally, an AMP connection is between two <code class="API"
-      base="twisted.protocols.amp">AMP</code> instances; each instance receives
-      all AMP boxes sent by the other side and handles them by interpreting
-      them as commands, responses to commands, or in some other way.  This
-      typically means that the logic for handling boxes on each side of the
-      connection is completely defined by a single object.  Sometimes it is
-      useful to allow multiple objects, perhaps of different types, to
-      participate in defining this logic.
-    </p>
-
-    <p>
-      <code>epsilon.amprouter</code> implements utilities which allow an
-      arbitrary number of objects, providers of <code>IBoxReceiver</code> (for
-      example, instances of <code>AMP</code>), to define how received AMP boxes
-      are interpreted.  This is useful to multiplex unrelated <code>AMP</code>
-      instances over a single TCP connection, to split up a single AMP protocol
-      into multiple simpler protocols, and for many other purposes.
-    </p>
-
-    <p>
-      Readers should familiarize themselves with the following concepts in
-      order to understand all sections of this document:
-    </p>
-
-    <ul>
-      <li>
-        Twisted <a
-        href="http://twistedmatrix.com/projects/core/documentation/howto/clients.html">TCP
-        clients</a> and <a
-        href="http://twistedmatrix.com/projects/core/documentation/howto/servers.html">TCP
-        servers</a>
-      </li>
-      <li>
-        <a href="http://twistedmatrix.com/projects/core/documentation/howto/defer.html">
-        Using Deferreds
-        </a>
-      </li>
-      <li>
-        Twisted <code class="API" base="twisted.protocols.amp">AMP</code>
-      </li>
-    </ul>
-
-    <h2>Routers</h2>
-
-    <p>
-      When working with routes, the object primarily of interest will be a <a
-      class="API" base="epsilon.amprouter">Router</a> instance.  Each AMP
-      client and server will have a <code>Router</code> instance which they can
-      use to create new routes.  They will use its <code class="API"
-      base="epsilon.amprouter">Router.bindRoute</code> method to set up
-      whatever routes they require.
-    </p>
-
-    <h2>Servers</h2>
-
-    <p>
-      <code>epsilon.amprouter</code> does not define a command for creating new
-      routes because different applications have different requirements for how
-      new routes are set up.  An application may want to negotiate about the
-      <code>IBoxReceiver</code> implementation which is associated with a
-      route, it may want to supply initial arguments to that object, it may
-      want to do version negotiation, and so on.  The first thing an
-      application using routes must do, then, is to define a way to create new
-      routes.  Consider the following example which allows routes to be created
-      with a <code>NewRoute</code> AMP command and associates them with a
-      parameterized <code>IBoxReceiver</code> implementation.
-    </p>
-
-    <a href="listings/amp/route_setup.py" class="py-listing">
-      Creation of new routes
-    </a>
-
-    <p>
-      <code>AMPRouteServerFactory.buildProtocol</code> creates new
-      <code>RoutingAMP</code> instances, each with a new <code>Router</code>.
-      The <code>Router</code> instance will become the <code>RoutingAMP</code>
-      instance's <code>boxReceiver</code> attribute.  This is important for two
-      reasons.  First, it allows the router to work by causing all AMP boxes
-      received from the connection to be delivered to the router to be
-      dispatched appropriately.  Second, it gives the <code>RoutingAMP</code>
-      instance a reference to the <code>Router</code> instance; this is
-      necessary so that new routes can be created.
-    </p>
-
-    <p>
-      After creating the <code>Router</code> and <code>RoutingAMP</code>,
-      <code>buildProtocol</code> also sets up the <code>RoutingAMP</code>
-      instance to be the default receiver by binding it to the
-      <code>None</code>.  All AMP boxes without routing information will be
-      delivered to the default receiver.  This is important because it allows
-      the <code>NewRoute</code> command to be handled by the
-      <code>RoutingAMP</code> instance.
-    </p>
-
-    <p>
-      <code>RoutingAMP</code>'s <code>NewRoute</code> responder uses
-      <code>self.boxReceiver</code>, the <code>Router</code> instance provided
-      by the factory, to <em>bind</em> the return value of
-      <code>self.factory.routeProtocol()</code> to a new route.  Then, it
-      connects the route to the identifier specified in the
-      <code>NewRoute</code> command.  Finally, it returns the identifier of the
-      route it has just created.  Once this has happened, the route is
-      completely set up on the server.
-    </p>
-
-    <p>
-      Finally, the <code>connect</code> function wraps up the necessary calls
-      to routing methods and a use of the <code>NewRoute</code> command to form
-      the client side of the setup.
-    </p>
-
-    <p>
-      First, let's look at an example of using <code>AMPRouteServerFactory</code> and
-      <code>RoutingAMP</code> to run a server.
-    </p>
-
-    <a href="listings/amp/route_server.py" class="py-listing">
-      Routed counters server
-    </a>
-
-    <p>
-      In this example, a simple counting protocol is hooked up to the server.
-      Each route which is created is associated with a new instance of this
-      protocol.  The protocol does just one simple thing, it keeps track of how
-      many times the <code>Count</code> command is issued to it and returns
-      this value in the response to that command.
-    </p>
-
-    <p>
-      Next we'll look at how a client can connect to this server, create new
-      routes, and issue commands over them.
-    </p>
-
-    <h2>Clients</h2>
-
-    <p>
-      Just as servers must, clients must first set up a route before they can
-      send boxes over it.  A client uses the same methods as the server,
-      <code>Router.bindRoute</code> and <code>Route.connectTo</code>, to set up
-      a new route.  Here's an example which makes one TCP connection to an AMP
-      server, sets up three routes, and then issues multiple commands over each
-      of them.
-    </p>
-
-    <a href="listings/amp/route_client.py" class="py-listing">
-      Routed counters client
-    </a>
-
-    <p>
-      Note first how <code>main</code> creates an <code>AMP</code> with a
-      <code>Router</code> instance.  Note also how <code>makeRoutes</code>
-      binds and connects the protocol to the default route.  This mirrors the
-      route setup which was done on the server and is necessary for the same
-      reasons.
-    </p>
-
-    <p>
-      Once an AMP connection is set up and the default route is bound,
-      <code>makeRoutes</code> uses the previously defined <code>connect</code>
-      function to establish three new routes.  Each route is associated with a
-      <code>CountClient</code> instance which will issue several count commands
-      and report the results.  The results of each command are tracked so that
-      when they have all been received the client can exit.
-    </p>
-  </body>
-</html>

=== removed file 'Epsilon/doc/index.xhtml'
--- Epsilon/doc/index.xhtml	2008-08-29 16:02:56 +0000
+++ Epsilon/doc/index.xhtml	1970-01-01 00:00:00 +0000
@@ -1,21 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml">
-  <head>
-    <title>Index</title>
-  </head>
-  <body>
-    <h1>Index</h1>
-
-    <ul class="toc">
-      <li>
-        <a href="amp-auth.xhtml">AMP Authentication</a>
-      </li>
-      <li>
-        <a href="amp-routes.xhtml">AMP Routes</a>
-      </li>
-    </ul>
-  </body>
-</html>

=== removed directory 'Epsilon/doc/listings'
=== removed directory 'Epsilon/doc/listings/amp'
=== removed file 'Epsilon/doc/listings/amp/amp_auth_client.py'
--- Epsilon/doc/listings/amp/amp_auth_client.py	2008-11-27 07:37:39 +0000
+++ Epsilon/doc/listings/amp/amp_auth_client.py	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-"""
-An AMP client which connects to and authenticates with an AMP server using OTP,
-then issues a command.
-"""
-
-from twisted.internet.protocol import ClientCreator
-from twisted.cred.credentials import UsernamePassword
-from twisted.protocols.amp import AMP
-
-from epsilon.react import react
-from epsilon.ampauth import OTPLogin
-
-from auth_server import Add
-
-
-def add(proto):
-    return proto.callRemote(Add, left=17, right=33)
-
-
-def display(result):
-    print result
-
-
-def otpLogin(client):
-    client.callRemote(OTPLogin, pad='pad')
-    return client
-
-
-def main(reactor):
-    cc = ClientCreator(reactor, AMP)
-    d = cc.connectTCP('localhost', 7805)
-    d.addCallback(otpLogin)
-    d.addCallback(add)
-    d.addCallback(display)
-    return d
-
-
-if __name__ == '__main__':
-    from twisted.internet import reactor
-    react(reactor, main, [])

=== removed file 'Epsilon/doc/listings/amp/amp_auth_server.py'
--- Epsilon/doc/listings/amp/amp_auth_server.py	2008-11-27 07:37:39 +0000
+++ Epsilon/doc/listings/amp/amp_auth_server.py	1970-01-01 00:00:00 +0000
@@ -1,76 +0,0 @@
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-"""
-An AMP server which requires authentication of its clients before exposing an
-addition command.
-"""
-
-from sys import stdout
-
-from twisted.python.log import startLogging, msg
-from twisted.internet import reactor
-from twisted.cred.portal import Portal
-from twisted.protocols.amp import IBoxReceiver, Command, Integer, AMP
-
-from epsilon.ampauth import CredAMPServerFactory, OneTimePadChecker
-
-
-class Add(Command):
-    """
-    An example of an application-defined command which should be made available
-    to clients after they successfully authenticate.
-    """
-    arguments = [("left", Integer()),
-                 ("right", Integer())]
-
-    response = [("sum", Integer())]
-
-
-
-class Adder(AMP):
-    """
-    An example of an application-defined AMP protocol, the responders defined
-    by which should only be available to clients after they have successfully
-    authenticated.
-    """
-    def __init__(self, avatarId):
-        AMP.__init__(self)
-        self.avatarId = avatarId
-
-
-    @Add.responder
-    def add(self, left, right):
-        msg("Adding %d to %d for %s" % (left, right, self.avatarId))
-        return {'sum': left + right}
-
-
-
-class AdditionRealm(object):
-    """
-    An example of an application-defined realm.
-    """
-    def requestAvatar(self, avatarId, mind, *interfaces):
-        """
-        Create Adder avatars for any IBoxReceiver request.
-        """
-        if IBoxReceiver in interfaces:
-            return (IBoxReceiver, Adder(avatarId), lambda: None)
-        raise NotImplementedError()
-
-
-
-def main():
-    """
-    Start the AMP server and the reactor.
-    """
-    startLogging(stdout)
-    checker = OneTimePadChecker({'pad': 0})
-    realm = AdditionRealm()
-    factory = CredAMPServerFactory(Portal(realm, [checker]))
-    reactor.listenTCP(7805, factory)
-    reactor.run()
-
-
-if __name__ == '__main__':
-    main()
-

=== removed file 'Epsilon/doc/listings/amp/auth_client.py'
--- Epsilon/doc/listings/amp/auth_client.py	2008-08-29 16:02:56 +0000
+++ Epsilon/doc/listings/amp/auth_client.py	1970-01-01 00:00:00 +0000
@@ -1,37 +0,0 @@
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-"""
-An AMP client which connects to and authenticates with an AMP server, then
-issues a command.
-"""
-
-from twisted.internet.protocol import ClientCreator
-from twisted.cred.credentials import UsernamePassword
-from twisted.protocols.amp import AMP
-
-from epsilon.react import react
-from epsilon.ampauth import login
-
-from auth_server import Add
-
-
-def add(proto):
-    return proto.callRemote(Add, left=17, right=33)
-
-
-def display(result):
-    print result
-
-
-def main(reactor):
-    cc = ClientCreator(reactor, AMP)
-    d = cc.connectTCP('localhost', 7805)
-    d.addCallback(login, UsernamePassword("testuser", "examplepass"))
-    d.addCallback(add)
-    d.addCallback(display)
-    return d
-
-
-if __name__ == '__main__':
-    from twisted.internet import reactor
-    react(reactor, main, [])

=== removed file 'Epsilon/doc/listings/amp/auth_server.py'
--- Epsilon/doc/listings/amp/auth_server.py	2008-11-05 18:50:57 +0000
+++ Epsilon/doc/listings/amp/auth_server.py	1970-01-01 00:00:00 +0000
@@ -1,77 +0,0 @@
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-"""
-An AMP server which requires authentication of its clients before exposing an
-addition command.
-"""
-
-from sys import stdout
-
-from twisted.python.log import startLogging, msg
-from twisted.internet import reactor
-from twisted.cred.checkers import InMemoryUsernamePasswordDatabaseDontUse
-from twisted.cred.portal import Portal
-from twisted.protocols.amp import IBoxReceiver, Command, Integer, AMP
-
-from epsilon.ampauth import CredAMPServerFactory
-
-
-class Add(Command):
-    """
-    An example of an application-defined command which should be made available
-    to clients after they successfully authenticate.
-    """
-    arguments = [("left", Integer()),
-                 ("right", Integer())]
-
-    response = [("sum", Integer())]
-
-
-
-class Adder(AMP):
-    """
-    An example of an application-defined AMP protocol, the responders defined
-    by which should only be available to clients after they have successfully
-    authenticated.
-    """
-    def __init__(self, avatarId):
-        AMP.__init__(self)
-        self.avatarId = avatarId
-
-
-    @Add.responder
-    def add(self, left, right):
-        msg("Adding %d to %d for %s" % (left, right, self.avatarId))
-        return {'sum': left + right}
-
-
-
-class AdditionRealm(object):
-    """
-    An example of an application-defined realm.
-    """
-    def requestAvatar(self, avatarId, mind, *interfaces):
-        """
-        Create Adder avatars for any IBoxReceiver request.
-        """
-        if IBoxReceiver in interfaces:
-            return (IBoxReceiver, Adder(avatarId), lambda: None)
-        raise NotImplementedError()
-
-
-
-def main():
-    """
-    Start the AMP server and the reactor.
-    """
-    startLogging(stdout)
-    checker = InMemoryUsernamePasswordDatabaseDontUse()
-    checker.addUser("testuser", "examplepass")
-    realm = AdditionRealm()
-    factory = CredAMPServerFactory(Portal(realm, [checker]))
-    reactor.listenTCP(7805, factory)
-    reactor.run()
-
-
-if __name__ == '__main__':
-    main()

=== removed file 'Epsilon/doc/listings/amp/route_client.py'
--- Epsilon/doc/listings/amp/route_client.py	2008-08-29 16:02:56 +0000
+++ Epsilon/doc/listings/amp/route_client.py	1970-01-01 00:00:00 +0000
@@ -1,60 +0,0 @@
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-import random
-
-from twisted.internet.defer import Deferred, gatherResults
-from twisted.internet.protocol import ClientCreator
-from twisted.protocols.amp import AMP
-
-from epsilon.react import react
-from epsilon.amprouter import Router
-
-from route_setup import connect
-from route_server import Count
-
-
-def display(value, id):
-    print id, value
-
-
-class CountClient(AMP):
-    def __init__(self, identifier):
-        AMP.__init__(self)
-        self.identifier = identifier
-        self.finished = Deferred()
-
-    def startReceivingBoxes(self, sender):
-        AMP.startReceivingBoxes(self, sender)
-
-        counts = []
-        for i in range(random.randrange(1, 5)):
-            d = self.callRemote(Count)
-            d.addCallback(display, self.identifier)
-            counts.append(d)
-        gatherResults(counts).chainDeferred(self.finished)
-
-
-
-def makeRoutes(proto, router):
-    router.bindRoute(proto, None).connectTo(None)
-
-    finish = []
-    for i in range(3):
-        client = CountClient(i)
-        finish.append(connect(proto, router, client))
-        finish.append(client.finished)
-    return gatherResults(finish)
-
-
-
-def main(reactor):
-    router = Router()
-    cc = ClientCreator(reactor, AMP, router)
-    d = cc.connectTCP('localhost', 7805)
-    d.addCallback(makeRoutes, router)
-    return d
-
-
-if __name__ == '__main__':
-    from twisted.internet import reactor
-    react(reactor, main, [])

=== removed file 'Epsilon/doc/listings/amp/route_server.py'
--- Epsilon/doc/listings/amp/route_server.py	2008-11-05 18:50:57 +0000
+++ Epsilon/doc/listings/amp/route_server.py	1970-01-01 00:00:00 +0000
@@ -1,37 +0,0 @@
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-from sys import stdout
-
-from twisted.python.log import startLogging
-from twisted.protocols.amp import Integer, Command, AMP
-from twisted.internet import reactor
-
-from route_setup import AMPRouteServerFactory
-
-
-class Count(Command):
-    response = [('value', Integer())]
-
-
-
-class Counter(AMP):
-    _valueCounter = 0
-
-    @Count.responder
-    def count(self):
-        self._valueCounter += 1
-        return {'value': self._valueCounter}
-
-
-
-def main():
-    startLogging(stdout)
-    serverFactory = AMPRouteServerFactory()
-    serverFactory.routeProtocol = Counter
-    reactor.listenTCP(7805, serverFactory)
-    reactor.run()
-
-
-
-if __name__ == '__main__':
-    main()

=== removed file 'Epsilon/doc/listings/amp/route_setup.py'
--- Epsilon/doc/listings/amp/route_setup.py	2008-08-29 16:02:56 +0000
+++ Epsilon/doc/listings/amp/route_setup.py	1970-01-01 00:00:00 +0000
@@ -1,49 +0,0 @@
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-import operator
-
-from twisted.internet.protocol import ServerFactory
-from twisted.protocols.amp import Unicode, Command, AMP
-
-from epsilon.amprouter import Router
-
-
-class NewRoute(Command):
-    arguments = [('name', Unicode())]
-    response = [('name', Unicode())]
-
-
-
-class RoutingAMP(AMP):
-    @NewRoute.responder
-    def newRoute(self, name):
-        route = self.boxReceiver.bindRoute(self.factory.routeProtocol())
-        route.connectTo(name)
-        return {'name': route.localRouteName}
-
-
-
-class AMPRouteServerFactory(ServerFactory):
-    protocol = RoutingAMP
-    routeProtocol = None
-
-    def buildProtocol(self, addr):
-        router = Router()
-        proto = self.protocol(router)
-        proto.factory = self
-        default = router.bindRoute(proto, None)
-        default.connectTo(None)
-        return proto
-
-
-
-def connect(proto, router, receiver):
-    route = router.bindRoute(receiver)
-    d = proto.callRemote(NewRoute, name=route.localRouteName)
-    d.addCallback(operator.getitem, 'name')
-    d.addCallback(lambda name: route.connectTo(name))
-    def connectionFailed(err):
-        route.unbind()
-        return err
-    d.addErrback(connectionFailed)
-    return d

=== removed file 'Epsilon/doc/stylesheet.css'
--- Epsilon/doc/stylesheet.css	2008-08-25 16:20:43 +0000
+++ Epsilon/doc/stylesheet.css	1970-01-01 00:00:00 +0000
@@ -1,129 +0,0 @@
-body
-{
-  margin-left: 2em;
-  margin-right: 2em;
-  border: 0px;
-  padding: 0px;
-  font-family: sans-serif;
-}
-
-pre
-{
-  padding: 1em;
-  font-family: Neep Alt, Courier New, Courier;
-  font-size: 12pt;
-  border: thin black solid;
-}
-
-.python
-{
-  background-color: #dddddd;
-}
-
-.py-listing, .html-listing, .listing
-{
-  margin: 1ex;
-  border: thin solid black;
-  background-color: #eee;
-}
-
-.py-listing pre, .html-listing pre, .listing pre
-{
-  margin: 0px;
-  border: none;
-  border-bottom: thin solid black;
-}
-
-.py-listing .python
-{
-  margin-top: 0;
-  margin-bottom: 0;
-  border: none;
-  border-bottom: thin solid black;
-}
-
-.py-src-comment
-{
-  color: #1111CC
-}
-
-.py-src-keyword
-{
-  color: #3333CC;
-  font-weight: bold;
-}
-
-.py-src-parameter
-{
-  color: #000066;
-  font-weight: bold;
-}
-
-.py-src-identifier
-{
-  color: #CC0000
-}
-
-.py-src-string
-{
-  color: #115511
-}
-
-.py-src-endmarker
-{
-  display: block; /* IE hack; prevents following line from being sucked into the py-listing box. */
-}
-
-hr
-{
-  display: inline;
-}
-
-ul
-{
-  padding: 0px;
-  margin: 0px;
-  margin-left: 1em;
-  padding-left: 1em;
-  border-left: 1em;
-}
-
-li
-{
-  padding: 2px;
-}
-
-dt
-{
-  font-weight: bold;
-  margin-left: 1ex;
-}
-
-dd
-{
-  margin-bottom: 1em;
-}
-
-div.note
-{
-  background-color: #FFFFCC;
-  margin-top: 1ex;
-  margin-left: 5%;
-  margin-right: 5%;
-  padding-top: 1ex;
-  padding-left: 5%;
-  padding-right: 5%;
-  border: thin black solid;
-}
-
-.caption
-{
-  text-align: center;
-  padding-top: 0.5em;
-  padding-bottom: 0.5em;
-}
-
-.filename
-{
-  font-style: italic;
-}

=== removed file 'Epsilon/doc/template.tpl'
--- Epsilon/doc/template.tpl	2008-08-25 16:20:43 +0000
+++ Epsilon/doc/template.tpl	1970-01-01 00:00:00 +0000
@@ -1,23 +0,0 @@
-<?xml version="1.0"?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
-    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en">
-  <head>
-    <title>
-      Epsilon:
-    </title>
-    <link type="text/css" rel="stylesheet" href="stylesheet.css" />
-  </head>
-
-  <body bgcolor="white">
-    <h1 class="title"></h1>
-    <div class="toc"></div>
-    <div class="body">
-
-    </div>
-
-    <p><a href="index.html">Index</a></p>
-    <span class="version">Version: </span>
-  </body>
-</html>

=== removed directory 'Epsilon/epsilon'
=== removed file 'Epsilon/epsilon/__init__.py'
--- Epsilon/epsilon/__init__.py	2014-01-12 10:53:44 +0000
+++ Epsilon/epsilon/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,8 +0,0 @@
-# -*- test-case-name: epsilon.test -*-
-from epsilon._version import __version__
-from twisted.python import versions
-
-def asTwistedVersion(packageName, versionString):
-    return versions.Version(packageName, *map(int, versionString.split(".")))
-
-version = asTwistedVersion("epsilon", __version__)

=== removed file 'Epsilon/epsilon/_version.py'
--- Epsilon/epsilon/_version.py	2014-01-15 10:21:17 +0000
+++ Epsilon/epsilon/_version.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-__version__ = "0.7.0"

=== removed file 'Epsilon/epsilon/ampauth.py'
--- Epsilon/epsilon/ampauth.py	2011-07-18 12:37:13 +0000
+++ Epsilon/epsilon/ampauth.py	1970-01-01 00:00:00 +0000
@@ -1,312 +0,0 @@
-# -*- test-case-name: epsilon.test.test_ampauth -*-
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-"""
-This module provides integration between L{AMP<twisted.protocols.amp.AMP>} and
-L{cred<twisted.cred>}.
-"""
-
-from hashlib import sha1
-
-from zope.interface import implements
-
-from twisted.python.randbytes import secureRandom
-from twisted.cred.error import UnauthorizedLogin
-from twisted.cred.credentials import IUsernameHashedPassword, IUsernamePassword
-from twisted.cred.checkers import ICredentialsChecker
-from twisted.protocols.amp import IBoxReceiver, String, Command, AMP
-from twisted.internet.protocol import ServerFactory
-
-from epsilon.iepsilon import IOneTimePad
-from epsilon.structlike import record
-
-__metaclass__ = type
-
-
-class UnhandledCredentials(Exception):
-    """
-    L{login} was passed a credentials object which did not provide a recognized
-    credentials interface.
-    """
-
-
-
-class OTPLogin(Command):
-    """
-    Command to initiate a login attempt where a one-time pad is to be used in
-    place of username/password credentials.
-    """
-    arguments = [('pad', String())]
-
-    errors = {
-        # Invalid username or password
-        UnauthorizedLogin: 'UNAUTHORIZED_LOGIN',
-        # No IBoxReceiver avatar
-        NotImplementedError: 'NOT_IMPLEMENTED_ERROR'}
-
-
-
-class PasswordLogin(Command):
-    """
-    Command to initiate a username/password-based login attempt.  The response
-    to this command is a challenge which must be responded to based on the
-    correct password associated with the username given to this command.
-    """
-    arguments = [('username', String())]
-    response = [('challenge', String())]
-
-
-
-def _calcResponse(challenge, nonce, password):
-    """
-    Compute the response to the given challenge.
-
-    @type challenge: C{str}
-    @param challenge: An arbitrary byte string, probably received in response
-        to (or generated for) the L{PasswordLogin} command.
-
-    @type nonce: C{str}
-    @param nonce: An arbitrary byte string, generated by the client to include
-        in the hash to avoid making the client an oracle.
-
-    @type password: C{str}
-    @param password: The known correct password for the account being
-        authenticated.
-
-    @rtype: C{str}
-    @return: A hash constructed from the three parameters.
-    """
-    return sha1('%s %s %s' % (challenge, nonce, password)).digest()
-
-
-
-class PasswordChallengeResponse(Command):
-    """
-    Command to respond to a challenge issued in the response to a
-    L{PasswordLogin} command and complete a username/password-based login
-    attempt.
-
-    @param cnonce: A randomly generated string used only in this response.
-    @param response: The SHA-1 hash of the challenge, cnonce, and password.
-    """
-    arguments = [('cnonce', String()),
-                 ('response', String())]
-
-    errors = {
-        # Invalid username or password
-        UnauthorizedLogin: 'UNAUTHORIZED_LOGIN',
-        # No IBoxReceiver avatar
-        NotImplementedError: 'NOT_IMPLEMENTED_ERROR'}
-
-    @classmethod
-    def determineFrom(cls, challenge, password):
-        """
-        Create a nonce and use it, along with the given challenge and password,
-        to generate the parameters for a response.
-
-        @return: A C{dict} suitable to be used as the keyword arguments when
-            calling this command.
-        """
-        nonce = secureRandom(16)
-        response = _calcResponse(challenge, nonce, password)
-        return dict(cnonce=nonce, response=response)
-
-
-
-class _AMPUsernamePassword(record('username challenge nonce response')):
-    """
-    L{IUsernameHashedPassword} implementation used by L{PasswordLogin} and
-    related commands.
-    """
-    implements(IUsernameHashedPassword)
-
-    def checkPassword(self, password):
-        """
-        Check the given plaintext password against the response in this
-        credentials object.
-
-        @type password: C{str}
-        @param password: The known correct password associated with
-            C{self.username}.
-
-        @return: A C{bool}, C{True} if this credentials object agrees with the
-            given password, C{False} otherwise.
-        """
-        if isinstance(password, unicode):
-            password = password.encode('utf-8')
-        correctResponse = _calcResponse(self.challenge, self.nonce, password)
-        return correctResponse == self.response
-
-
-
-class _AMPOneTimePad(record('padValue')):
-    """
-    L{IOneTimePad} implementation used by L{OTPLogin}.
-
-    @ivar padValue: The value of the one-time pad.
-    @type padValue: C{str}
-    """
-    implements(IOneTimePad)
-
-
-
-class CredReceiver(AMP):
-    """
-    Integration between AMP and L{twisted.cred}.
-
-    This implementation is limited to a single authentication per connection.
-    A future implementation may use I{routes} to allow multiple authentications
-    over the same connection.
-
-    @ivar portal: The L{Portal} against which login will be performed.  This is
-        expected to be set by the factory which creates instances of this
-        class.
-
-    @ivar logout: C{None} or a no-argument callable.  This is set to the logout
-        object returned by L{Portal.login} and is set while an avatar is logged
-        in.
-
-    @ivar challenge: The C{str} which was sent as a challenge in response to
-        the L{PasswordLogin} command.  If multiple L{PasswordLogin} commands
-        are sent, this is the challenge sent in response to the most recent of
-        them.  It is not set before L{PasswordLogin} is received.
-
-    @ivar username: The C{str} which was received for the I{username} parameter
-        of the L{PasswordLogin} command.  The lifetime is the same as that of
-        the I{challenge} attribute.
-    """
-    portal = None
-    logout = None
-
-    @PasswordLogin.responder
-    def passwordLogin(self, username):
-        """
-        Generate a new challenge for the given username.
-        """
-        self.challenge = secureRandom(16)
-        self.username = username
-        return {'challenge': self.challenge}
-
-
-    def _login(self, credentials):
-        """
-        Actually login to our portal with the given credentials.
-        """
-        d = self.portal.login(credentials, None, IBoxReceiver)
-        def cbLoggedIn((interface, avatar, logout)):
-            self.logout = logout
-            self.boxReceiver = avatar
-            self.boxReceiver.startReceivingBoxes(self.boxSender)
-            return {}
-        d.addCallback(cbLoggedIn)
-        return d
-
-
-    @PasswordChallengeResponse.responder
-    def passwordChallengeResponse(self, cnonce, response):
-        """
-        Verify the response to a challenge.
-        """
-        return self._login(_AMPUsernamePassword(
-            self.username, self.challenge, cnonce, response))
-
-
-    @OTPLogin.responder
-    def otpLogin(self, pad):
-        """
-        Verify the given pad.
-        """
-        return self._login(_AMPOneTimePad(pad))
-
-
-    def connectionLost(self, reason):
-        """
-        If a login has happened, perform a logout.
-        """
-        AMP.connectionLost(self, reason)
-        if self.logout is not None:
-            self.logout()
-            self.boxReceiver = self.logout = None
-
-
-
-class OneTimePadChecker(record('pads')):
-    """
-    Checker which validates one-time pads.
-
-    @ivar pads: Mapping between valid one-time pads and avatar IDs.
-    @type pads: C{dict}
-    """
-    implements(ICredentialsChecker)
-
-    credentialInterfaces = (IOneTimePad,)
-
-    # ICredentialsChecker
-    def requestAvatarId(self, credentials):
-        if credentials.padValue in self.pads:
-            return self.pads.pop(credentials.padValue)
-        raise UnauthorizedLogin('Unknown one-time pad')
-
-
-
-class CredAMPServerFactory(ServerFactory):
-    """
-    Server factory useful for creating L{CredReceiver} instances.
-
-    This factory takes care of associating a L{Portal} with L{CredReceiver}
-    instances it creates.
-
-    @ivar portal: The portal which will be used by L{CredReceiver} instances
-        created by this factory.
-    """
-    protocol = CredReceiver
-
-    def __init__(self, portal):
-        self.portal = portal
-
-
-    def buildProtocol(self, addr):
-        proto = ServerFactory.buildProtocol(self, addr)
-        proto.portal = self.portal
-        return proto
-
-
-
-def login(client, credentials):
-    """
-    Authenticate using the given L{AMP} instance.  The protocol must be
-    connected to a server with responders for L{PasswordLogin} and
-    L{PasswordChallengeResponse}.
-
-    @param client: A connected L{AMP} instance which will be used to issue
-        authentication commands.
-
-    @param credentials: An object providing L{IUsernamePassword} which will
-        be used to authenticate this connection to the server.
-
-    @return: A L{Deferred} which fires when authentication has succeeded or
-        which fails with L{UnauthorizedLogin} if the server rejects the
-        authentication attempt.
-    """
-    if not IUsernamePassword.providedBy(credentials):
-        raise UnhandledCredentials()
-    d = client.callRemote(
-        PasswordLogin, username=credentials.username)
-    def cbChallenge(response):
-        args = PasswordChallengeResponse.determineFrom(
-            response['challenge'], credentials.password)
-        d = client.callRemote(PasswordChallengeResponse, **args)
-        return d.addCallback(lambda ignored: client)
-    d.addCallback(cbChallenge)
-    return d
-
-
-
-__all__ = [
-    'UnhandledCredentials',
-
-    'OTPLogin', 'OneTimePadChecker',
-
-    'PasswordLogin', 'PasswordChallengeResponse', 'CredReceiver',
-
-    'CredAMPServerFactory', 'login']

=== removed file 'Epsilon/epsilon/amprouter.py'
--- Epsilon/epsilon/amprouter.py	2008-08-29 16:02:56 +0000
+++ Epsilon/epsilon/amprouter.py	1970-01-01 00:00:00 +0000
@@ -1,205 +0,0 @@
-# -*- test-case-name: epsilon.test.test_amprouter -*-
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-"""
-This module provides an implementation of I{Routes}, a system for multiplexing
-multiple L{IBoxReceiver}/I{IBoxSender} pairs over a single L{AMP} connection.
-"""
-
-from itertools import count
-
-from zope.interface import implements
-
-from twisted.protocols.amp import IBoxReceiver, IBoxSender
-
-from epsilon.structlike import record
-
-__metaclass__ = type
-
-_ROUTE = '_route'
-_unspecified = object()
-
-
-class RouteNotConnected(Exception):
-    """
-    An attempt was made to send AMP boxes through a L{Route} which is not yet
-    connected to anything.
-    """
-
-
-
-class Route(record('router receiver localRouteName remoteRouteName',
-                   remoteRouteName=_unspecified)):
-    """
-    Wrap up a route name and a box sender to transparently add the route name
-    to boxes sent through this box sender.
-
-    @ivar router: The L{Router} which created this route.  This will be used
-        for route tear down and for its L{IBoxSender}, to send boxes.
-
-    @ivar receiver: The receiver which will be started with this object as its
-        sender.
-
-    @type localRouteName: C{unicode}
-    @ivar localRouteName: The name of this route as known by the other side of
-        the AMP connection.  AMP boxes with this route are expected to be
-        routed to this object.
-
-    @type remoteRouteName: C{unicode} or L{NoneType}
-    @ivar remoteRouteName: The name of the route which will be added to all
-        boxes sent to this sender.  If C{None}, no route will be added.
-    """
-    implements(IBoxSender)
-
-    def connectTo(self, remoteRouteName):
-        """
-        Set the name of the route which will be added to outgoing boxes.
-        """
-        self.remoteRouteName = remoteRouteName
-        # This route must not be started before its router is started.  If
-        # sender is None, then the router is not started.  When the router is
-        # started, it will start this route.
-        if self.router._sender is not None:
-            self.start()
-
-
-    def unbind(self):
-        """
-        Remove the association between this route and its router.
-        """
-        del self.router._routes[self.localRouteName]
-
-
-    def start(self):
-        """
-        Associate this object with a receiver as its L{IBoxSender}.
-        """
-        self.receiver.startReceivingBoxes(self)
-
-
-    def stop(self, reason):
-        """
-        Shut down the underlying receiver.
-        """
-        self.receiver.stopReceivingBoxes(reason)
-
-
-    def sendBox(self, box):
-        """
-        Add the route and send the box.
-        """
-        if self.remoteRouteName is _unspecified:
-            raise RouteNotConnected()
-        if self.remoteRouteName is not None:
-            box[_ROUTE] = self.remoteRouteName.encode('ascii')
-        self.router._sender.sendBox(box)
-
-
-    def unhandledError(self, failure):
-        """
-        Pass failures through to the wrapped L{IBoxSender} without
-        modification.
-        """
-        self.router._sender.unhandledError(failure)
-
-
-
-class Router:
-    """
-    An L{IBoxReceiver} implementation which demultiplexes boxes from an AMP
-    connection being used with zero, one, or more routes.
-
-    @ivar _sender: An L{IBoxSender} provider which is used to allow
-        L{IBoxReceiver}s added to this router to send boxes.
-
-    @ivar _unstarted: A C{dict} similar to C{_routes} set before
-        C{startReceivingBoxes} is called and containing all routes which have
-        been added but not yet started.  These are started and moved to the
-        C{_routes} dict when the router is started.
-
-    @ivar _routes: A C{dict} mapping local route identifiers to
-        L{IBoxReceivers} associated with them.  This is only initialized after
-        C{startReceivingBoxes} is called.
-
-    @ivar _routeCounter: A L{itertools.count} instance used to generate unique
-        identifiers for routes in this router.
-    """
-    implements(IBoxReceiver)
-
-    _routes = None
-    _sender = None
-
-    def __init__(self):
-        self._routeCounter = count()
-        self._unstarted = {}
-
-
-    def createRouteIdentifier(self):
-        """
-        Return a route identifier which is not yet associated with a route on
-        this dispatcher.
-
-        @rtype: C{unicode}
-        """
-        return unicode(self._routeCounter.next())
-
-
-    def bindRoute(self, receiver, routeName=_unspecified):
-        """
-        Create a new route to associate the given route name with the given
-        receiver.
-
-        @type routeName: C{unicode} or L{NoneType}
-        @param routeName: The identifier for the newly created route.  If
-            C{None}, boxes with no route in them will be delivered to this
-            receiver.
-
-        @rtype: L{Route}
-        """
-        if routeName is _unspecified:
-            routeName = self.createRouteIdentifier()
-        # self._sender may yet be None; if so, this route goes into _unstarted
-        # and will have its sender set correctly in startReceivingBoxes below.
-        route = Route(self, receiver, routeName)
-        mapping = self._routes
-        if mapping is None:
-            mapping = self._unstarted
-        mapping[routeName] = route
-        return route
-
-
-    def startReceivingBoxes(self, sender):
-        """
-        Initialize route tracking objects.
-        """
-        self._sender = sender
-        for routeName, route in self._unstarted.iteritems():
-            # Any route which has been bound but which does not yet have a
-            # remote route name should not yet be started.  These will be
-            # started in Route.connectTo.
-            if route.remoteRouteName is not _unspecified:
-                route.start()
-        self._routes = self._unstarted
-        self._unstarted = None
-
-
-    def ampBoxReceived(self, box):
-        """
-        Dispatch the given box to the L{IBoxReceiver} associated with the route
-        indicated by the box, or handle it directly if there is no route.
-        """
-        route = box.pop(_ROUTE, None)
-        self._routes[route].receiver.ampBoxReceived(box)
-
-
-    def stopReceivingBoxes(self, reason):
-        """
-        Stop all the L{IBoxReceiver}s which have been added to this router.
-        """
-        for routeName, route in self._routes.iteritems():
-            route.stop(reason)
-        self._routes = None
-
-
-
-__all__ = ['Router', 'Route']

=== removed file 'Epsilon/epsilon/asplode.py'
--- Epsilon/epsilon/asplode.py	2005-12-02 20:28:41 +0000
+++ Epsilon/epsilon/asplode.py	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-
-import sys, os
-from datetime import date
-
-def status(x):
-    sys.stderr.write(x+'\n')
-    sys.stderr.flush()
-
-def splode(linerator, proj, capproj):
-    current = None
-    for line in linerator:
-        line = line.replace('_project_', proj)
-        line = line.replace('_Project_', capproj)
-        line = line.replace('_date_', str(date.today()))
-        ls = line.split("###file:")
-        if len(ls) > 1:
-            fname = ls[1].strip()
-            if current is not None:
-                current.close()
-            try:
-                os.makedirs(os.path.dirname(fname))
-            except:
-                pass
-            current = file(fname, 'wb')
-            status('Created: ' + fname)
-        else:
-            current.write(line)
-    current.close()
-
-def main(argv):
-    splode(sys.stdin.readlines(), 'zoop', 'Zoop')
-
-if __name__ == '__main__':
-    main(sys.argv)

=== removed file 'Epsilon/epsilon/caseless.py'
--- Epsilon/epsilon/caseless.py	2008-04-16 12:34:02 +0000
+++ Epsilon/epsilon/caseless.py	1970-01-01 00:00:00 +0000
@@ -1,135 +0,0 @@
-# -*- test-case-name: epsilon.test.test_caseless -*-
-"""
-Helpers for case-insensitive string handling.
-"""
-
-class Caseless(object):
-    """
-    Case-insensitive string wrapper type.
-    
-    This wrapper is intended for use with strings that have case-insensitive
-    semantics, such as HTTP/MIME header values.  It implements comparison-based
-    operations case-insensitively, avoiding the need to manually call C{lower}
-    where appropriate, or keep track of which strings are case-insensitive
-    throughout various function calls.
-
-    Example usage:
-
-        >>> Caseless('Spam') == Caseless('spam')
-        True
-        >>> 'spam' in Caseless('Eggs and Spam')
-        True
-
-        >>> sorted(['FOO', 'bar'], key=Caseless)
-        ['bar', 'FOO']
-
-        >>> d = {Caseless('Content-type'): Caseless('Text/Plain')}
-        >>> d[Caseless('Content-Type')].startswith('text/')
-        True
-
-    Note:  String methods that return modified strings (such as
-    C{decode}/C{encode}, C{join}, C{partition}, C{replace}, C{strip}/C{split})
-    don't have an unambiguous return types with regards to case sensitivity, so
-    they are not implemented by L{Caseless}.  They should be accessed on the
-    underlying cased string instead.  (Excepted are methods like
-    C{lower}/C{upper}, whose return case is unambiguous.)
-
-    @ivar cased:  the wrapped string-like object
-    """
-
-    def __init__(self, cased):
-        if isinstance(cased, Caseless):
-            cased = cased.cased
-        self.cased = cased
-
-
-    def __repr__(self):
-        return '%s(%r)' % (type(self).__name__, self.cased)
-
-
-    # Methods delegated to cased
-
-    def __str__(self):
-        return str(self.cased)
-
-
-    def __unicode__(self):
-        return unicode(self.cased)
-
-
-    def __len__(self):
-        return len(self.cased)
-
-
-    def __getitem__(self, key):
-        return self.cased[key]
-
-
-    def __iter__(self):
-        return iter(self.cased)
-
-
-    def lower(self):
-        return self.cased.lower()
-
-
-    def upper(self):
-        return self.cased.upper()
-
-
-    def title(self):
-        return self.cased.title()
-
-
-    def swapcase(self):
-        return self.cased.swapcase()
-
-
-    # Methods delegated to lower()
-
-    def __cmp__(self, other):
-        return cmp(self.lower(), other.lower())
-
-
-    def __hash__(self):
-        return hash(self.lower())
-
-
-    def __contains__(self, substring):
-        return substring.lower() in self.lower()
-
-
-    def startswith(self, prefix, *rest):
-        if isinstance(prefix, tuple):
-            lprefix = tuple(s.lower() for s in prefix)
-        else:
-            lprefix = prefix.lower()
-        return self.lower().startswith(lprefix, *rest)
-
-
-    def endswith(self, suffix, *rest):
-        if isinstance(suffix, tuple):
-            lsuffix = tuple(s.lower() for s in suffix)
-        else:
-            lsuffix = suffix.lower()
-        return self.lower().endswith(lsuffix, *rest)
-
-
-    def count(self, substring, *rest):
-        return self.lower().count(substring.lower(), *rest)
-
-
-    def find(self, substring, *rest):
-        return self.lower().find(substring.lower(), *rest)
-
-
-    def index(self, substring, *rest):
-        return self.lower().index(substring.lower(), *rest)
-
-
-    def rfind(self, substring, *rest):
-        return self.lower().rfind(substring.lower(), *rest)
-
-
-    def rindex(self, substring, *rest):
-        return self.lower().rindex(substring.lower(), *rest)

=== removed file 'Epsilon/epsilon/cooperator.py'
--- Epsilon/epsilon/cooperator.py	2009-05-22 13:21:37 +0000
+++ Epsilon/epsilon/cooperator.py	1970-01-01 00:00:00 +0000
@@ -1,32 +0,0 @@
-
-from twisted.application.service import Service
-from twisted.internet.task import SchedulerStopped, Cooperator, coiterate
-
-def iterateInReactor(i, delay=None):
-    """
-    Cooperatively iterate over the given iterator.
-
-    @see: L{twisted.internet.task.coiterate}.
-    """
-    return coiterate(i)
-
-
-class SchedulingService(Service):
-    """
-    Simple L{IService} implementation.
-    """
-    def __init__(self):
-        self.coop = Cooperator(started=False)
-
-    def addIterator(self, iterator):
-        return self.coop.coiterate(iterator)
-
-    def startService(self):
-        self.coop.start()
-
-    def stopService(self):
-        self.coop.stop()
-
-__all__ = [
-    'SchedulerStopped', 'Cooperator',
-    'SchedulingService', 'iterateInReactor']

=== removed file 'Epsilon/epsilon/descriptor.py'
--- Epsilon/epsilon/descriptor.py	2008-02-08 14:07:46 +0000
+++ Epsilon/epsilon/descriptor.py	1970-01-01 00:00:00 +0000
@@ -1,147 +0,0 @@
-# -*- test-case-name: epsilon.test.test_descriptor -*-
-
-"""
-Provides an 'attribute' class for one-use descriptors.
-"""
-
-attribute = None
-
-class _MetaAttribute(type):
-    def __new__(meta, name, bases, dict):
-        # for reals, yo.
-        for kw in ['get', 'set', 'delete']:
-            if kw in dict:
-                dict[kw] = staticmethod(dict[kw])
-        secretClass = type.__new__(meta, name, bases, dict)
-        if attribute is None:
-            return secretClass
-        return secretClass()
-
-class attribute(object):
-    """
-    Convenience class for providing one-shot descriptors, similar to
-    'property'.  For example:
-
-        >>> from epsilon.descriptor import attribute
-        >>> class Dynamo(object):
-        ...  class dynamic(attribute):
-        ...   def get(self):
-        ...    self.dynCount += 1
-        ...    return self.dynCount
-        ...   def set(self, value):
-        ...    self.dynCount += value
-        ...  dynCount = 0
-        ...
-        >>> d = Dynamo()
-        >>> d.dynamic
-        1
-        >>> d.dynamic
-        2
-        >>> d.dynamic = 6
-        >>> d.dynamic
-        9
-        >>> d.dynamic
-        10
-        >>> del d.dynamic
-        Traceback (most recent call last):
-            ...
-        AttributeError: attribute cannot be removed
-    """
-
-    __metaclass__ = _MetaAttribute
-
-    def __get__(self, oself, type):
-        """
-        Private implementation of descriptor interface.
-        """
-        if oself is None:
-            return self
-        return self.get(oself)
-
-    def __set__(self, oself, value):
-        """
-        Private implementation of descriptor interface.
-        """
-        return self.set(oself, value)
-
-    def __delete__(self, oself):
-        """
-        Private implementation of descriptor interface.
-        """
-        return self.delete(oself)
-
-    def set(self, value):
-        """
-        Implement this method to provide attribute setting.  Default behavior
-        is that attributes are not settable.
-        """
-        raise AttributeError('read only attribute')
-
-    def get(self):
-        """
-        Implement this method to provide attribute retrieval.  Default behavior
-        is that unset attributes do not have any value.
-        """
-        raise AttributeError('attribute has no value')
-
-    def delete(self):
-        """
-        Implement this method to provide attribute deletion.  Default behavior
-        is that attributes cannot be deleted.
-        """
-        raise AttributeError('attribute cannot be removed')
-
-
-
-def requiredAttribute(requiredAttributeName):
-    """
-    Utility for defining attributes on base classes/mixins which require their
-    values to be supplied by their derived classes.  C{None} is a common, but
-    almost never suitable default value for these kinds of attributes, as it
-    may cause operations in the derived class to fail silently in peculiar
-    ways.  If a C{requiredAttribute} is accessed before having its value
-    changed, a C{AttributeError} will be raised with a helpful error message.
-
-    @param requiredAttributeName: The name of the required attribute.
-    @type requiredAttributeName: C{str}
-
-    Example:
-        >>> from epsilon.descriptor import requiredAttribute
-        ...
-        >>> class FooTestMixin:
-        ...  expectedResult = requiredAttribute('expectedResult')
-        ...
-        >>> class BrokenFooTestCase(TestCase, FooTestMixin):
-        ...  pass
-        ...
-        >>> brokenFoo = BrokenFooTestCase()
-        >>> print brokenFoo.expectedResult
-        Traceback (most recent call last):
-            ...
-        AttributeError: Required attribute 'expectedResult' has not been
-                        changed from its default value on '<BrokenFooTestCase
-                        instance>'.
-        ...
-        >>> class WorkingFooTestCase(TestCase, FooTestMixin):
-        ...  expectedResult = 7
-        ...
-        >>> workingFoo = WorkingFooTestCase()
-        >>> print workingFoo.expectedResult
-        ... 7
-        >>>
-    """
-    class RequiredAttribute(attribute):
-        def get(self):
-            if requiredAttributeName not in self.__dict__:
-                raise AttributeError(
-                    ('Required attribute %r has not been changed'
-                     ' from its default value on %r' % (
-                            requiredAttributeName, self)))
-            return self.__dict__[requiredAttributeName]
-        def set(self, value):
-            self.__dict__[requiredAttributeName] = value
-    return RequiredAttribute
-
-
-
-__all__ = ['attribute', 'requiredAttribute']

=== removed file 'Epsilon/epsilon/expose.py'
--- Epsilon/epsilon/expose.py	2008-08-13 02:55:58 +0000
+++ Epsilon/epsilon/expose.py	1970-01-01 00:00:00 +0000
@@ -1,141 +0,0 @@
-# Copright 2008 Divmod, Inc.  See LICENSE file for details.
-# -*- test-case-name: epsilon.test.test_expose -*-
-
-"""
-This module provides L{Exposer}, a utility for creating decorators that expose
-methods on types for a particular purpose.
-
-The typical usage of this module is for an infrastructure layer (usually one
-that allows methods to be invoked from the network, directly or indirectly) to
-provide an explicit API for exposing those methods securely.
-
-For example, a sketch of a finger protocol implementation which could use this
-to expose the results of certain methods as finger results::
-
-    # tx_finger.py
-    fingermethod = Exposer("This object exposes finger methods.")
-    ...
-    class FingerProtocol(Protocol):
-        def __init__(self, fingerModel):
-            self.model = fingerModel
-        ...
-        def fingerQuestionReceived(self, whichUser):
-            try:
-                method = fingermethod.get(self.model, whichUser)
-            except MethodNotExposed:
-                method = lambda : "Unknown user"
-            return method()
-
-    # myfingerserver.py
-    from tx_finger import fingermethod
-    ...
-    class MyFingerModel(object):
-        @fingermethod.expose("bob")
-        def someMethod(self):
-            return "Bob is great."
-
-Assuming lots of protocol code to hook everything together, this would then
-allow you to use MyFingerModel and 'finger bob' to get the message 'Bob is
-great.'
-"""
-
-import inspect
-
-from types import FunctionType
-
-
-class MethodNotExposed(Exception):
-    """
-    The requested method was not exposed for the purpose requested.  More
-    specifically, L{Exposer.get} was used to retrieve a key from an object
-    which does not expose that key with that exposer.
-    """
-
-
-class NameRequired(Exception):
-    """
-    L{Exposer.expose} was used to decorate a non-function object without having
-    a key explicitly specified.
-    """
-
-
-
-class Exposer(object):
-    """
-    This is an object that can expose and retrieve methods on classes.
-
-    @ivar _exposed: a dict mapping exposed keys to exposed function objects.
-    """
-
-    def __init__(self, doc):
-        """
-        Create an exposer.
-        """
-        self.__doc__ = doc
-        self._exposed = {}
-
-
-    def expose(self, key=None):
-        """
-        Expose the decorated method for this L{Exposer} with the given key.  A
-        method which is exposed will be able to be retrieved by this
-        L{Exposer}'s C{get} method with that key.  If no key is provided, the
-        key is the method name of the exposed method.
-
-        Use like so::
-
-            class MyClass:
-                @someExposer.expose()
-                def foo(): ...
-
-        or::
-
-            class MyClass:
-                @someExposer.expose('foo')
-                def unrelatedMethodName(): ...
-
-        @param key: a hashable object, used by L{Exposer.get} to look up the
-        decorated method later.  If None, the key is the exposed method's name.
-
-        @return: a 1-argument callable which records its input as exposed, then
-        returns it.
-        """
-        def decorator(function):
-            rkey = key
-            if rkey is None:
-                if isinstance(function, FunctionType):
-                    rkey = function.__name__
-                else:
-                    raise NameRequired()
-            if rkey not in self._exposed:
-                self._exposed[rkey] = []
-            self._exposed[rkey].append(function)
-            return function
-        return decorator
-
-
-    def get(self, obj, key):
-        """
-        Retrieve 'key' from an instance of a class which previously exposed it.
-
-        @param key: a hashable object, previously passed to L{Exposer.expose}.
-
-        @return: the object which was exposed with the given name on obj's key.
-
-        @raise MethodNotExposed: when the key in question was not exposed with
-        this exposer.
-        """
-        if key not in self._exposed:
-            raise MethodNotExposed()
-        rightFuncs = self._exposed[key]
-        T = obj.__class__
-        seen = {}
-        for subT in inspect.getmro(T):
-            for name, value in subT.__dict__.items():
-                for rightFunc in rightFuncs:
-                    if value is rightFunc:
-                        if name in seen:
-                            raise MethodNotExposed()
-                        return value.__get__(obj, T)
-                seen[name] = True
-        raise MethodNotExposed()

=== removed file 'Epsilon/epsilon/extime.py'
--- Epsilon/epsilon/extime.py	2009-11-16 19:09:42 +0000
+++ Epsilon/epsilon/extime.py	1970-01-01 00:00:00 +0000
@@ -1,980 +0,0 @@
-# -*- test-case-name: epsilon.test.test_extime -*-
-"""
-Extended date/time formatting and miscellaneous functionality.
-
-See the class 'Time' for details.
-"""
-
-import datetime
-import re
-
-from email.Utils import parsedate_tz
-
-_EPOCH = datetime.datetime.utcfromtimestamp(0)
-
-
-class InvalidPrecision(Exception):
-    """
-    L{Time.asHumanly} was passed an invalid precision value.
-    """
-
-
-
-def sanitizeStructTime(struct):
-    """
-    Convert struct_time tuples with possibly invalid values to valid
-    ones by substituting the closest valid value.
-    """
-    maxValues = (9999, 12, 31, 23, 59, 59)
-    minValues = (1, 1, 1, 0, 0, 0)
-    newstruct = []
-    for value, maxValue, minValue in zip(struct[:6], maxValues, minValues):
-        newstruct.append(max(minValue, min(value, maxValue)))
-    return tuple(newstruct) + struct[6:]
-
-def _timedeltaToSignHrMin(offset):
-    """
-    Return a (sign, hour, minute) triple for the offset described by timedelta.
-
-    sign is a string, either "+" or "-". In the case of 0 offset, sign is "+".
-    """
-    minutes = round((offset.days * 3600000000 * 24
-                     + offset.seconds * 1000000
-                     + offset.microseconds)
-                    / 60000000.0)
-    if minutes < 0:
-        sign = '-'
-        minutes = -minutes
-    else:
-        sign = '+'
-    return (sign, minutes // 60, minutes % 60)
-
-def _timedeltaToSeconds(offset):
-    """
-    Convert a datetime.timedelta instance to simply a number of seconds.
-
-    For example, you can specify purely second intervals with timedelta's
-    constructor:
-
-        >>> td = datetime.timedelta(seconds=99999999)
-
-    but then you can't get them out again:
-
-        >>> td.seconds
-        35199
-
-    This allows you to:
-
-        >>> import epsilon.extime
-        >>> epsilon.extime._timedeltaToSeconds(td)
-        99999999.0
-
-    @param offset: a L{datetime.timedelta} representing an interval that we
-    wish to know the total number of seconds for.
-
-    @return: a number of seconds
-    @rtype: float
-    """
-    return ((offset.days * 60*60*24) +
-            (offset.seconds) +
-            (offset.microseconds * 1e-6))
-
-class FixedOffset(datetime.tzinfo):
-    _zeroOffset = datetime.timedelta()
-
-    def __init__(self, hours, minutes):
-        self.offset = datetime.timedelta(minutes = hours * 60 + minutes)
-
-    def utcoffset(self, dt):
-        return self.offset
-
-    def tzname(self, dt):
-        return _timedeltaToSignHrMin(self.offset)
-
-    def dst(self, tz):
-        return self._zeroOffset
-
-    def __repr__(self):
-        return '<%s.%s object at 0x%x offset %r>' % (
-            self.__module__, type(self).__name__, id(self), self.offset)
-
-
-
-class Time(object):
-    """An object representing a well defined instant in time.
-
-    A Time object unambiguously addresses some time, independent of timezones,
-    contorted base-60 counting schemes, leap seconds, and the effects of
-    general relativity. It provides methods for returning a representation of
-    this time in various ways that a human or a programmer might find more
-    useful in various applications.
-
-    Every Time instance has an attribute 'resolution'. This can be ignored, or
-    the instance can be considered to address a span of time. This resolution
-    is determined by the value used to initalize the instance, or the
-    resolution of the internal representation, whichever is greater. It is
-    mostly useful when using input formats that allow the specification of
-    whole days or weeks. For example, ISO 8601 allows one to state a time as,
-    "2005-W03", meaning "the third week of 2005". In this case the resolution
-    is set to one week. Other formats are considered to express only an instant
-    in time, such as a POSIX timestamp, because the resolution of the time is
-    limited only by the hardware's representation of a real number.
-
-    Timezones are significant only for instances with a resolution greater than
-    one day. When the timezone is insignificant, the result of methods like
-    asISO8601TimeAndDate is the same for any given tzinfo parameter. Sort order
-    is determined by the start of the period in UTC. For example, "today" sorts
-    after "midnight today, central Europe", and before "midnight today, US
-    Eastern". For applications that need to store a mix of timezone dependent
-    and independent instances, it may be wise to store them separately, since
-    the time between the start and end of today in the local timezone may not
-    include the start of today in UTC, and thus not independent instances
-    addressing the whole day. In other words, the desired sort order (the one
-    where just "Monday" sorts before any more precise time in "Monday", and
-    after any in "Sunday") of Time instances is dependant on the timezone
-    context.
-
-    Date arithmetic and boolean operations operate on instants in time, not
-    periods. In this case, the start of the period is used as the value, and
-    the result has a resolution of 0.
-
-    For containment tests with the 'in' operator, the period addressed by the
-    instance is used.
-
-    The methods beginning with 'from' are constructors to create instances from
-    various formats. Some of them are textual formats, and others are other
-    time types commonly found in Python code.
-
-    Likewise, methods beginning with 'as' return the represented time in
-    various formats. Some of these methods should try to reflect the resolution
-    of the instance. However, they don't yet.
-
-    For formats with both a constructor and a formatter, d == fromFu(d.asFu())
-
-    @type resolution: datetime.timedelta
-    @ivar resolution: the length of the period to which this instance could
-    refer. For example, "Today, 13:38" could refer to any time between 13:38
-    until but not including 13:39. In this case resolution would be
-    timedelta(minutes=1).
-    """
-
-    # the instance variable _time is the internal representation of time. It
-    # is a naive datetime object which is always UTC. A UTC tzinfo would be
-    # great, if one existed, and anyway it complicates pickling.
-
-
-    class Precision(object):
-        MINUTES = object() 
-        SECONDS = object()
-
-
-    _timeFormat = {
-            Precision.MINUTES: '%I:%M %p',
-            Precision.SECONDS: '%I:%M:%S %p'}
-
-    rfc2822Weekdays = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
-
-    rfc2822Months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug',
-                     'Sep', 'Oct', 'Nov', 'Dec']
-
-    resolution = datetime.timedelta.resolution
-
-    #
-    # Methods to create new instances
-    #
-
-    def __init__(self):
-        """Return a new Time instance representing the time now.
-
-        See also the fromFu methods to create new instances from other types of
-        initializers.
-        """
-        self._time = datetime.datetime.utcnow()
-
-
-    def _fromWeekday(klass, match, tzinfo, now):
-        weekday = klass.weekdays.index(match.group('weekday').lower())
-        dtnow = now.asDatetime().replace(
-            hour=0, minute=0, second=0, microsecond=0)
-        daysInFuture = (weekday - dtnow.weekday()) % len(klass.weekdays)
-        if daysInFuture == 0:
-            daysInFuture = 7
-        self = klass.fromDatetime(dtnow + datetime.timedelta(days=daysInFuture))
-        assert self.asDatetime().weekday() == weekday
-        self.resolution = datetime.timedelta(days=1)
-        return self
-
-
-    def _fromTodayOrTomorrow(klass, match, tzinfo, now):
-        dtnow = now.asDatetime().replace(
-            hour=0, minute=0, second=0, microsecond=0)
-        when = match.group(0).lower()
-        if when == 'tomorrow':
-            dtnow += datetime.timedelta(days=1)
-        elif when == 'yesterday':
-            dtnow -= datetime.timedelta(days=1)
-        else:
-            assert when == 'today'
-        self = klass.fromDatetime(dtnow)
-        self.resolution = datetime.timedelta(days=1)
-        return self
-
-
-    def _fromTime(klass, match, tzinfo, now):
-        minute = int(match.group('minute'))
-        hour = int(match.group('hour'))
-        ampm = (match.group('ampm') or '').lower()
-        if ampm:
-            if not 1 <= hour <= 12:
-                raise ValueError, 'hour %i is not in 1..12' % (hour,)
-            if hour == 12 and ampm == 'am':
-                hour = 0
-            elif ampm == 'pm':
-                hour += 12
-        if not 0 <= hour <= 23:
-            raise ValueError, 'hour %i is not in 0..23' % (hour,)
-
-        dtnow = now.asDatetime(tzinfo).replace(second=0, microsecond=0)
-        dtthen = dtnow.replace(hour=hour, minute=minute)
-        if dtthen < dtnow:
-            dtthen += datetime.timedelta(days=1)
-
-        self = klass.fromDatetime(dtthen)
-        self.resolution = datetime.timedelta(minutes=1)
-        return self
-
-
-    def _fromNoonOrMidnight(klass, match, tzinfo, now):
-        when = match.group(0).lower()
-        if when == 'noon':
-            hour = 12
-        else:
-            assert when == 'midnight'
-            hour = 0
-        dtnow = now.asDatetime(tzinfo).replace(
-            minute=0, second=0, microsecond=0)
-        dtthen = dtnow.replace(hour=hour)
-        if dtthen < dtnow:
-            dtthen += datetime.timedelta(days=1)
-
-        self = klass.fromDatetime(dtthen)
-        self.resolution = datetime.timedelta(minutes=1)
-        return self
-
-    def _fromNow(klass, match, tzinfo, now):
-        # coerce our 'now' argument to an instant
-        return now + datetime.timedelta(0)
-
-    weekdays = ['monday', 'tuesday', 'wednesday', 'thursday', 'friday',
-                'saturday', 'sunday']
-
-    humanlyPatterns = [
-        (re.compile(r"""
-            \b
-            ((next|this)\s+)?
-            (?P<weekday>
-                monday
-                | tuesday
-                | wednesday
-                | thursday
-                | friday
-                | saturday
-                | sunday
-            )
-            \b
-            """, re.IGNORECASE | re.VERBOSE),
-            _fromWeekday),
-        (re.compile(r"\b(today|tomorrow|yesterday)\b", re.IGNORECASE),
-            _fromTodayOrTomorrow),
-        (re.compile(r"""
-            \b
-            (?P<hour>\d{1,2}):(?P<minute>\d{2})
-            (\s*(?P<ampm>am|pm))?
-            \b
-            """, re.IGNORECASE | re.VERBOSE),
-            _fromTime),
-        (re.compile(r"\b(noon|midnight)\b", re.IGNORECASE),
-            _fromNoonOrMidnight),
-        (re.compile(r"\b(now)\b", re.IGNORECASE),
-            _fromNow),
-    ]
-
-    _fromWeekday = classmethod(_fromWeekday)
-    _fromTodayOrTomorrow = classmethod(_fromTodayOrTomorrow)
-    _fromTime = classmethod(_fromTime)
-    _fromNoonOrMidnight = classmethod(_fromNoonOrMidnight)
-    _fromNow = classmethod(_fromNow)
-
-
-    def fromHumanly(klass, humanStr, tzinfo=None, now=None):
-        """Return a new Time instance from a string a human might type.
-
-        @param humanStr: the string to be parsed.
-
-        @param tzinfo: A tzinfo instance indicating the timezone to assume if
-        none is specified in humanStr. If None, assume UTC.
-
-        @param now: A Time instance to be considered "now" for when
-        interpreting relative dates like "tomorrow". If None, use the real now.
-
-        Total crap now, it just supports weekdays, "today" and "tomorrow" for
-        now. This is pretty insufficient and useless, but good enough for some
-        demo functionality, or something.
-        """
-        humanStr = humanStr.strip()
-        if now is None:
-            now = Time()
-        if tzinfo is None:
-            tzinfo = FixedOffset(0, 0)
-
-        for pattern, creator in klass.humanlyPatterns:
-            match = pattern.match(humanStr)
-            if not match \
-            or match.span()[1] != len(humanStr):
-                continue
-            try:
-                return creator(klass, match, tzinfo, now)
-            except ValueError:
-                continue
-        raise ValueError, 'could not parse date: %r' % (humanStr,)
-
-    fromHumanly = classmethod(fromHumanly)
-
-
-    iso8601pattern = re.compile(r"""
-        ^ (?P<year> \d{4})
-        (
-            # a year may optionally be followed by one of:
-            # - a month
-            # - a week
-            # - a specific day, and an optional time
-            #     a specific day is one of:
-            #     - a month and day
-            #     - week and weekday
-            #     - a day of the year
-            (
-                -? (?P<month1> \d{2})
-                |
-                -? W (?P<week1> \d{2})
-                |
-                (
-                    -? (?P<month2> \d{2})
-                    -? (?P<day> \d{2})
-                    |
-                    -? W (?P<week2> \d{2})
-                    -? (?P<weekday> \d)
-                    |
-                    -? (?P<dayofyear> \d{3})
-                )
-                (
-                    T (?P<hour> \d{2})
-                    (
-                        :? (?P<minute> \d{2})
-                        (
-                            :? (?P<second> \d{2})
-                            (
-                                [\.,] (?P<fractionalsec> \d+)
-                            )?
-                        )?
-                    )?
-                    (
-                        (?P<zulu> Z)
-                        |
-                        (?P<tzhour> [+\-]\d{2})
-                        (
-                            :? (?P<tzmin> \d{2})
-                        )?
-                    )?
-                )?
-            )?
-        )? $""", re.VERBOSE)
-
-
-    def fromISO8601TimeAndDate(klass, iso8601string, tzinfo=None):
-        """Return a new Time instance from a string formated as in ISO 8601.
-
-        If the given string contains no timezone, it is assumed to be in the
-        timezone specified by the parameter `tzinfo`, or UTC if tzinfo is None.
-        An input string with an explicit timezone will always override tzinfo.
-
-        If the given iso8601string does not contain all parts of the time, they
-        will default to 0 in the timezone given by `tzinfo`.
-
-        WARNING: this function is incomplete. ISO is dumb and their standards
-        are not free. Only a subset of all valid ISO 8601 dates are parsed,
-        because I can't find a formal description of the format. However,
-        common ones should work.
-        """
-
-        def calculateTimezone():
-            if groups['zulu'] == 'Z':
-                return FixedOffset(0, 0)
-            else:
-                tzhour = groups.pop('tzhour')
-                tzmin = groups.pop('tzmin')
-                if tzhour is not None:
-                    return FixedOffset(int(tzhour), int(tzmin or 0))
-            return tzinfo or FixedOffset(0, 0)
-
-        def coerceGroups():
-            groups['month'] = groups['month1'] or groups['month2']
-            groups['week'] = groups['week1'] or groups['week2']
-            # don't include fractional seconds, because it's not an integer.
-            defaultTo0 = ['hour', 'minute', 'second']
-            defaultTo1 = ['month', 'day', 'week', 'weekday', 'dayofyear']
-            if groups['fractionalsec'] is None:
-                groups['fractionalsec'] = '0'
-            for key in defaultTo0:
-                if groups[key] is None:
-                    groups[key] = 0
-            for key in defaultTo1:
-                if groups[key] is None:
-                    groups[key] = 1
-            groups['fractionalsec'] = float('.'+groups['fractionalsec'])
-            for key in defaultTo0 + defaultTo1 + ['year']:
-                groups[key] = int(groups[key])
-
-            for group, min, max in [
-                # some years have only 52 weeks
-                ('week', 1, 53),
-                ('weekday', 1, 7),
-                ('month', 1, 12),
-                ('day', 1, 31),
-                ('hour', 0, 24),
-                ('minute', 0, 59),
-
-                # Sometime in the 22nd century AD, two leap seconds will be
-                # required every year.  In the 25th century AD, four every
-                # year.  We'll ignore that for now though because it would be
-                # tricky to get right and we certainly don't need it for our
-                # target applications.  In other words, post-singularity
-                # Martian users, please do not rely on this code for
-                # compatibility with Greater Galactic Protectorate of Earth
-                # date/time formatting!  Apologies, but no library I know of in
-                # Python is sufficient for processing their dates and times
-                # without ADA bindings to get the radiation-safety zone counter
-                # correct. -glyph
-
-                ('second', 0, 61),
-                # don't forget leap years
-                ('dayofyear', 1, 366)]:
-                if not min <= groups[group] <= max:
-                    raise ValueError, '%s must be in %i..%i' % (group, min, max)
-
-        def determineResolution():
-            if match.group('fractionalsec') is not None:
-                return max(datetime.timedelta.resolution,
-                    datetime.timedelta(
-                        microseconds=1 * 10 ** -len(
-                            match.group('fractionalsec')) * 1000000))
-
-            for testGroup, resolution in [
-            ('second', datetime.timedelta(seconds=1)),
-            ('minute', datetime.timedelta(minutes=1)),
-            ('hour', datetime.timedelta(hours=1)),
-            ('weekday', datetime.timedelta(days=1)),
-            ('dayofyear', datetime.timedelta(days=1)),
-            ('day', datetime.timedelta(days=1)),
-            ('week1', datetime.timedelta(weeks=1)),
-            ('week2', datetime.timedelta(weeks=1))]:
-                if match.group(testGroup) is not None:
-                    return resolution
-
-            if match.group('month1') is not None \
-            or match.group('month2') is not None:
-                if self._time.month == 12:
-                    return datetime.timedelta(days=31)
-                nextMonth = self._time.replace(month=self._time.month+1)
-                return nextMonth - self._time
-            else:
-                nextYear = self._time.replace(year=self._time.year+1)
-                return nextYear - self._time
-
-        def calculateDtime(tzinfo):
-            """Calculate a datetime for the start of the addressed period."""
-
-            if match.group('week1') is not None \
-            or match.group('week2') is not None:
-                if not 0 < groups['week'] <= 53:
-                    raise ValueError(
-                        'week must be in 1..53 (was %i)' % (groups['week'],))
-                dtime = datetime.datetime(
-                    groups['year'],
-                    1,
-                    4,
-                    groups['hour'],
-                    groups['minute'],
-                    groups['second'],
-                    int(round(groups['fractionalsec'] * 1000000)),
-                    tzinfo=tzinfo
-                )
-                dtime -= datetime.timedelta(days = dtime.weekday())
-                dtime += datetime.timedelta(
-                    days = (groups['week']-1) * 7 + groups['weekday'] - 1)
-                if dtime.isocalendar() != (
-                    groups['year'], groups['week'], groups['weekday']):
-                    # actually the problem could be an error in my logic, but
-                    # nothing should cause this but requesting week 53 of a
-                    # year with 52 weeks.
-                    raise ValueError('year %04i has no week %02i' %
-                                     (groups['year'], groups['week']))
-                return dtime
-
-            if match.group('dayofyear') is not None:
-                dtime = datetime.datetime(
-                    groups['year'],
-                    1,
-                    1,
-                    groups['hour'],
-                    groups['minute'],
-                    groups['second'],
-                    int(round(groups['fractionalsec'] * 1000000)),
-                    tzinfo=tzinfo
-                )
-                dtime += datetime.timedelta(days=groups['dayofyear']-1)
-                if dtime.year != groups['year']:
-                    raise ValueError(
-                        'year %04i has no day of year %03i' %
-                        (groups['year'], groups['dayofyear']))
-                return dtime
-
-            else:
-                return datetime.datetime(
-                    groups['year'],
-                    groups['month'],
-                    groups['day'],
-                    groups['hour'],
-                    groups['minute'],
-                    groups['second'],
-                    int(round(groups['fractionalsec'] * 1000000)),
-                    tzinfo=tzinfo
-                )
-
-
-        match = klass.iso8601pattern.match(iso8601string)
-        if match is None:
-            raise ValueError(
-                '%r could not be parsed as an ISO 8601 date and time' %
-                (iso8601string,))
-
-        groups = match.groupdict()
-        coerceGroups()
-        if match.group('hour') is not None:
-            timezone = calculateTimezone()
-        else:
-            timezone = None
-        self = klass.fromDatetime(calculateDtime(timezone))
-        self.resolution = determineResolution()
-        return self
-
-    fromISO8601TimeAndDate = classmethod(fromISO8601TimeAndDate)
-
-    def fromStructTime(klass, structTime, tzinfo=None):
-        """Return a new Time instance from a time.struct_time.
-
-        If tzinfo is None, structTime is in UTC. Otherwise, tzinfo is a
-        datetime.tzinfo instance coresponding to the timezone in which
-        structTime is.
-
-        Many of the functions in the standard time module return these things.
-        This will also work with a plain 9-tuple, for parity with the time
-        module. The last three elements, or tm_wday, tm_yday, and tm_isdst are
-        ignored.
-        """
-        dtime = datetime.datetime(tzinfo=tzinfo, *structTime[:6])
-        self = klass.fromDatetime(dtime)
-        self.resolution = datetime.timedelta(seconds=1)
-        return self
-
-    fromStructTime = classmethod(fromStructTime)
-
-    def fromDatetime(klass, dtime):
-        """Return a new Time instance from a datetime.datetime instance.
-
-        If the datetime instance does not have an associated timezone, it is
-        assumed to be UTC.
-        """
-        self = klass.__new__(klass)
-        if dtime.tzinfo is not None:
-            self._time = dtime.astimezone(FixedOffset(0, 0)).replace(tzinfo=None)
-        else:
-            self._time = dtime
-        self.resolution = datetime.timedelta.resolution
-        return self
-
-    fromDatetime = classmethod(fromDatetime)
-
-    def fromPOSIXTimestamp(klass, secs):
-        """Return a new Time instance from seconds since the POSIX epoch.
-
-        The POSIX epoch is midnight Jan 1, 1970 UTC. According to POSIX, leap
-        seconds don't exist, so one UTC day is exactly 86400 seconds, even if
-        it wasn't.
-
-        @param secs: a number of seconds, represented as an integer, long or
-        float.
-        """
-        self = klass.fromDatetime(_EPOCH + datetime.timedelta(seconds=secs))
-        self.resolution = datetime.timedelta()
-        return self
-
-    fromPOSIXTimestamp = classmethod(fromPOSIXTimestamp)
-
-    def fromRFC2822(klass, rfc822string):
-        """
-        Return a new Time instance from a string formated as described in RFC 2822.
-
-        @type rfc822string: str
-
-        @raise ValueError: if the timestamp is not formatted properly (or if
-        certain obsoleted elements of the specification are used).
-
-        @return: a new L{Time}
-        """
-
-        # parsedate_tz is going to give us a "struct_time plus", a 10-tuple
-        # containing the 9 values a struct_time would, i.e.: (tm_year, tm_mon,
-        # tm_day, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst), plus a
-        # bonus "offset", which is an offset (in _seconds_, of all things).
-
-        maybeStructTimePlus = parsedate_tz(rfc822string)
-
-        if maybeStructTimePlus is None:
-            raise ValueError, 'could not parse RFC 2822 date %r' % (rfc822string,)
-        structTimePlus = sanitizeStructTime(maybeStructTimePlus)
-        offsetInSeconds = structTimePlus[-1]
-        if offsetInSeconds is None:
-            offsetInSeconds = 0
-        self = klass.fromStructTime(
-            structTimePlus,
-            FixedOffset(
-                hours=0,
-                minutes=offsetInSeconds // 60))
-        self.resolution = datetime.timedelta(seconds=1)
-        return self
-
-    fromRFC2822 = classmethod(fromRFC2822)
-
-    #
-    # Methods to produce various formats
-    #
-
-    def asPOSIXTimestamp(self):
-        """Return this time as a timestamp as specified by POSIX.
-
-        This timestamp is the count of the number of seconds since Midnight,
-        Jan 1 1970 UTC, ignoring leap seconds.
-        """
-        mytimedelta = self._time - _EPOCH
-        return _timedeltaToSeconds(mytimedelta)
-
-    def asDatetime(self, tzinfo=None):
-        """Return this time as an aware datetime.datetime instance.
-
-        The returned datetime object has the specified tzinfo, or a tzinfo
-        describing UTC if the tzinfo parameter is None.
-        """
-        if tzinfo is None:
-            tzinfo = FixedOffset(0, 0)
-
-        if not self.isTimezoneDependent():
-            return self._time.replace(tzinfo=tzinfo)
-        else:
-            return self._time.replace(tzinfo=FixedOffset(0, 0)).astimezone(tzinfo)
-
-    def asNaiveDatetime(self, tzinfo=None):
-        """Return this time as a naive datetime.datetime instance.
-
-        The returned datetime object has its tzinfo set to None, but is in the
-        timezone given by the tzinfo parameter, or UTC if the parameter is
-        None.
-        """
-        return self.asDatetime(tzinfo).replace(tzinfo=None)
-
-    def asRFC2822(self, tzinfo=None, includeDayOfWeek=True):
-        """Return this Time formatted as specified in RFC 2822.
-
-        RFC 2822 specifies the format of email messages.
-
-        RFC 2822 says times in email addresses should reflect the local
-        timezone. If tzinfo is a datetime.tzinfo instance, the returned
-        formatted string will reflect that timezone. Otherwise, the timezone
-        will be '-0000', which RFC 2822 defines as UTC, but with an unknown
-        local timezone.
-
-        RFC 2822 states that the weekday is optional. The parameter
-        includeDayOfWeek indicates whether or not to include it.
-        """
-        dtime = self.asDatetime(tzinfo)
-
-        if tzinfo is None:
-            rfcoffset = '-0000'
-        else:
-            rfcoffset = '%s%02i%02i' % _timedeltaToSignHrMin(dtime.utcoffset())
-
-        rfcstring = ''
-        if includeDayOfWeek:
-            rfcstring += self.rfc2822Weekdays[dtime.weekday()] + ', '
-
-        rfcstring += '%i %s %4i %02i:%02i:%02i %s' % (
-            dtime.day,
-            self.rfc2822Months[dtime.month - 1],
-            dtime.year,
-            dtime.hour,
-            dtime.minute,
-            dtime.second,
-            rfcoffset)
-
-        return rfcstring
-
-    def asISO8601TimeAndDate(self, includeDelimiters=True, tzinfo=None,
-                             includeTimezone=True):
-        """Return this time formatted as specified by ISO 8861.
-
-        ISO 8601 allows optional dashes to delimit dates and colons to delimit
-        times. The parameter includeDelimiters (default True) defines the
-        inclusion of these delimiters in the output.
-
-        If tzinfo is a datetime.tzinfo instance, the output time will be in the
-        timezone given. If it is None (the default), then the timezone string
-        will not be included in the output, and the time will be in UTC.
-
-        The includeTimezone parameter coresponds to the inclusion of an
-        explicit timezone. The default is True.
-        """
-        if not self.isTimezoneDependent():
-            tzinfo = None
-        dtime = self.asDatetime(tzinfo)
-
-        if includeDelimiters:
-            dateSep = '-'
-            timeSep = ':'
-        else:
-            dateSep = timeSep = ''
-
-        if includeTimezone:
-            if tzinfo is None:
-                timezone = '+00%s00' % (timeSep,)
-            else:
-                sign, hour, min = _timedeltaToSignHrMin(dtime.utcoffset())
-                timezone = '%s%02i%s%02i' % (sign, hour, timeSep, min)
-        else:
-            timezone = ''
-
-        microsecond = ('%06i' % (dtime.microsecond,)).rstrip('0')
-        if microsecond:
-            microsecond = '.' + microsecond
-
-        parts = [
-            ('%04i' % (dtime.year,), datetime.timedelta(days=366)),
-            ('%s%02i' % (dateSep, dtime.month), datetime.timedelta(days=31)),
-            ('%s%02i' % (dateSep, dtime.day), datetime.timedelta(days=1)),
-            ('T', datetime.timedelta(hours=1)),
-            ('%02i' % (dtime.hour,), datetime.timedelta(hours=1)),
-            ('%s%02i' % (timeSep, dtime.minute), datetime.timedelta(minutes=1)),
-            ('%s%02i' % (timeSep, dtime.second), datetime.timedelta(seconds=1)),
-            (microsecond, datetime.timedelta(microseconds=1)),
-            (timezone, datetime.timedelta(hours=1))
-        ]
-
-        formatted = ''
-        for part, minResolution in parts:
-            if self.resolution <= minResolution:
-                formatted += part
-
-        return formatted
-
-    def asStructTime(self, tzinfo=None):
-        """Return this time represented as a time.struct_time.
-
-        tzinfo is a datetime.tzinfo instance coresponding to the desired
-        timezone of the output. If is is the default None, UTC is assumed.
-        """
-        dtime = self.asDatetime(tzinfo)
-        if tzinfo is None:
-            return dtime.utctimetuple()
-        else:
-            return dtime.timetuple()
-
-    def asHumanly(self, tzinfo=None, now=None, precision=Precision.MINUTES):
-        """Return this time as a short string, tailored to the current time.
-
-        Parts of the date that can be assumed are omitted. Consequently, the
-        output string depends on the current time. This is the format used for
-        displaying dates in most user visible places in the quotient web UI.
-
-        By default, the current time is determined by the system clock. The
-        current time used for formatting the time can be changed by providing a
-        Time instance as the parameter 'now'.
-
-        @param precision: The smallest unit of time that will be represented
-        in the returned string.  Valid values are L{Time.Precision.MINUTES} and
-        L{Time.Precision.SECONDS}.
-
-        @raise InvalidPrecision: if the specified precision is not either
-        L{Time.Precision.MINUTES} or L{Time.Precision.SECONDS}.
-        """
-        try:
-            timeFormat = Time._timeFormat[precision]
-        except KeyError:
-            raise InvalidPrecision(
-                    'Use Time.Precision.MINUTES or Time.Precision.SECONDS')
-
-        if now is None:
-            now = Time().asDatetime(tzinfo)
-        else:
-            now = now.asDatetime(tzinfo)
-        dtime = self.asDatetime(tzinfo)
-
-        # Same day?
-        if dtime.date() == now.date():
-            if self.isAllDay():
-                return 'all day'
-            return dtime.strftime(timeFormat).lower()
-        else:
-            res = str(dtime.date().day) + dtime.strftime(' %b')  # day + month
-            # Different year?
-            if not dtime.date().year == now.date().year:
-                res += dtime.strftime(' %Y')
-            if not self.isAllDay():
-                res += dtime.strftime(', %s' % (timeFormat,)).lower()
-            return res
-
-    #
-    # methods to return related times
-    #
-
-    def getBounds(self, tzinfo=None):
-        """
-        Return a pair describing the bounds of self.
-
-        This returns a pair (min, max) of Time instances. It is not quite the
-        same as (self, self + self.resolution). This is because timezones are
-        insignificant for instances with a resolution greater or equal to 1
-        day.
-
-        To illustrate the problem, consider a Time instance::
-
-            T = Time.fromHumanly('today', tzinfo=anything)
-
-        This will return an equivalent instance independent of the tzinfo used.
-        The hour, minute, and second of this instance are 0, and its resolution
-        is one day.
-
-        Now say we have a sorted list of times, and we want to get all times
-        for 'today', where whoever said 'today' is in a timezone that's 5 hours
-        ahead of UTC. The start of 'today' in this timezone is UTC 05:00. The
-        example instance T above is before this, but obviously it is today.
-
-        The min and max times this returns are such that all potentially
-        matching instances are within this range. However, this range might
-        contain unmatching instances.
-
-        As an example of this, if 'today' is April first 2005, then
-        Time.fromISO8601TimeAndDate('2005-04-01T00:00:00') sorts in the same
-        place as T from above, but is not in the UTC+5 'today'.
-
-        TIME IS FUN!
-        """
-        if self.resolution >= datetime.timedelta(days=1) \
-        and tzinfo is not None:
-            time = self._time.replace(tzinfo=tzinfo)
-        else:
-            time = self._time
-
-        return (
-            min(self.fromDatetime(time), self.fromDatetime(self._time)),
-            max(self.fromDatetime(time + self.resolution),
-                self.fromDatetime(self._time + self.resolution))
-        )
-
-    def oneDay(self):
-        """Return a Time instance representing the day of the start of self.
-
-        The returned new instance will be set to midnight of the day containing
-        the first instant of self in the specified timezone, and have a
-        resolution of datetime.timedelta(days=1).
-        """
-        day = self.__class__.fromDatetime(self.asDatetime().replace(
-                hour=0, minute=0, second=0, microsecond=0))
-        day.resolution = datetime.timedelta(days=1)
-        return day
-
-    #
-    # useful predicates
-    #
-
-    def isAllDay(self):
-        """Return True iff this instance represents exactly all day."""
-        return self.resolution == datetime.timedelta(days=1)
-
-    def isTimezoneDependent(self):
-        """Return True iff timezone is relevant for this instance.
-
-        Timezone is only relevent for instances with a resolution better than
-        one day.
-        """
-        return self.resolution < datetime.timedelta(days=1)
-
-    #
-    # other magic methods
-    #
-
-    def __cmp__(self, other):
-        if not isinstance(other, Time):
-            raise TypeError("Cannot meaningfully compare %r with %r" % (self, other))
-        return cmp(self._time, other._time)
-
-    def __eq__(self, other):
-        if isinstance(other, Time):
-            return cmp(self._time, other._time) == 0
-        return False
-
-    def __ne__(self, other):
-        return not (self == other)
-
-    def __repr__(self):
-        return 'extime.Time.fromDatetime(%r)' % (self._time,)
-
-    __str__ = asISO8601TimeAndDate
-
-    def __contains__(self, other):
-        """Test if another Time instance is entirely within the period addressed by this one."""
-        if not isinstance(other, Time):
-            raise TypeError(
-                '%r is not a Time instance; can not test for containment'
-                % (other,))
-        if other._time < self._time:
-            return False
-        if self._time + self.resolution < other._time + other.resolution:
-            return False
-        return True
-
-    def __add__(self, addend):
-        if not isinstance(addend, datetime.timedelta):
-            raise TypeError, 'expected a datetime.timedelta instance'
-        return Time.fromDatetime(self._time + addend)
-
-    def __sub__(self, subtrahend):
-        """
-        Implement subtraction of an interval or another time from this one.
-
-        @type subtrahend: L{datetime.timedelta} or L{Time}
-
-        @param subtrahend: The object to be subtracted from this one.
-
-        @rtype: L{datetime.timedelta} or L{Time}
-
-        @return: If C{subtrahend} is a L{datetime.timedelta}, the result is
-        a L{Time} instance which is offset from this one by that amount.  If
-        C{subtrahend} is a L{Time}, the result is a L{datetime.timedelta}
-        instance which gives the difference between it and this L{Time}
-        instance.
-        """
-        if isinstance(subtrahend, datetime.timedelta):
-            return Time.fromDatetime(self._time - subtrahend)
-
-        if isinstance(subtrahend, Time):
-            return self.asDatetime() - subtrahend.asDatetime()
-
-        return NotImplemented

=== removed file 'Epsilon/epsilon/hotfix.py'
--- Epsilon/epsilon/hotfix.py	2009-05-22 13:03:43 +0000
+++ Epsilon/epsilon/hotfix.py	1970-01-01 00:00:00 +0000
@@ -1,81 +0,0 @@
-
-import inspect
-
-class NoSuchHotfix(Exception):
-    """
-    Man you must be pretty stupid.
-    """
-
-_alreadyInstalled = set()
-def require(packageName, fixName):
-    if (packageName, fixName) in _alreadyInstalled:
-        return
-
-    if (packageName, fixName) == ('twisted', 'filepath_copyTo'):
-        from twisted.python import filepath
-        if filepath.FilePath('a') != filepath.FilePath('a'):
-            from epsilon.hotfixes import filepath_copyTo
-            filepath_copyTo.install()
-    elif (packageName, fixName) == ('twisted', 'timeoutmixin_calllater'):
-        from twisted.protocols import policies
-        if not hasattr(policies.TimeoutMixin, 'callLater'):
-            from epsilon.hotfixes import timeoutmixin_calllater
-            timeoutmixin_calllater.install()
-    elif (packageName, fixName) == ('twisted', 'delayedcall_seconds'):
-        from twisted.internet import base
-        args = inspect.getargs(base.DelayedCall.__init__.func_code)[0]
-        if 'seconds' not in args:
-            from epsilon.hotfixes import delayedcall_seconds
-            delayedcall_seconds.install()
-    elif (packageName, fixName) == ('twisted', 'deferredgenerator_tfailure'):
-        from twisted.internet import defer
-        result = []
-        def test():
-            d = defer.waitForDeferred(defer.succeed(1))
-            yield d
-            result.append(d.getResult())
-        defer.deferredGenerator(test)()
-        if result == [1]:
-            from epsilon.hotfixes import deferredgenerator_tfailure
-            deferredgenerator_tfailure.install()
-        else:
-            assert result == [None]
-    elif (packageName, fixName) == ("twisted", "proto_helpers_stringtransport"):
-        from twisted.test.proto_helpers import StringTransport
-        st = StringTransport()
-        try:
-            st.write(u'foo')
-        except TypeError, e:
-            pass
-        else:
-            from epsilon.hotfixes import proto_helpers_stringtransport
-            proto_helpers_stringtransport.install()
-    elif (packageName, fixName) == ("twisted", "internet_task_Clock"):
-        from twisted.internet.task import Clock
-        from twisted.internet import base
-        from twisted import version
-        from epsilon.hotfixes import internet_task_clock
-        if internet_task_clock.clockIsBroken():
-            internet_task_clock.install()
-    elif (packageName, fixName) == ("twisted", "trial_assertwarns"):
-        from twisted.trial.unittest import TestCase
-        if not hasattr(TestCase, "failUnlessWarns"):
-            from epsilon.hotfixes import trial_assertwarns
-            trial_assertwarns.install()
-    elif (packageName, fixName) == ("twisted", "plugin_package_paths"):
-        try:
-            from twisted.plugin import pluginPackagePaths
-        except ImportError:
-            from epsilon.hotfixes import plugin_package_paths
-            plugin_package_paths.install()
-    elif (packageName, fixName) == ("twisted", "loopbackasync_reentrancy"):
-        # This one is really hard to detect reasonably.  Invoking the code
-        # involves triggering the reactor, which it would be good to avoid. 
-        from twisted import version
-        if (version.major, version.minor) < (8, 2):
-            from epsilon.hotfixes import loopbackasync_reentrancy
-            loopbackasync_reentrancy.install()
-    else:
-        raise NoSuchHotfix(packageName, fixName)
-
-    _alreadyInstalled.add((packageName, fixName))

=== removed directory 'Epsilon/epsilon/hotfixes'
=== removed file 'Epsilon/epsilon/hotfixes/__init__.py'
=== removed file 'Epsilon/epsilon/hotfixes/deferredgenerator_tfailure.py'
--- Epsilon/epsilon/hotfixes/deferredgenerator_tfailure.py	2006-05-22 15:35:56 +0000
+++ Epsilon/epsilon/hotfixes/deferredgenerator_tfailure.py	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-
-from twisted.python import failure
-from twisted.internet import  defer
-
-def getResult(self):
-    if isinstance(self.result, failure.Failure):
-        self.result.raiseException()
-    return self.result
-
-
-def _deferGenerator(g, deferred=None):
-    """
-    See L{waitForDeferred}.
-    """
-    result = None
-    while 1:
-        if deferred is None:
-            deferred = defer.Deferred()
-        try:
-            result = g.next()
-        except StopIteration:
-            deferred.callback(result)
-            return deferred
-        except:
-            deferred.errback()
-            return deferred
-
-        # Deferred.callback(Deferred) raises an error; we catch this case
-        # early here and give a nicer error message to the user in case
-        # they yield a Deferred. Perhaps eventually these semantics may
-        # change.
-        if isinstance(result, defer.Deferred):
-            return defer.fail(TypeError("Yield waitForDeferred(d), not d!"))
-
-        if isinstance(result, defer.waitForDeferred):
-            waiting = [True, None]
-            # Pass vars in so they don't get changed going around the loop
-            def gotResult(r, waiting=waiting, result=result):
-                result.result = r
-                if waiting[0]:
-                    waiting[0] = False
-                    waiting[1] = r
-                else:
-                    _deferGenerator(g, deferred)
-            result.d.addBoth(gotResult)
-            if waiting[0]:
-                # Haven't called back yet, set flag so that we get reinvoked
-                # and return from the loop
-                waiting[0] = False
-                return deferred
-            result = None # waiting[1]
-
-
-def install():
-    getResult.__module__ = 'twisted.internet.defer'
-    defer.waitForDeferred.getResult = getResult
-
-    _deferGenerator.__module__ = 'twisted.internet.defer'
-    defer._deferGenerator = _deferGenerator

=== removed file 'Epsilon/epsilon/hotfixes/delayedcall_seconds.py'
--- Epsilon/epsilon/hotfixes/delayedcall_seconds.py	2006-05-19 15:23:46 +0000
+++ Epsilon/epsilon/hotfixes/delayedcall_seconds.py	1970-01-01 00:00:00 +0000
@@ -1,160 +0,0 @@
-
-import traceback
-
-from zope.interface import implements
-
-from twisted.persisted import styles
-from twisted.internet.interfaces import IDelayedCall
-from twisted.internet import error, base
-from twisted.python import reflect
-
-class DelayedCall(styles.Ephemeral):
-
-    implements(IDelayedCall)
-    # enable .debug to record creator call stack, and it will be logged if
-    # an exception occurs while the function is being run
-    debug = False
-    _str = None
-
-    def __init__(self, time, func, args, kw, cancel, reset, seconds=None):
-        self.time, self.func, self.args, self.kw = time, func, args, kw
-        self.resetter = reset
-        self.canceller = cancel
-        self.seconds = seconds
-        self.cancelled = self.called = 0
-        self.delayed_time = 0
-        if self.debug:
-            self.creator = traceback.format_stack()[:-2]
-
-    def getTime(self):
-        """Return the time at which this call will fire
-
-        @rtype: C{float}
-        @return: The number of seconds after the epoch at which this call is
-        scheduled to be made.
-        """
-        return self.time + self.delayed_time
-
-    def cancel(self):
-        """Unschedule this call
-
-        @raise AlreadyCancelled: Raised if this call has already been
-        unscheduled.
-
-        @raise AlreadyCalled: Raised if this call has already been made.
-        """
-        if self.cancelled:
-            raise error.AlreadyCancelled
-        elif self.called:
-            raise error.AlreadyCalled
-        else:
-            self.canceller(self)
-            self.cancelled = 1
-            if self.debug:
-                self._str = str(self)
-            del self.func, self.args, self.kw
-
-    def reset(self, secondsFromNow):
-        """Reschedule this call for a different time
-
-        @type secondsFromNow: C{float}
-        @param secondsFromNow: The number of seconds from the time of the
-        C{reset} call at which this call will be scheduled.
-
-        @raise AlreadyCancelled: Raised if this call has been cancelled.
-        @raise AlreadyCalled: Raised if this call has already been made.
-        """
-        if self.cancelled:
-            raise error.AlreadyCancelled
-        elif self.called:
-            raise error.AlreadyCalled
-        else:
-            if self.seconds is None:
-                new_time = base.seconds() + secondsFromNow
-            else:
-                new_time = self.seconds() + secondsFromNow
-            if new_time < self.time:
-                self.delayed_time = 0
-                self.time = new_time
-                self.resetter(self)
-            else:
-                self.delayed_time = new_time - self.time
-
-    def delay(self, secondsLater):
-        """Reschedule this call for a later time
-
-        @type secondsLater: C{float}
-        @param secondsLater: The number of seconds after the originally
-        scheduled time for which to reschedule this call.
-
-        @raise AlreadyCancelled: Raised if this call has been cancelled.
-        @raise AlreadyCalled: Raised if this call has already been made.
-        """
-        if self.cancelled:
-            raise error.AlreadyCancelled
-        elif self.called:
-            raise error.AlreadyCalled
-        else:
-            self.delayed_time += secondsLater
-            if self.delayed_time < 0:
-                self.activate_delay()
-                self.resetter(self)
-
-    def activate_delay(self):
-        self.time += self.delayed_time
-        self.delayed_time = 0
-
-    def active(self):
-        """Determine whether this call is still pending
-
-        @rtype: C{bool}
-        @return: True if this call has not yet been made or cancelled,
-        False otherwise.
-        """
-        return not (self.cancelled or self.called)
-
-    def __le__(self, other):
-        return self.time <= other.time
-
-    def __str__(self):
-        if self._str is not None:
-            return self._str
-        if hasattr(self, 'func'):
-            if hasattr(self.func, 'func_name'):
-                func = self.func.func_name
-                if hasattr(self.func, 'im_class'):
-                    func = self.func.im_class.__name__ + '.' + func
-            else:
-                func = reflect.safe_repr(self.func)
-        else:
-            func = None
-
-        if self.seconds is None:
-            now = base.seconds()
-        else:
-            now = self.seconds()
-        L = ["<DelayedCall %s [%ss] called=%s cancelled=%s" % (
-                id(self), self.time - now, self.called, self.cancelled)]
-        if func is not None:
-            L.extend((" ", func, "("))
-            if self.args:
-                L.append(", ".join([reflect.safe_repr(e) for e in self.args]))
-                if self.kw:
-                    L.append(", ")
-            if self.kw:
-                L.append(", ".join(['%s=%s' % (k, reflect.safe_repr(v)) for (k, v) in self.kw.iteritems()]))
-            L.append(")")
-
-        if self.debug:
-            L.append("\n\ntraceback at creation: \n\n%s" % ('    '.join(self.creator)))
-        L.append('>')
-
-        return "".join(L)
-
-
-def install():
-    global DelayedCall
-
-    base.DelayedCall.__dict__ = DelayedCall.__dict__
-    base.DelayedCall.__dict__['__module__'] = 'twisted.internet.base'
-    DelayedCall = base.DelayedCall

=== removed file 'Epsilon/epsilon/hotfixes/filepath_copyTo.py'
--- Epsilon/epsilon/hotfixes/filepath_copyTo.py	2005-12-06 07:36:12 +0000
+++ Epsilon/epsilon/hotfixes/filepath_copyTo.py	1970-01-01 00:00:00 +0000
@@ -1,403 +0,0 @@
-# -*- test-case-name: twisted.test.test_paths -*-
-# Copyright (c) 2001-2004 Twisted Matrix Laboratories.
-# See LICENSE for details.
-
-from __future__ import generators
-
-import os
-import errno
-import base64
-import random
-import sha
-
-from os.path import isabs, exists, normpath, abspath, splitext
-from os.path import basename, dirname
-from os.path import join as joinpath
-from os import sep as slash
-from os import listdir, utime, stat
-from os import remove
-
-from stat import ST_MODE, ST_MTIME, ST_ATIME, ST_CTIME, ST_SIZE
-
-from stat import S_ISREG, S_ISDIR, S_ISLNK
-
-try:
-    from os.path import islink
-except ImportError:
-    def islink(path):
-        return False
-
-try:
-    from os import urandom as randomBytes
-except ImportError:
-    def randomBytes(n):
-        randomData = [random.randrange(256) for n in xrange(n)]
-        return ''.join(map(chr, randomData))
-
-try:
-    from base64 import urlsafe_b64encode as armor
-except ImportError:
-    def armor(s):
-        return s.encode('hex')
-
-class InsecurePath(Exception):
-    pass
-
-def _secureEnoughString():
-    """
-    Create a pseudorandom, 16-character string for use in secure filenames.
-    """
-    return armor(sha.new(randomBytes(64)).digest())[:16]
-
-class FilePath:
-    """I am a path on the filesystem that only permits 'downwards' access.
-
-    Instantiate me with a pathname (for example,
-    FilePath('/home/myuser/public_html')) and I will attempt to only provide
-    access to files which reside inside that path.  I may be a path to a file,
-    a directory, or a file which does not exist.
-
-    The correct way to use me is to instantiate me, and then do ALL filesystem
-    access through me.  In other words, do not import the 'os' module; if you
-    need to open a file, call my 'open' method.  If you need to list a
-    directory, call my 'path' method.
-
-    Even if you pass me a relative path, I will convert that to an absolute
-    path internally.
-
-    @type alwaysCreate: C{bool}
-    @ivar alwaysCreate: When opening this file, only succeed if the file does not
-    already exist.
-    """
-
-    # __slots__ = 'path abs'.split()
-
-    statinfo = None
-
-    def __init__(self, path, alwaysCreate=False):
-        self.path = abspath(path)
-        self.alwaysCreate = alwaysCreate
-
-    def __getstate__(self):
-        d = self.__dict__.copy()
-        if d.has_key('statinfo'):
-            del d['statinfo']
-        return d
-
-    def child(self, path):
-        norm = normpath(path)
-        if slash in norm:
-            raise InsecurePath("%r contains one or more directory separators" % (path,))
-        newpath = abspath(joinpath(self.path, norm))
-        if not newpath.startswith(self.path):
-            raise InsecurePath("%r is not a child of %s" % (newpath, self.path))
-        return self.clonePath(newpath)
-
-    def preauthChild(self, path):
-        """
-        Use me if `path' might have slashes in it, but you know they're safe.
-
-        (NOT slashes at the beginning. It still needs to be a _child_).
-        """
-        newpath = abspath(joinpath(self.path, normpath(path)))
-        if not newpath.startswith(self.path):
-            raise InsecurePath("%s is not a child of %s" % (newpath, self.path))
-        return self.clonePath(newpath)
-
-    def childSearchPreauth(self, *paths):
-        """Return my first existing child with a name in 'paths'.
-
-        paths is expected to be a list of *pre-secured* path fragments; in most
-        cases this will be specified by a system administrator and not an
-        arbitrary user.
-
-        If no appropriately-named children exist, this will return None.
-        """
-        p = self.path
-        for child in paths:
-            jp = joinpath(p, child)
-            if exists(jp):
-                return self.clonePath(jp)
-
-    def siblingExtensionSearch(self, *exts):
-        """Attempt to return a path with my name, given multiple possible
-        extensions.
-
-        Each extension in exts will be tested and the first path which exists
-        will be returned.  If no path exists, None will be returned.  If '' is
-        in exts, then if the file referred to by this path exists, 'self' will
-        be returned.
-
-        The extension '*' has a magic meaning, which means "any path that
-        begins with self.path+'.' is acceptable".
-        """
-        p = self.path
-        for ext in exts:
-            if not ext and self.exists():
-                return self
-            if ext == '*':
-                basedot = basename(p)+'.'
-                for fn in listdir(dirname(p)):
-                    if fn.startswith(basedot):
-                        return self.clonePath(joinpath(dirname(p), fn))
-            p2 = p + ext
-            if exists(p2):
-                return self.clonePath(p2)
-
-    def siblingExtension(self, ext):
-        return self.clonePath(self.path+ext)
-
-    def open(self, mode='r'):
-        if self.alwaysCreate:
-            assert 'a' not in mode, "Appending not supported when alwaysCreate == True"
-            return self.create()
-        return open(self.path, mode+'b')
-
-    # stat methods below
-
-    def restat(self, reraise=True):
-        try:
-            self.statinfo = stat(self.path)
-        except OSError:
-            self.statinfo = 0
-            if reraise:
-                raise
-
-    def getsize(self):
-        st = self.statinfo
-        if not st:
-            self.restat()
-            st = self.statinfo
-        return st[ST_SIZE]
-
-    def getmtime(self):
-        st = self.statinfo
-        if not st:
-            self.restat()
-            st = self.statinfo
-        return st[ST_MTIME]
-
-    def getctime(self):
-        st = self.statinfo
-        if not st:
-            self.restat()
-            st = self.statinfo
-        return st[ST_CTIME]
-
-    def getatime(self):
-        st = self.statinfo
-        if not st:
-            self.restat()
-            st = self.statinfo
-        return st[ST_ATIME]
-
-    def exists(self):
-        if self.statinfo:
-            return True
-        elif self.statinfo is None:
-            self.restat(False)
-            return self.exists()
-        else:
-            return False
-
-    def isdir(self):
-        st = self.statinfo
-        if not st:
-            self.restat(False)
-            st = self.statinfo
-            if not st:
-                return False
-        return S_ISDIR(st[ST_MODE])
-
-    def isfile(self):
-        st = self.statinfo
-        if not st:
-            self.restat(False)
-            st = self.statinfo
-            if not st:
-                return False
-        return S_ISREG(st[ST_MODE])
-
-    def islink(self):
-        st = self.statinfo
-        if not st:
-            self.restat(False)
-            st = self.statinfo
-            if not st:
-                return False
-        return S_ISLNK(st[ST_MODE])
-
-    def isabs(self):
-        return isabs(self.path)
-
-    def listdir(self):
-        return listdir(self.path)
-
-    def splitext(self):
-        return splitext(self.path)
-
-    def __repr__(self):
-        return 'FilePath(%r)' % self.path
-
-    def touch(self):
-        try:
-            self.open('a').close()
-        except IOError:
-            pass
-        utime(self.path, None)
-
-    def remove(self):
-        if self.isdir():
-            for child in self.children():
-                child.remove()
-            os.rmdir(self.path)
-        else:
-            os.remove(self.path)
-        self.restat(False)
-
-    def makedirs(self):
-        return os.makedirs(self.path)
-
-    def globChildren(self, pattern):
-        """
-        Assuming I am representing a directory, return a list of
-        FilePaths representing my children that match the given
-        pattern.
-        """
-        import glob
-        path = self.path[-1] == '/' and self.path + pattern or slash.join([self.path, pattern])
-        return map(self.clonePath, glob.glob(path))
-
-    def basename(self):
-        return basename(self.path)
-
-    def dirname(self):
-        return dirname(self.path)
-
-    def parent(self):
-        return self.clonePath(self.dirname())
-
-    def setContent(self, content, ext='.new'):
-        sib = self.siblingExtension(ext)
-        sib.open('w').write(content)
-        os.rename(sib.path, self.path)
-
-    def getContent(self):
-        return self.open().read()
-
-    # new in 2.2.0
-
-    def __cmp__(self, other):
-        if not isinstance(other, FilePath):
-            return NotImplemented
-        return cmp(self.path, other.path)
-
-    def createDirectory(self):
-        os.mkdir(self.path)
-
-    def requireCreate(self, val=1):
-        self.alwaysCreate = val
-
-    def create(self):
-        """Exclusively create a file, only if this file previously did not exist.
-        """
-        fdint = os.open(self.path, (os.O_EXCL |
-                                    os.O_CREAT |
-                                    os.O_RDWR))
-
-        # XXX TODO: 'name' attribute of returned files is not mutable or
-        # settable via fdopen, so this file is slighly less functional than the
-        # one returned from 'open' by default.  send a patch to Python...
-
-        return os.fdopen(fdint, 'w+b')
-
-    def temporarySibling(self):
-        """
-        Create a path naming a temporary sibling of this path in a secure fashion.
-        """
-        sib = self.parent().child(_secureEnoughString() + self.basename())
-        sib.requireCreate()
-        return sib
-
-    def children(self):
-        return map(self.child, self.listdir())
-
-    def walk(self):
-        yield self
-        if self.isdir():
-            for c in self.children():
-                for subc in c.walk():
-                    yield subc
-
-    _chunkSize = 2 ** 2 ** 2 ** 2
-
-    def copyTo(self, destination):
-        # XXX TODO: *thorough* audit and documentation of the exact desired
-        # semantics of this code.  Right now the behavior of existent
-        # destination symlinks is convenient, and quite possibly correct, but
-        # its security properties need to be explained.
-        if self.isdir():
-            if not destination.exists():
-                destination.createDirectory()
-            for child in self.children():
-                destChild = destination.child(child.basename())
-                child.copyTo(destChild)
-        elif self.isfile():
-            writefile = destination.open('w')
-            readfile = self.open()
-            while 1:
-                # XXX TODO: optionally use os.open, os.read and O_DIRECT and
-                # use os.fstatvfs to determine chunk sizes and make
-                # *****sure**** copy is page-atomic; the following is good
-                # enough for 99.9% of everybody and won't take a week to audit
-                # though.
-                chunk = readfile.read(self._chunkSize)
-                writefile.write(chunk)
-                if len(chunk) < self._chunkSize:
-                    break
-            writefile.close()
-            readfile.close()
-        else:
-            # If you see the following message because you want to copy
-            # symlinks, fifos, block devices, character devices, or unix
-            # sockets, please feel free to add support to do sensible things in
-            # reaction to those types!
-            raise NotImplementedError(
-                "Only copying of files and directories supported")
-
-    def moveTo(self, destination):
-        try:
-            os.rename(self.path, destination.path)
-            self.restat(False)
-        except OSError, ose:
-            if ose.errno == errno.EXDEV:
-                # man 2 rename, ubuntu linux 5.10 "breezy":
-
-                #   oldpath and newpath are not on the same mounted filesystem.
-                #   (Linux permits a filesystem to be mounted at multiple
-                #   points, but rename(2) does not work across different mount
-                #   points, even if the same filesystem is mounted on both.)
-
-                # that means it's time to copy trees of directories!
-                secsib = destination.secureSibling()
-                self.copyTo(secsib) # slow
-                secsib.moveTo(destination) # visible
-
-                # done creating new stuff.  let's clean me up.
-                mysecsib = self.secureSibling()
-                self.moveTo(mysecsib) # visible
-                mysecsib.remove() # slow
-            else:
-                raise
-
-
-FilePath.clonePath = FilePath
-
-
-def install():
-    global FilePath
-
-    from twisted.python import filepath
-    filepath.FilePath.__dict__ = FilePath.__dict__
-    filepath.FilePath.__dict__['__module__'] = 'twisted.python.filepath'
-    FilePath = filepath.FilePath

=== removed file 'Epsilon/epsilon/hotfixes/internet_task_clock.py'
--- Epsilon/epsilon/hotfixes/internet_task_clock.py	2007-06-22 20:06:46 +0000
+++ Epsilon/epsilon/hotfixes/internet_task_clock.py	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-"""
-Fix from Twisted r20480.
-"""
-from twisted.internet.task import Clock
-from twisted.internet import base
-
-def callLater(self, when, what, *a, **kw):
-    """
-    Copied from twisted.internet.task.Clock, r20480.  Fixes the bug
-    where the wrong DelayedCall would sometimes be returned.
-    """
-    dc =  base.DelayedCall(self.seconds() + when,
-                           what, a, kw,
-                           self.calls.remove,
-                           lambda c: None,
-                           self.seconds)
-    self.calls.append(dc)
-    self.calls.sort(lambda a, b: cmp(a.getTime(), b.getTime()))
-    return dc
-
-def clockIsBroken():
-    """
-    Returns whether twisted.internet.task.Clock has the bug that
-    returns the wrong DelayedCall or not.
-    """
-    clock = Clock()
-    dc1 = clock.callLater(10, lambda: None)
-    dc2 = clock.callLater(1, lambda: None)
-    if dc1 is dc2:
-        return True
-    else:
-        return False
-
-def install():
-    """
-    Insert the fixed callLater method.
-    """
-    Clock.callLater = callLater

=== removed file 'Epsilon/epsilon/hotfixes/loopbackasync_reentrancy.py'
--- Epsilon/epsilon/hotfixes/loopbackasync_reentrancy.py	2008-08-28 14:40:39 +0000
+++ Epsilon/epsilon/hotfixes/loopbackasync_reentrancy.py	1970-01-01 00:00:00 +0000
@@ -1,26 +0,0 @@
-
-"""
-Fix from Twisted r23970
-"""
-
-from twisted.internet.task import deferLater
-from twisted.protocols.loopback import _loopbackAsyncBody
-
-def _loopbackAsyncContinue(ignored, server, serverToClient, client, clientToServer):
-    # Clear the Deferred from each message queue, since it has already fired
-    # and cannot be used again.
-    clientToServer._notificationDeferred = serverToClient._notificationDeferred = None
-
-    # Schedule some more byte-pushing to happen.  This isn't done
-    # synchronously because no actual transport can re-enter dataReceived as
-    # a result of calling write, and doing this synchronously could result  
-    # in that.
-    from twisted.internet import reactor
-    return deferLater(
-        reactor, 0,   
-        _loopbackAsyncBody, server, serverToClient, client, clientToServer)
-
-
-def install():
-    from twisted.protocols import loopback
-    loopback._loopbackAsyncContinue = _loopbackAsyncContinue

=== removed file 'Epsilon/epsilon/hotfixes/plugin_package_paths.py'
--- Epsilon/epsilon/hotfixes/plugin_package_paths.py	2008-08-07 14:03:07 +0000
+++ Epsilon/epsilon/hotfixes/plugin_package_paths.py	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-# Copyright (c) 2007 Twisted Matrix Laboratories.
-# Copyright (c) 2008 Divmod.
-# See LICENSE for details.
-
-
-
-import sys, os
-
-def pluginPackagePaths(name):
-    """
-    Return a list of additional directories which should be searched for
-    modules to be included as part of the named plugin package.
-
-    @type name: C{str}
-    @param name: The fully-qualified Python name of a plugin package, eg
-        C{'twisted.plugins'}.
-
-    @rtype: C{list} of C{str}
-    @return: The absolute paths to other directories which may contain plugin
-        modules for the named plugin package.
-    """
-    package = name.split('.')
-    # Note that this may include directories which do not exist.  It may be
-    # preferable to remove such directories at this point, rather than allow
-    # them to be searched later on.
-    #
-    # Note as well that only '__init__.py' will be considered to make a
-    # directory a package (and thus exclude it from this list).  This means
-    # that if you create a master plugin package which has some other kind of
-    # __init__ (eg, __init__.pyc) it will be incorrectly treated as a
-    # supplementary plugin directory.
-    return [
-        os.path.abspath(os.path.join(x, *package))
-        for x
-        in sys.path
-        if
-        not os.path.exists(os.path.join(x, *package + ['__init__.py']))]
-
-
-def install():
-    import twisted.plugin
-    twisted.plugin.pluginPackagePaths = pluginPackagePaths

=== removed file 'Epsilon/epsilon/hotfixes/proto_helpers_stringtransport.py'
--- Epsilon/epsilon/hotfixes/proto_helpers_stringtransport.py	2006-06-22 20:48:07 +0000
+++ Epsilon/epsilon/hotfixes/proto_helpers_stringtransport.py	1970-01-01 00:00:00 +0000
@@ -1,11 +0,0 @@
-from twisted.test import proto_helpers
-
-class StringTransport:
-
-    def write(self, data):
-        if isinstance(data, unicode): # no, really, I mean it
-            raise TypeError("Data must not be unicode")
-        self.io.write(data)
-
-def install():
-    proto_helpers.StringTransport.__dict__['write'] = StringTransport.__dict__['write']

=== removed file 'Epsilon/epsilon/hotfixes/timeoutmixin_calllater.py'
--- Epsilon/epsilon/hotfixes/timeoutmixin_calllater.py	2006-05-19 15:23:46 +0000
+++ Epsilon/epsilon/hotfixes/timeoutmixin_calllater.py	1970-01-01 00:00:00 +0000
@@ -1,60 +0,0 @@
-
-from twisted.internet import reactor
-
-class TimeoutMixin:
-    """Mixin for protocols which wish to timeout connections
-
-    @cvar timeOut: The number of seconds after which to timeout the connection.
-    """
-    timeOut = None
-
-    __timeoutCall = None
-
-    def callLater(self, period, func):
-        return reactor.callLater(period, func)
-
-
-    def resetTimeout(self):
-        """Reset the timeout count down"""
-        if self.__timeoutCall is not None and self.timeOut is not None:
-            self.__timeoutCall.reset(self.timeOut)
-
-    def setTimeout(self, period):
-        """Change the timeout period
-
-        @type period: C{int} or C{NoneType}
-        @param period: The period, in seconds, to change the timeout to, or
-        C{None} to disable the timeout.
-        """
-        prev = self.timeOut
-        self.timeOut = period
-
-        if self.__timeoutCall is not None:
-            if period is None:
-                self.__timeoutCall.cancel()
-                self.__timeoutCall = None
-            else:
-                self.__timeoutCall.reset(period)
-        elif period is not None:
-            self.__timeoutCall = self.callLater(period, self.__timedOut)
-
-        return prev
-
-    def __timedOut(self):
-        self.__timeoutCall = None
-        self.timeoutConnection()
-
-    def timeoutConnection(self):
-        """Called when the connection times out.
-        Override to define behavior other than dropping the connection.
-        """
-        self.transport.loseConnection()
-
-
-def install():
-    global TimeoutMixin
-
-    from twisted.protocols import policies
-    policies.TimeoutMixin.__dict__ = TimeoutMixin.__dict__
-    policies.TimeoutMixin.__dict__['module'] = 'twisted.protocols.policies'
-    TimeoutMixin = policies.TimeoutMixin

=== removed file 'Epsilon/epsilon/hotfixes/trial_assertwarns.py'
--- Epsilon/epsilon/hotfixes/trial_assertwarns.py	2008-05-13 19:40:37 +0000
+++ Epsilon/epsilon/hotfixes/trial_assertwarns.py	1970-01-01 00:00:00 +0000
@@ -1,61 +0,0 @@
-
-"""
-failUnlessWarns assertion from twisted.trial in Twisted 8.0.
-"""
-
-import warnings
-
-def failUnlessWarns(self, category, message, filename, f,
-                   *args, **kwargs):
-    """
-    Fail if the given function doesn't generate the specified warning when
-    called. It calls the function, checks the warning, and forwards the
-    result of the function if everything is fine.
-
-    @param category: the category of the warning to check.
-    @param message: the output message of the warning to check.
-    @param filename: the filename where the warning should come from.
-    @param f: the function which is supposed to generate the warning.
-    @type f: any callable.
-    @param args: the arguments to C{f}.
-    @param kwargs: the keywords arguments to C{f}.
-
-    @return: the result of the original function C{f}.
-    """
-    warningsShown = []
-    def warnExplicit(*args):
-        warningsShown.append(args)
-
-    origExplicit = warnings.warn_explicit
-    try:
-        warnings.warn_explicit = warnExplicit
-        result = f(*args, **kwargs)
-    finally:
-        warnings.warn_explicit = origExplicit
-
-    if not warningsShown:
-        self.fail("No warnings emitted")
-    first = warningsShown[0]
-    for other in warningsShown[1:]:
-        if other[:2] != first[:2]:
-            self.fail("Can't handle different warnings")
-    gotMessage, gotCategory, gotFilename, lineno = first[:4]
-    self.assertEqual(gotMessage, message)
-    self.assertIdentical(gotCategory, category)
-
-    # Use starts with because of .pyc/.pyo issues.
-    self.failUnless(
-        filename.startswith(gotFilename),
-        'Warning in %r, expected %r' % (gotFilename, filename))
-
-    # It would be nice to be able to check the line number as well, but
-    # different configurations actually end up reporting different line
-    # numbers (generally the variation is only 1 line, but that's enough
-    # to fail the test erroneously...).
-    # self.assertEqual(lineno, xxx)
-
-    return result
-
-def install():
-    from twisted.trial.unittest import TestCase
-    TestCase.failUnlessWarns = TestCase.assertWarns = failUnlessWarns

=== removed file 'Epsilon/epsilon/iepsilon.py'
--- Epsilon/epsilon/iepsilon.py	2008-11-10 20:26:55 +0000
+++ Epsilon/epsilon/iepsilon.py	1970-01-01 00:00:00 +0000
@@ -1,25 +0,0 @@
-# Copyright (c) 2008 Divmod.  See LICENSE for details.
-
-"""
-Epsilon interfaces.
-"""
-from zope.interface import Attribute
-
-from twisted.cred.credentials import ICredentials
-
-
-class IOneTimePad(ICredentials):
-    """
-    A type of opaque credential for authenticating users, which can be used
-    only a single time.
-
-    This interface should also be responsible for authenticating.  See #2784.
-    """
-    padValue = Attribute(
-        """
-        C{str} giving the value of the one-time pad.  The value will be
-        compared by a L{twisted.cred.checkers.ICredentialsChecker} (e.g.
-        L{epsilon.ampauth.OneTimePadChecker}) against all valid one-time pads.
-        If there is a match, login will be successful and the pad will be
-        invalidated (further attempts to use it will fail).
-        """)

=== removed file 'Epsilon/epsilon/juice.py'
--- Epsilon/epsilon/juice.py	2009-07-06 11:51:08 +0000
+++ Epsilon/epsilon/juice.py	1970-01-01 00:00:00 +0000
@@ -1,1009 +0,0 @@
-# -*- test-case-name: epsilon.test.test_juice -*-
-# Copyright 2005 Divmod, Inc.  See LICENSE file for details
-
-__metaclass__ = type
-
-import warnings, pprint
-
-from twisted.internet.main import CONNECTION_LOST
-from twisted.internet.defer import Deferred, maybeDeferred, fail
-from twisted.internet.protocol import ServerFactory, ClientFactory
-from twisted.internet.ssl import Certificate
-from twisted.python.failure import Failure
-from twisted.python import log, filepath
-
-from epsilon.liner import LineReceiver
-from epsilon import extime
-
-ASK = '_ask'
-ANSWER = '_answer'
-COMMAND = '_command'
-ERROR = '_error'
-ERROR_CODE = '_error_code'
-ERROR_DESCRIPTION = '_error_description'
-LENGTH = '_length'
-BODY = 'body'
-
-debug = False
-
-class JuiceBox(dict):
-    """ I am a packet in the JUICE protocol.  """
-
-    def __init__(self, __body='', **kw):
-        self.update(kw)
-        if __body:
-            assert isinstance(__body, str), "body must be a string: %r" % ( repr(__body),)
-            self['body'] = __body
-
-    def body():
-        def get(self):
-            warnings.warn("body attribute of boxes is now just a regular field",
-                          stacklevel=2)
-            return self['body']
-        def set(self, newbody):
-            warnings.warn("body attribute of boxes is now just a regular field",
-                          stacklevel=2)
-            self['body'] = newbody
-        return get,set
-    body = property(*body())
-
-    def copy(self):
-        newBox = self.__class__()
-        newBox.update(self)
-        return newBox
-
-    def serialize(self,
-                  delimiter='\r\n',
-                  escaped='\r\n '):
-        assert LENGTH not in self
-
-        L = []
-        for (k, v) in self.iteritems():
-            if k == BODY:
-                k = LENGTH
-                v = str(len(self[BODY]))
-            L.append(k.replace('_', '-').title())
-            L.append(': ')
-            L.append(v.replace(delimiter, escaped))
-            L.append(delimiter)
-
-        L.append(delimiter)
-        if BODY in self:
-            L.append(self[BODY])
-
-        bytes = ''.join(L)
-        return bytes
-
-    def sendTo(self, proto):
-        """
-        Serialize and send this box to a Juice instance.  By the time it is
-        being sent, several keys are required.  I must have exactly ONE of::
-
-            -ask
-            -answer
-            -error
-
-        If the '-ask' header is set, then the '-command' header must also be
-        set.
-        """
-        proto.sendPacket(self)
-
-# juice.Box => JuiceBox
-
-Box = JuiceBox
-
-class TLSBox(JuiceBox):
-    def __repr__(self):
-        return 'TLS(**%s)' % (super(TLSBox, self).__repr__(),)
-
-
-    def __init__(self, __certificate, __verify=None, __sslstarted=None, **kw):
-        super(TLSBox, self).__init__(**kw)
-        self.certificate = __certificate
-        self.verify = __verify
-        self.sslstarted = __sslstarted
-
-    def sendTo(self, proto):
-        super(TLSBox, self).sendTo(proto)
-        if self.verify is None:
-            proto.startTLS(self.certificate)
-        else:
-            proto.startTLS(self.certificate, self.verify)
-        if self.sslstarted is not None:
-            self.sslstarted()
-
-class QuitBox(JuiceBox):
-    def __repr__(self):
-        return 'Quit(**%s)' % (super(QuitBox, self).__repr__(),)
-
-
-    def sendTo(self, proto):
-        super(QuitBox, self).sendTo(proto)
-        proto.transport.loseConnection()
-
-class _SwitchBox(JuiceBox):
-    def __repr__(self):
-        return 'Switch(**%s)' % (super(_SwitchBox, self).__repr__(),)
-
-
-    def __init__(self, __proto, **kw):
-        super(_SwitchBox, self).__init__(**kw)
-        self.innerProto = __proto
-
-    def sendTo(self, proto):
-        super(_SwitchBox, self).sendTo(proto)
-        proto._switchTo(self.innerProto)
-
-
-
-class NegotiateBox(JuiceBox):
-    def __repr__(self):
-        return 'Negotiate(**%s)' % (super(NegotiateBox, self).__repr__(),)
-
-
-    def sendTo(self, proto):
-        super(NegotiateBox, self).sendTo(proto)
-        proto._setProtocolVersion(int(self['version']))
-
-
-
-class JuiceError(Exception):
-    pass
-
-class RemoteJuiceError(JuiceError):
-    """
-    This error indicates that something went wrong on the remote end of the
-    connection, and the error was serialized and transmitted to you.
-    """
-    def __init__(self, errorCode, description, fatal=False):
-        """Create a remote error with an error code and description.
-        """
-        Exception.__init__(self, "Remote[%s]: %s" % (errorCode, description))
-        self.errorCode = errorCode
-        self.description = description
-        self.fatal = fatal
-
-class UnhandledRemoteJuiceError(RemoteJuiceError):
-    def __init__(self, description):
-        errorCode = "UNHANDLED"
-        RemoteJuiceError.__init__(self, errorCode, description)
-
-class JuiceBoxError(JuiceError):
-    pass
-
-class MalformedJuiceBox(JuiceBoxError):
-    pass
-
-class UnhandledCommand(JuiceError):
-    pass
-
-
-class IncompatibleVersions(JuiceError):
-    pass
-
-class _Transactor:
-    def __init__(self, store, callable):
-        self.store = store
-        self.callable = callable
-
-    def __call__(self, box):
-        return self.store.transact(self.callable, box)
-
-    def __repr__(self):
-        return '<Transaction in: %s of: %s>' % (self.store, self.callable)
-
-class DispatchMixin:
-    baseDispatchPrefix = 'juice_'
-    autoDispatchPrefix = 'command_'
-
-    wrapper = None
-
-    def _auto(self, aCallable, proto, namespace=None):
-        if aCallable is None:
-            return None
-        command = aCallable.command
-        if namespace not in command.namespaces:
-            # if you're in the wrong namespace, you are very likely not allowed
-            # to invoke the command you are trying to invoke.  some objects
-            # have commands exposed in a separate namespace for security
-            # reasons, since the security model is a role : namespace mapping.
-            log.msg('WRONG NAMESPACE: %r, %r' % (namespace, command.namespaces))
-            return None
-        def doit(box):
-            kw = stringsToObjects(box, command.arguments, proto)
-            for name, extraArg in command.extra:
-                kw[name] = extraArg.fromTransport(proto.transport)
-#             def checkIsDict(result):
-#                 if not isinstance(result, dict):
-#                     raise RuntimeError("%r returned %r, not dictionary" % (
-#                             aCallable, result))
-#                 return result
-            def checkKnownErrors(error):
-                key = error.trap(*command.allErrors)
-                code = command.allErrors[key]
-                desc = str(error.value)
-                return Failure(RemoteJuiceError(
-                        code, desc, error in command.fatalErrors))
-            return maybeDeferred(aCallable, **kw).addCallback(
-                command.makeResponse, proto).addErrback(
-                checkKnownErrors)
-        return doit
-
-    def _wrap(self, aCallable):
-        if aCallable is None:
-            return None
-        wrap = self.wrapper
-        if wrap is not None:
-            return wrap(aCallable)
-        else:
-            return aCallable
-
-    def normalizeCommand(self, cmd):
-        """Return the canonical form of a command.
-        """
-        return cmd.upper().strip().replace('-', '_')
-
-    def lookupFunction(self, proto, name, namespace):
-        """Return a callable to invoke when executing the named command.
-        """
-        # Try to find a method to be invoked in a transaction first
-        # Otherwise fallback to a "regular" method
-        fName = self.autoDispatchPrefix + name
-        fObj = getattr(self, fName, None)
-        if fObj is not None:
-            # pass the namespace along
-            return self._auto(fObj, proto, namespace)
-
-        assert namespace is None, 'Old-style parsing'
-        # Fall back to simplistic command dispatching - we probably want to get
-        # rid of this eventually, there's no reason to do extra work and write
-        # fewer docs all the time.
-        fName = self.baseDispatchPrefix + name
-        return getattr(self, fName, None)
-
-    def dispatchCommand(self, proto, cmd, box, namespace=None):
-        fObj = self.lookupFunction(proto, self.normalizeCommand(cmd), namespace)
-        if fObj is None:
-            return fail(UnhandledCommand(cmd))
-        return maybeDeferred(self._wrap(fObj), box)
-
-PYTHON_KEYWORDS = [
-    'and', 'del', 'for', 'is', 'raise', 'assert', 'elif', 'from', 'lambda',
-    'return', 'break', 'else', 'global', 'not', 'try', 'class', 'except',
-    'if', 'or', 'while', 'continue', 'exec', 'import', 'pass', 'yield',
-    'def', 'finally', 'in', 'print']
-
-def normalizeKey(key):
-    lkey = key.lower().replace('-', '_')
-    if lkey in PYTHON_KEYWORDS:
-        return lkey.title()
-    return lkey
-
-
-def parseJuiceHeaders(lines):
-    """
-    Create a JuiceBox from a list of header lines.
-
-    @param lines: a list of lines.
-    """
-    b = JuiceBox()
-    bodylen = 0
-    key = None
-    for L in lines:
-        if L[0] == ' ':
-            # continuation
-            assert key is not None
-            b[key] += '\r\n'+L[1:]
-            continue
-        parts = L.split(': ', 1)
-        if len(parts) != 2:
-            raise MalformedJuiceBox("Wrong number of parts: %r" % (L,))
-        key, value = parts
-        key = normalizeKey(key)
-        b[key] = value
-    return int(b.pop(LENGTH, 0)), b
-
-class JuiceParserBase(DispatchMixin):
-
-    def __init__(self):
-        self._outstandingRequests = {}
-
-    def _puke(self, failure):
-        log.msg("Juice server or network failure "
-                "unhandled by client application:")
-        log.err(failure)
-        log.msg(
-            "Dropping connection!  "
-            "To avoid, add errbacks to ALL remote commands!")
-        if self.transport is not None:
-            self.transport.loseConnection()
-
-    _counter = 0L
-
-    def _nextTag(self):
-        self._counter += 1
-        return '%x' % (self._counter,)
-
-    def failAllOutgoing(self, reason):
-        OR = self._outstandingRequests.items()
-        self._outstandingRequests = None # we can never send another request
-        for key, value in OR:
-            value.errback(reason)
-
-    def juiceBoxReceived(self, box):
-        if debug:
-            log.msg("Juice receive: %s" % pprint.pformat(dict(box.iteritems())))
-
-        if ANSWER in box:
-            question = self._outstandingRequests.pop(box[ANSWER])
-            question.addErrback(self._puke)
-            self._wrap(question.callback)(box)
-        elif ERROR in box:
-            question = self._outstandingRequests.pop(box[ERROR])
-            question.addErrback(self._puke)
-            self._wrap(question.errback)(
-                Failure(RemoteJuiceError(box[ERROR_CODE],
-                                         box[ERROR_DESCRIPTION])))
-        elif COMMAND in box:
-            cmd = box[COMMAND]
-            def sendAnswer(answerBox):
-                if ASK not in box:
-                    return
-                if self.transport is None:
-                    return
-                answerBox[ANSWER] = box[ASK]
-                answerBox.sendTo(self)
-            def sendError(error):
-                if ASK not in box:
-                    return error
-                if error.check(RemoteJuiceError):
-                    code = error.value.errorCode
-                    desc = error.value.description
-                    if error.value.fatal:
-                        errorBox = QuitBox()
-                    else:
-                        errorBox = JuiceBox()
-                else:
-                    errorBox = QuitBox()
-                    log.err(error) # here is where server-side logging happens
-                                   # if the error isn't handled
-                    code = 'UNHANDLED'
-                    desc = "Unhandled Remote System Exception "
-                errorBox[ERROR] = box[ASK]
-                errorBox[ERROR_DESCRIPTION] = desc
-                errorBox[ERROR_CODE] = code
-                if self.transport is not None:
-                    errorBox.sendTo(self)
-                return None # intentionally stop the error here: don't log the
-                            # traceback if it's handled, do log it (earlier) if
-                            # it isn't
-            self.dispatchCommand(self, cmd, box).addCallbacks(sendAnswer, sendError
-                                                              ).addErrback(self._puke)
-        else:
-            raise RuntimeError(
-                "Empty packet received over connection-oriented juice: %r" % (box,))
-
-    def sendBoxCommand(self, command, box, requiresAnswer=True):
-        """
-        Send a command across the wire with the given C{juice.Box}.
-
-        Returns a Deferred which fires with the response C{juice.Box} when it
-        is received, or fails with a C{juice.RemoteJuiceError} if an error is
-        received.
-
-        If the Deferred fails and the error is not handled by the caller of
-        this method, the failure will be logged and the connection dropped.
-        """
-        if self._outstandingRequests is None:
-            return fail(CONNECTION_LOST)
-        box[COMMAND] = command
-        tag = self._nextTag()
-        if requiresAnswer:
-            box[ASK] = tag
-            result = self._outstandingRequests[tag] = Deferred()
-        else:
-            result = None
-        box.sendTo(self)
-        return result
-
-
-
-
-
-
-class Argument:
-    optional = False
-
-    def __init__(self, optional=False):
-        self.optional = optional
-
-    def retrieve(self, d, name):
-        if self.optional:
-            value = d.get(name)
-            if value is not None:
-                del d[name]
-        else:
-            value = d.pop(name)
-        return value
-
-    def fromBox(self, name, strings, objects, proto):
-        st = self.retrieve(strings, name)
-        if self.optional and st is None:
-            objects[name] = None
-        else:
-            objects[name] = self.fromStringProto(st, proto)
-
-    def toBox(self, name, strings, objects, proto):
-        obj = self.retrieve(objects, name)
-        if self.optional and obj is None:
-            # strings[name] = None
-            return
-        else:
-            strings[name] = self.toStringProto(obj, proto)
-
-    def fromStringProto(self, inString, proto):
-        return self.fromString(inString)
-
-    def toStringProto(self, inObject, proto):
-        return self.toString(inObject)
-
-    def fromString(self, inString):
-        raise NotImplementedError()
-
-    def toString(self, inObject):
-        raise NotImplementedError()
-
-class JuiceList(Argument):
-    def __init__(self, subargs):
-        self.subargs = subargs
-
-    def fromStringProto(self, inString, proto):
-        boxes = parseString(inString)
-        values = [stringsToObjects(box, self.subargs, proto)
-                  for box in boxes]
-        return values
-
-    def toStringProto(self, inObject, proto):
-        return ''.join([objectsToStrings(
-                    objects, self.subargs, Box(), proto
-                    ).serialize() for objects in inObject])
-
-class ListOf(Argument):
-    def __init__(self, subarg, delimiter=', '):
-        self.subarg = subarg
-        self.delimiter = delimiter
-
-    def fromStringProto(self, inString, proto):
-        strings = inString.split(self.delimiter)
-        L = [self.subarg.fromStringProto(string, proto)
-             for string in strings]
-        return L
-
-    def toStringProto(self, inObject, proto):
-        L = []
-        for inSingle in inObject:
-            outString = self.subarg.toStringProto(inSingle, proto)
-            assert self.delimiter not in outString
-            L.append(outString)
-        return self.delimiter.join(L)
-
-class Integer(Argument):
-    fromString = int
-    def toString(self, inObject):
-        return str(int(inObject))
-
-class String(Argument):
-    def toString(self, inObject):
-        return inObject
-    def fromString(self, inString):
-        return inString
-
-class EncodedString(Argument):
-
-    def __init__(self, encoding):
-        self.encoding = encoding
-
-    def toString(self, inObject):
-        return inObject.encode(self.encoding)
-
-    def fromString(self, inString):
-        return inString.decode(self.encoding)
-
-# Temporary backwards compatibility for Exponent
-
-Body = String
-
-class Unicode(String):
-    def toString(self, inObject):
-        # assert isinstance(inObject, unicode)
-        return String.toString(self, inObject.encode('utf-8'))
-
-    def fromString(self, inString):
-        # assert isinstance(inString, str)
-        return String.fromString(self, inString).decode('utf-8')
-
-class Path(Unicode):
-    def fromString(self, inString):
-        return filepath.FilePath(Unicode.fromString(self, inString))
-
-    def toString(self, inObject):
-        return Unicode.toString(self, inObject.path)
-
-
-class Float(Argument):
-    fromString = float
-    toString = str
-
-class Base64Binary(Argument):
-    def toString(self, inObject):
-        return inObject.encode('base64').replace('\n', '')
-    def fromString(self, inString):
-        return inString.decode('base64')
-
-class Time(Argument):
-    def toString(self, inObject):
-        return inObject.asISO8601TimeAndDate()
-    def fromString(self, inString):
-        return extime.Time.fromISO8601TimeAndDate(inString)
-
-class ExtraArg:
-    def fromTransport(self, inTransport):
-        raise NotImplementedError()
-
-class Peer(ExtraArg):
-    def fromTransport(self, inTransport):
-        return inTransport.getQ2QPeer()
-
-class PeerDomain(ExtraArg):
-    def fromTransport(self, inTransport):
-        return inTransport.getQ2QPeer().domain
-
-class PeerUser(ExtraArg):
-    def fromTransport(self, inTransport):
-        return inTransport.getQ2QPeer().resource
-
-class Host(ExtraArg):
-    def fromTransport(self, inTransport):
-        return inTransport.getQ2QHost()
-
-class HostDomain(ExtraArg):
-    def fromTransport(self, inTransport):
-        return inTransport.getQ2QHost().domain
-
-class HostUser(ExtraArg):
-    def fromTransport(self, inTransport):
-        return inTransport.getQ2QHost().resource
-
-
-
-class Boolean(Argument):
-    def fromString(self, inString):
-        if inString == 'True':
-            return True
-        elif inString == 'False':
-            return False
-        else:
-            raise RuntimeError("Bad boolean value: %r" % (inString,))
-
-    def toString(self, inObject):
-        if inObject:
-            return 'True'
-        else:
-            return 'False'
-
-class Command:
-    class __metaclass__(type):
-        def __new__(cls, name, bases, attrs):
-            re = attrs['reverseErrors'] = {}
-            er = attrs['allErrors'] = {}
-            for v, k in attrs.get('errors',{}).iteritems():
-                re[k] = v
-                er[v] = k
-            for v, k in attrs.get('fatalErrors',{}).iteritems():
-                re[k] = v
-                er[v] = k
-            return type.__new__(cls, name, bases, attrs)
-
-    arguments = []
-    response = []
-    extra = []
-    namespaces = [None]         # This is set to [None] on purpose: None means
-                                # "no namespace", not "empty list".  "empty
-                                # list" will make your command invalid in _all_
-                                # namespaces, effectively uncallable.
-    errors = {}
-    fatalErrors = {}
-
-    commandType = Box
-    responseType = Box
-
-    def commandName():
-        def get(self):
-            return self.__class__.__name__
-            raise NotImplementedError("Missing command name")
-        return get,
-    commandName = property(*commandName())
-
-    def __init__(self, **kw):
-        self.structured = kw
-        givenArgs = [normalizeKey(k) for k in kw.keys()]
-        forgotten = []
-        for name, arg in self.arguments:
-            if normalizeKey(name) not in givenArgs and not arg.optional:
-                forgotten.append(normalizeKey(name))
-#         for v in kw.itervalues():
-#             if v is None:
-#                 from pprint import pformat
-#                 raise RuntimeError("ARGH: %s" % pformat(kw))
-        if forgotten:
-            if len(forgotten) == 1:
-                plural = 'an argument'
-            else:
-                plural = 'some arguments'
-            raise RuntimeError("You forgot %s to %r: %s" % (
-                    plural, self.commandName, ', '.join(forgotten)))
-        forgotten = []
-
-    def makeResponse(cls, objects, proto):
-        try:
-            return objectsToStrings(objects, cls.response, cls.responseType(), proto)
-        except:
-            log.msg("Exception in %r.makeResponse" % (cls,))
-            raise
-    makeResponse = classmethod(makeResponse)
-
-    def do(self, proto, namespace=None, requiresAnswer=True):
-        if namespace is not None:
-            cmd = namespace + ":" + self.commandName
-        else:
-            cmd = self.commandName
-        def _massageError(error):
-            error.trap(RemoteJuiceError)
-            rje = error.value
-            return Failure(self.reverseErrors.get(rje.errorCode, UnhandledRemoteJuiceError)(rje.description))
-
-        d = proto.sendBoxCommand(
-            cmd, objectsToStrings(self.structured, self.arguments, self.commandType(),
-                                  proto),
-            requiresAnswer)
-
-        if requiresAnswer:
-            d.addCallback(stringsToObjects, self.response, proto)
-            d.addCallback(self.addExtra, proto.transport)
-            d.addErrback(_massageError)
-
-        return d
-
-    def addExtra(self, d, transport):
-        for name, extraArg in self.extra:
-            d[name] = extraArg.fromTransport(transport)
-        return d
-
-
-class ProtocolSwitchCommand(Command):
-    """Use this command to switch from something Juice-derived to a different
-    protocol mid-connection.  This can be useful to use juice as the
-    connection-startup negotiation phase.  Since TLS is a different layer
-    entirely, you can use Juice to negotiate the security parameters of your
-    connection, then switch to a different protocol, and the connection will
-    remain secured.
-    """
-
-    def __init__(self, __protoToSwitchToFactory, **kw):
-        self.protoToSwitchToFactory = __protoToSwitchToFactory
-        super(ProtocolSwitchCommand, self).__init__(**kw)
-
-    def makeResponse(cls, innerProto, proto):
-        return _SwitchBox(innerProto)
-
-    makeResponse = classmethod(makeResponse)
-
-    def do(self, proto, namespace=None):
-        d = super(ProtocolSwitchCommand, self).do(proto)
-        proto._lock()
-        def switchNow(ign):
-            innerProto = self.protoToSwitchToFactory.buildProtocol(proto.transport.getPeer())
-            proto._switchTo(innerProto, self.protoToSwitchToFactory)
-            return ign
-        def die(ign):
-            proto.transport.loseConnection()
-            return ign
-        def handle(ign):
-            self.protoToSwitchToFactory.clientConnectionFailed(None, Failure(CONNECTION_LOST))
-            return ign
-        return d.addCallbacks(switchNow, handle).addErrback(die)
-
-class Negotiate(Command):
-    commandName = 'Negotiate'
-
-    arguments = [('versions', ListOf(Integer()))]
-    response = [('version', Integer())]
-
-    responseType = NegotiateBox
-
-
-class Juice(LineReceiver, JuiceParserBase):
-    """
-    JUICE (JUice Is Concurrent Events) is a simple connection-oriented
-    request/response protocol.  Packets, or "boxes", are collections of
-    RFC2822-inspired headers, plus a body.  Note that this is NOT a literal
-    interpretation of any existing RFC, 822, 2822 or otherwise, but a simpler
-    version that does not do line continuations, does not specify any
-    particular format for header values, dispatches semantic meanings of most
-    headers on the -Command header rather than giving them global meaning, and
-    allows multiple sets of headers (messages, or JuiceBoxes) on a connection.
-
-    All headers whose names begin with a dash ('-') are reserved for use by the
-    protocol.  All others are for application use - their meaning depends on
-    the value of the "-Command" header.
-    """
-
-    protocolName = 'juice-base'
-
-    hostCertificate = None
-
-    MAX_LENGTH = 1024 * 1024
-
-    isServer = property(lambda self: self._issueGreeting,
-                        doc="""
-                        True if this is a juice server, e.g. it is going to
-                        issue or has issued a server greeting upon
-                        connection.
-                        """)
-
-    isClient = property(lambda self: not self._issueGreeting,
-                        doc="""
-                        True if this is a juice server, e.g. it is not going to
-                        issue or did not issue a server greeting upon
-                        connection.
-                        """)
-
-    def __init__(self, issueGreeting):
-        """
-        @param issueGreeting: whether to issue a greeting when connected.  This
-        should be set on server-side Juice protocols.
-        """
-        JuiceParserBase.__init__(self)
-        self._issueGreeting = issueGreeting
-
-    def __repr__(self):
-        return '<%s %s/%s at 0x%x>' % (self.__class__.__name__, self.isClient and 'client' or 'server', self.innerProtocol, id(self))
-
-    __locked = False
-
-    def _lock(self):
-        """ Lock this Juice instance so that no further Juice traffic may be sent.
-        This is used when sending a request to switch underlying protocols.
-        You probably want to subclass ProtocolSwitchCommand rather than calling
-        this directly.
-        """
-        self.__locked = True
-
-    innerProtocol = None
-
-    def _switchTo(self, newProto, clientFactory=None):
-        """ Switch this Juice instance to a new protocol.  You need to do this
-        'simultaneously' on both ends of a connection; the easiest way to do
-        this is to use a subclass of ProtocolSwitchCommand.