TimeStamp doesn't go here. Remove duplicate README.txt.

CHANGES.txt

 1.0 
 
-  Initial release.
+  Initial release, branched from HEAD of ZODB on Nov. 8 2007 (aka
+  "3.9.0dev").
 
   Remove (deprecated) support for beforeCommitHook alias to
   addBeforeCommitHook.
 
   Add weakset tests.
-
-  Add TimeStamp tests.
-
-

setup.py

@@ -19,7 +19,7 @@ import os
 from ez_setup import use_setuptools
 use_setuptools()
 
-from setuptools import setup, find_packages, Extension
+from setuptools import setup, find_packages
 
 here = os.path.abspath(os.path.dirname(__file__))
 README = open(os.path.join(here, 'README.txt')).read()
@@ -43,10 +43,6 @@ setup(name='zope.transaction',
       license="ZPL 2.1",
       platforms=["any"],
       packages=find_packages(),
-      ext_modules = [
-            Extension('zope.transaction.TimeStamp',
-                      ['zope/transaction/TimeStamp.c']),
-            ],
       include_package_data=True,
       zip_safe=False,
       test_suite="zope.transaction.tests",

zope/transaction/README.txt

-============
-Transactions
-============
-
-This package contains a generic transaction implementation for Python. It is
-mainly used by the ZODB, though.
-
-Note that the data manager API, ``transaction.interfaces.IDataManager``,
-is syntactically simple, but semantically complex.  The semantics
-were not easy to express in the interface. This could probably use
-more work.  The semantics are presented in detail through examples of
-a sample data manager in ``transaction.tests.test_SampleDataManager``.
-

zope/transaction/tests/test_timestamp.py

-#############################################################################
-#
-# Copyright (c) 2006 Zope Corporation and Contributors.
-# All Rights Reserved.
-#
-# This software is subject to the provisions of the Zope Public License,
-# Version 2.1 (ZPL).  A copy of the ZPL should accompany this distribution.
-# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
-# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
-# FOR A PARTICULAR PURPOSE.
-#
-##############################################################################
-
-import unittest
-import time
-from zope.transaction.TimeStamp import TimeStamp
-
-EPSILON = 0.000001
-
-class TimeStampTests(unittest.TestCase):
-    def testStringInput(self):
-        ts = TimeStamp('00000000')
-        self.assertEqual(repr(ts), '00000000')
-        ts = TimeStamp('11111111')
-        self.assertEqual(repr(ts), '11111111')
-
-    def testTupleInput(self):
-        t = int(time.time())
-        args = time.gmtime(t)[:6]
-        ts = TimeStamp(*args)
-        self.assertEqual(ts.year(), args[0])
-        self.assertEqual(ts.month(), args[1])
-        self.assertEqual(ts.day(), args[2])
-        self.assertEqual(ts.hour(), args[3])
-        self.assertEqual(ts.minute(), args[4])
-        self.assertEqual(int(round(ts.second())), args[5])
-
-    def testRaw(self):
-        ts = TimeStamp('00000000')
-        self.assertEqual(repr(ts), ts.raw())
-        ts = TimeStamp('11111111')
-        self.assertEqual(repr(ts), ts.raw())
-
-    def testStr(self):
-        t1 = 1141445984
-        args1 = time.gmtime(t1)[:6]
-        ts1 = TimeStamp(*args1)
-        self.assertEqual(str(ts1), '2006-03-04 04:19:44.000000')
-
-    def testTimeTime(self):
-        t = int(time.time())
-        args = time.gmtime(t)[:6]
-        ts = TimeStamp(*args)
-        tt = ts.timeTime()
-        self.assertEqual(tt, t)
-
-    def testYMDTimeStamp(self):
-        self._check_ymd(2001, 6, 3)
-
-    def _check_ymd(self, yr, mo, dy):
-        ts = TimeStamp(yr, mo, dy)
-        self.assertEqual(ts.year(), yr)
-        self.assertEqual(ts.month(), mo)
-        self.assertEqual(ts.day(), dy)
-
-        self.assertEquals(ts.hour(), 0)
-        self.assertEquals(ts.minute(), 0)
-        self.assertEquals(ts.second(), 0)
-
-        t = time.gmtime(ts.timeTime())
-        self.assertEquals(yr, t[0])
-        self.assertEquals(mo, t[1])
-        self.assertEquals(dy, t[2])
-
-    def testFullTimeStamp(self):
-        native_ts = int(time.time()) # fractional seconds get in the way
-        t = time.gmtime(native_ts)   # the corresponding GMT struct tm
-        ts = TimeStamp(*t[:6])
-
-        # Seconds are stored internally via (conceptually) multiplying by
-        # 2**32 then dividing by 60, ending up with a 32-bit integer.
-        # While this gives a lot of room for cramming many distinct
-        # TimeStamps into a second, it's not good at roundtrip accuracy.
-        # For example, 1 second is stored as int(2**32/60) == 71582788.
-        # Converting back gives 71582788*60.0/2**32 == 0.9999999962747097.
-        # In general, we can lose up to 0.999... to truncation during
-        # storing, creating an absolute error up to about 1*60.0/2**32 ==
-        # 0.000000014 on the seconds value we get back.  This is so even
-        # when we have an exact integral second value going in (as we
-        # do in this test), so we can't expect equality in any comparison
-        # involving seconds.  Minutes (etc) are stored exactly, so we
-        # can expect equality for those.
-
-        self.assert_(abs(ts.timeTime() - native_ts) < EPSILON)
-        self.assertEqual(ts.year(), t[0])
-        self.assertEqual(ts.month(), t[1])
-        self.assertEqual(ts.day(), t[2])
-        self.assertEquals(ts.hour(), t[3])
-        self.assertEquals(ts.minute(), t[4])
-        self.assert_(abs(ts.second() - t[5]) < EPSILON)
-
-    def testRawTimestamp(self):
-        t = time.gmtime()
-        ts1 = TimeStamp(*t[:6])
-        ts2 = TimeStamp(`ts1`)
-
-        self.assertEquals(ts1, ts2)
-        self.assertEquals(ts1.timeTime(), ts2.timeTime())
-        self.assertEqual(ts1.year(), ts2.year())
-        self.assertEqual(ts1.month(), ts2.month())
-        self.assertEqual(ts1.day(), ts2.day())
-        self.assertEquals(ts1.hour(), ts2.hour())
-        self.assertEquals(ts1.minute(), ts2.minute())
-        self.assert_(abs(ts1.second() - ts2.second()) < EPSILON)
-
-    def testDictKey(self):
-        t = time.gmtime()
-        ts1 = TimeStamp(*t[:6])
-        ts2 = TimeStamp(2000, *t[1:6])
-
-        d = {}
-        d[ts1] = 1
-        d[ts2] = 2
-
-        self.assertEquals(len(d), 2)
-
-    def testCompare(self):
-        ts1 = TimeStamp(1972, 6, 27)
-        ts2 = TimeStamp(1971, 12, 12)
-        self.assert_(ts1 > ts2)
-        self.assert_(ts2 <= ts1)
-
-    def testLaterThan(self):
-        t = time.gmtime()
-        ts = TimeStamp(*t[:6])
-        ts2 = ts.laterThan(ts)
-        self.assert_(ts2 > ts)
-
-    # TODO:  should test for bogus inputs to TimeStamp constructor
-
-    def testTimeStamp(self):
-        # Alternate test suite
-        t = TimeStamp(2002, 1, 23, 10, 48, 5) # GMT
-        self.assertEquals(str(t), '2002-01-23 10:48:05.000000')
-        self.assertEquals(repr(t), '\x03B9H\x15UUU')
-        self.assertEquals(TimeStamp('\x03B9H\x15UUU'), t)
-        self.assertEquals(t.year(), 2002)
-        self.assertEquals(t.month(), 1)
-        self.assertEquals(t.day(), 23)
-        self.assertEquals(t.hour(), 10)
-        self.assertEquals(t.minute(), 48)
-        self.assertEquals(round(t.second()), 5)
-        self.assertEquals(t.timeTime(), 1011782885)
-        t1 = TimeStamp(2002, 1, 23, 10, 48, 10)
-        self.assertEquals(str(t1), '2002-01-23 10:48:10.000000')
-        self.assert_(t == t)
-        self.assert_(t != t1)
-        self.assert_(t < t1)
-        self.assert_(t <= t1)
-        self.assert_(t1 >= t)
-        self.assert_(t1 > t)
-        self.failIf(t == t1)
-        self.failIf(t != t)
-        self.failIf(t > t1)
-        self.failIf(t >= t1)
-        self.failIf(t1 < t)
-        self.failIf(t1 <= t)
-        self.assertEquals(cmp(t, t), 0)
-        self.assertEquals(cmp(t, t1), -1)
-        self.assertEquals(cmp(t1, t), 1)
-        self.assertEquals(t1.laterThan(t), t1)
-        self.assert_(t.laterThan(t1) > t1)
-        self.assertEquals(TimeStamp(2002,1,23), TimeStamp(2002,1,23,0,0,0))
-
-
-def test_suite():
-    return unittest.makeSuite(TimeStampTests)
-
-if __name__ == '__main__':
-    unittest.main()