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!!!
Unit testing for TransmissionDataSerializer Done

The unit tests are done and pass, updated various other things.

There are now working unit tests for the Serializer, this caught a few
errors which was nice. The current tests are for the following
Serializing TransmissionData with automatic Time stamping,
SerializingData with a predefined timestamp, Deserializing a
TransmissionData object.

Changed data members of TransmissionData to fit naming convention -
publict members are capitalized.

Biggest change to the serializer was that the Decode function now will
allow for decoding TransmissionData objects containing dictionaries and
lists. This means that nested dictionaries can't be under the key data
as it is sort of a reserved word.

I need to update the tester next.
Updates to be more pythonic, cleaned unittests

Better fits PEP 8 standards. Unit tests fit the stds from Pylons (much
cleaner and safer).

Shortened some calls in the TransmissionDataSerializerTests to use self.
This is still readable and lowers the line length to under chars.  Moved
necessary imports into the functions from which they are utilized which
is best practised so that if there is an import error it will cause a
failed test instead of halting the testing process.

Changed checking for None to use the is keyword instead of equality
checks/boolean checks. This was only in one place - good to catch this
early!

Changed TransmissionData to _TransmissionData

Updated the TransmissionData module to fit the updated UML for
Connections.

All tests still pass.

Added the custom loads and dumps

The custom loads and dumps have been implemented and tested.

These functions will act as an abstraction to the built in JSON module.
They are specialized for TransmissionData serializing and deserializing.
Tests are passing right now, this should be working ^_^

Updated the sphinx files

Moved sphinx files so that they don't clutter everything.

All of the new modules and tests are documented and sphinx is properly
building their pages.
Documentation for serialization tools finished
Fixed getting time twice in test

Times were being fetched twice, should only be fetched once.