First Version of the connection prototype being created.

I am thinking about how we want to manage connections and am hoping to
do so through
connection objects that maintain connections between computers.
Servers will maintain a pool of these objects and clients will maintain
a single connection.

The data object will be used as a layer around our change
objects that will provide things like timestamping. I think this will
work.
I wrote a custom json encoder for the data objects.
(Really just gets the __dict__ from the object so it can be
serialized.) Timestpams are created as soon as the _Data is created.
Everything is nested in connection right now as it seems that it is
unlikely
that we should let these objects be used globably.
Rebuilt everything based on the new specs

Class/file dependancies are now correctly applied.

I went ahead and stubbed out the classes and their dependancies for now.
These will next go through prelim documentation. I want to get the docs
started now so we don't have to do them in the future. It is the next
step to be done. Since the heirarchy seems correct now we can also move
on to building the actual functionality. We basically now have the
supports in place to start moving forward.
Built first iteration of TransmissionData

The TransmissionData object is now built

This object contains two pieces of information currently. The first is
the time which the package was created, and the next is the data
maintained in the cash. This is allowed to be of arbitrary type - it can
literally be any python type. For our cases it will probably be a list
or a dictionary - either way it will work. The second is a time stamp.
It can be set during instantiation, but if not it will default to the
current time during which the package was created. This will allow for
sending packages easily as creation of a new package, and rebuilding a
transmitted package is done with the constructor and nothing else.
Built the custome json serializer

The TransmissionDataSerializer is now built and working.

By using the functions in this class it is possible to both Encode a
TransmissionData object via dumps(obj, cls=TransmissionDataSerializer).
To undo this loads(str, object_hook=TransmissionDataSerializer.Decode)
will give return the rebuilt object.

This means that we are now ready to start working with sending these
objects we can garuntee that the we will get back an identical object to
what we sent. These need unit tests - that is the next step.
Unit tests for TransmissionDataSerializer

I have added the first tests for the TransmissionDataSerializer. I am
playing catchup a little and need to get these up and some commenting. I
need to get my act together and write comments as I go and design tests
before I write code!!!