[Author Prev][Author Next][Thread Prev][Thread Next][Author Index][Thread Index]

[bridgedb/develop] Move lib/bridgedb/Time.py → lib/bridgedb/schedule.py.



commit e35194ecc67f40e69635fa70adee7331471de337
Author: Isis Lovecruft <isis@xxxxxxxxxxxxxx>
Date:   Tue May 13 23:19:06 2014 +0000

    Move lib/bridgedb/Time.py â?? lib/bridgedb/schedule.py.
---
 lib/bridgedb/HTTPServer.py             |    6 +-
 lib/bridgedb/Main.py                   |   10 +-
 lib/bridgedb/Tests.py                  |    4 +-
 lib/bridgedb/Time.py                   |  266 -------------------------------
 lib/bridgedb/email/server.py           |    4 +-
 lib/bridgedb/schedule.py               |  267 ++++++++++++++++++++++++++++++++
 lib/bridgedb/test/test_HTTPServer.py   |    4 +-
 lib/bridgedb/test/test_email_server.py |    6 +-
 8 files changed, 284 insertions(+), 283 deletions(-)

diff --git a/lib/bridgedb/HTTPServer.py b/lib/bridgedb/HTTPServer.py
index b436df2..8289be3 100644
--- a/lib/bridgedb/HTTPServer.py
+++ b/lib/bridgedb/HTTPServer.py
@@ -481,7 +481,7 @@ class ReCaptchaProtectedResource(CaptchaProtectedResource):
             ``'captcha_response_field'``. These POST arguments should be
             obtained from :meth:`render_GET`.
         :rtupe: :api:`twisted.internet.defer.Deferred`
-        :returns: A deferred wich will callback with a tuple in the following
+        :returns: A deferred which will callback with a tuple in the following
             form:
                 (:type:`bool`, :api:`twisted.web.server.Request`)
             If the CAPTCHA solution was valid, a tuple will contain::
@@ -619,7 +619,7 @@ class WebResourceBridges(resource.Resource):
         :type distributor: :class:`IPBasedDistributor`
         :param distributor: The mechanism to retrieve bridges for this
             distributor.
-        :type schedule: :class:`IntervalSchedule`
+        :type schedule: :class:`~bridgedb.schedule.ScheduledInterval`
         :param schedule: The time period used to tweak the bridge selection
             procedure.
         :param int N: The number of bridges to hand out per query.
@@ -669,7 +669,7 @@ class WebResourceBridges(resource.Resource):
         :returns: A plaintext or HTML response to serve.
         """
         # XXX why are we getting the interval if our distributor might be
-        # using bridgedb.Time.NoSchedule?
+        # using bridgedb.schedule.Unscheduled?
         interval = self.schedule.getInterval(time.time())
         bridges = ( )
         ip = None
diff --git a/lib/bridgedb/Main.py b/lib/bridgedb/Main.py
index 1b4420e..ccc844d 100644
--- a/lib/bridgedb/Main.py
+++ b/lib/bridgedb/Main.py
@@ -20,12 +20,12 @@ from twisted.internet import reactor
 from bridgedb import crypto
 from bridgedb import persistent
 from bridgedb import safelog
+from bridgedb import schedule
 from bridgedb import util
 from bridgedb.parse import options
 
 import bridgedb.Bridges as Bridges
 import bridgedb.Dist as Dist
-import bridgedb.Time as Time
 import bridgedb.Storage
 
 
@@ -590,12 +590,12 @@ def startup(options):
 
     # Configure all servers:
     if config.HTTPS_DIST and config.HTTPS_SHARE:
-        #webSchedule = Time.IntervalSchedule("day", 2)
-        webSchedule = Time.NoSchedule()
+        #webSchedule = schedule.ScheduledInterval("day", 2)
+        webSchedule = schedule.Unscheduled()
         HTTPServer.addWebServer(config, ipDistributor, webSchedule)
     if config.EMAIL_DIST and config.EMAIL_SHARE:
-        #emailSchedule = Time.IntervalSchedule("day", 1)
-        emailSchedule = Time.NoSchedule()
+        #emailSchedule = schedule.ScheduledInterval("day", 1)
+        emailSchedule = schedule.Unscheduled()
         addSMTPServer(config, emailDistributor, emailSchedule)
 
     # Actually run the servers.
diff --git a/lib/bridgedb/Tests.py b/lib/bridgedb/Tests.py
index 6fcdbc6..219802b 100644
--- a/lib/bridgedb/Tests.py
+++ b/lib/bridgedb/Tests.py
@@ -17,7 +17,7 @@ from datetime import datetime
 import bridgedb.Bridges
 import bridgedb.Main
 import bridgedb.Dist
-import bridgedb.Time
+import bridgedb.schedule
 import bridgedb.Storage
 import re
 import ipaddr
@@ -768,7 +768,7 @@ def testSuite():
     for module in [ bridgedb.Bridges,
                     bridgedb.Main,
                     bridgedb.Dist,
-                    bridgedb.Time ]:
+                    bridgedb.schedule ]:
         suite.addTest(doctest.DocTestSuite(module))
 
     return suite
diff --git a/lib/bridgedb/Time.py b/lib/bridgedb/Time.py
deleted file mode 100644
index 4c4a2e2..0000000
--- a/lib/bridgedb/Time.py
+++ /dev/null
@@ -1,266 +0,0 @@
-# -*- coding: utf-8 ; test-case-name: bridgedb.test.test_Time -*-
-#
-# This file is part of BridgeDB, a Tor bridge distribution system.
-#
-# :authors: Nick Mathewson
-# :copyright: (c) 2007-2014, The Tor Project, Inc.
-# :license: see LICENSE for licensing information
-
-
-"""This module implements functions for dividing time into chunks."""
-
-import calendar
-
-from datetime import datetime
-
-from zope import interface
-from zope.interface import implements
-from zope.interface import Attribute
-
-
-#: The known time intervals (or *periods*) for dividing time by.
-KNOWN_INTERVALS = ["second", "minute", "hour", "day", "week", "month"]
-
-
-class UnknownInterval(ValueError):
-    """Raised if an interval isn't one of the :data:`KNOWN_INTERVALS`."""
-
-
-def toUnixSeconds(timestruct):
-    """Convert a datetime struct to a Unix timestamp in seconds.
-
-    :param timestruct: A ``datetime.datetime`` object to convert into a
-        timestamp in Unix Era seconds.
-    :rtype: int
-    """
-    return calendar.timegm(timestruct)
-
-def fromUnixSeconds(timestamp):
-    """Convert a Unix timestamp to a datetime struct.
-
-    :param int timestamp: A timestamp in Unix Era seconds.
-    :rtype: :type:`datetime.datetime`
-    """
-    return datetime.fromtimestamp(timestamp)
-
-
-class ISchedule(interface.Interface):
-    """A ``Interface`` specification for a Schedule."""
-
-    intervalPeriod = Attribute(
-        "The type of period which this Schedule's intervals will rotate by.")
-    intervalCount = Attribute(
-        "Number of **intervalPeriod**s before rotation to the next interval")
-
-    def intervalStart(when=None):
-        """Get the start time of the interval that contains **when**."""
-
-    def getInterval(when=None):
-        """Get the interval which includes an arbitrary **when**."""
-
-    def nextIntervalStarts(when=None):
-        """Get the start of the interval after the one containing **when**."""
-
-
-class Unscheduled(object):
-    """A base ``Schedule`` that has only one period that contains all time."""
-
-    implements(ISchedule)
-
-    def __init__(self, period=None, count=None):
-        """Create a schedule for dividing time into intervals.
-
-        :param str period: One of the periods in :data:`KNOWN_INTERVALS`.
-        :param int count: The number of **period**s in an interval.
-        """
-        self.intervalCount = count
-        self.intervalPeriod = period
-
-    def intervalStart(self, when=0):
-        """Get the start time of the interval that contains **when**.
-
-        :param int when: The time which we're trying to find the corresponding
-            interval for.
-        :rtype: int
-        :returns: The Unix epoch timestamp for the start time of the interval
-            that contains **when**.
-        """
-        return toUnixSeconds(datetime.min.timetuple())
-
-    def getInterval(self, when=0):
-        """Get the interval that contains the time **when**.
-
-        :param int when: The time which we're trying to find the corresponding
-            interval for.
-        :rtype: str
-        :returns: A timestamp in the form ``YEAR-MONTH[-DAY[-HOUR]]``. It's
-            specificity depends on what type of interval we're using. For
-            example, if using ``"month"``, the return value would be something
-            like ``"2013-12"``.
-        """
-        return fromUnixSeconds(when).strftime('%04Y-%02m-%02d %02H:%02M:%02S')
-
-    def nextIntervalStarts(self, when=0):
-        """Return the start time of the interval starting _after_ when.
-
-        :rtype: int
-        :returns: Return the Y10K bug.
-        """
-        return toUnixSeconds(datetime.max.timetuple())
-
-
-class ScheduledInterval(Unscheduled):
-    """An class that splits time into periods, based on seconds, minutes,
-    hours, days, weeks, or months.
-
-    :ivar str intervalPeriod: One of the :data:`KNOWN_INTERVALS`.
-    :ivar int intervalCount: The number of times **intervalPeriod** should be
-        repeated within an interval.
-    """
-    implements(ISchedule)
-
-    def __init__(self, period=None, count=None):
-        """Create a schedule for dividing time into intervals.
-
-        :param str period: One of the periods in :data:`KNOWN_INTERVALS`.
-        :param int count: The number of **period**s in an interval.
-        """
-        super(ScheduledInterval, self).__init__(period, count)
-        self._setIntervalCount(count)
-        self._setIntervalPeriod(period)
-
-    def _setIntervalCount(self, count=None):
-        """Set our :ivar:`intervalCount`.
-
-        .. attention:: This method should be called _before_
-            :meth:`_setIntervalPeriod`, because the latter may change the
-            count, if it decides to change the period (for example, to
-            simplify things by changing weeks into days).
-
-        :param int count: The number of times the :ivar:`intervalPeriod`
-            should be repeated during the interval. Defaults to ``1``.
-        :raises UnknownInterval: if the specified **count** was invalid.
-        """
-        try:
-            if not count > 0:
-                count = 1
-            count = int(count)
-        except (TypeError, ValueError):
-            raise UnknownInterval("%s.intervalCount: %r ist not an integer."
-                                  % (self.__class__.__name__, count))
-        self.intervalCount = count
-
-    def _setIntervalPeriod(self, period=None):
-        """Set our :ivar:`intervalPeriod`.
-
-        :param str period: One of the :data:`KNOWN_INTERVALS`, or its
-            plural. Defaults to ``'hour'``.
-        :raises UnknownInterval: if the specified **period** is unknown.
-        """
-        if not period:
-            period = 'hour'
-        try:
-            period = period.lower()
-            # Depluralise the period if necessary, i.e., "months" -> "month".
-            if period.endswith('s'):
-                period = period[:-1]
-
-            if not period in KNOWN_INTERVALS:
-                raise ValueError
-        except (TypeError, AttributeError, ValueError):
-            raise UnknownInterval("%s doesn't know about the %r interval type."
-                                  % (self.__class__.__name__, period))
-        self.intervalPeriod = period
-
-        if period == 'week':
-            self.intervalPeriod = 'day'
-            self.intervalCount *= 7
-
-    def intervalStart(self, when=0):
-        """Get the start time of the interval that contains **when**.
-
-        :param int when: The time which we're trying to determine the start of
-            interval that contains it. This should be given in Unix seconds,
-            for example, taken from :func:`calendar.timegm`.
-        :rtype: int
-        :returns: The Unix epoch timestamp for the start time of the interval
-            that contains **when**.
-        """
-        if self.intervalPeriod == 'month':
-            # For months, we always start at the beginning of the month.
-            date = fromUnixSeconds(when)
-            months = (date.year * 12) + (date.month - 1)
-            months -= (months % self.intervalCount)
-            month = months % 12 + 1
-            return toUnixSeconds((months // 12, month, 1, 0, 0, 0))
-        elif self.intervalPeriod == 'day':
-            # For days, we start at the beginning of a day.
-            when -= when % (86400 * self.intervalCount)
-            return when
-        elif self.intervalPeriod == 'hour':
-            # For hours, we start at the beginning of an hour.
-            when -= when % (3600 * self.intervalCount)
-            return when
-        elif self.intervalPeriod == 'minute':
-            when -= when % (60 * self.intervalCount)
-            return when
-        elif self.intervalPeriod == 'second':
-            when -= when % self.intervalCount
-            return when
-
-    def getInterval(self, when=0):
-        """Get the interval that contains the time **when**.
-
-        >>> import calendar
-        >>> from bridgedb.Time import ScheduledInterval
-        >>> sched = ScheduledInterval('month', 1)
-        >>> when = calendar.timegm((2007, 12, 12, 0, 0, 0))
-        >>> sched.getInterval(when)
-        '2007-12'
-        >>> then = calendar.timegm((2014, 05, 13, 20, 25, 13))
-        >>> sched.getInterval(then)
-        '2014-05'
-
-        :param int when: The time which we're trying to find the corresponding
-            interval for. Given in Unix seconds, for example, taken from
-            :func:`calendar.timegm`.
-        :rtype: str
-        :returns: A timestamp in the form ``YEAR-MONTH[-DAY[-HOUR]]``. It's
-            specificity depends on what type of interval we're using. For
-            example, if using ``"month"``, the return value would be something
-            like ``"2013-12"``.
-        """
-        date = fromUnixSeconds(self.intervalStart(when))
-
-        fstr = "%04Y-%02m"
-        if self.intervalPeriod != 'month':
-            fstr += "-%02d"
-            if self.intervalPeriod != 'day':
-                fstr += " %02H"
-                if self.intervalPeriod != 'hour':
-                    fstr += ":%02M"
-                    if self.intervalPeriod == 'minute':
-                        fstr += ":%02S"
-
-        return date.strftime(fstr)
-
-    def nextIntervalStarts(self, when=0):
-        """Return the start time of the interval starting _after_ when.
-
-        :returns: The Unix epoch timestamp for the start time of the interval
-            that contains **when**.
-        """
-        seconds = self.intervalStart(when)
-
-        if self.intervalPeriod == 'month':
-            date = fromUnixSeconds(seconds)
-            months = date.month + self.intervalCount
-            return toUnixSeconds((date.year, months, 1, 0, 0, 0))
-        elif self.intervalPeriod == 'day':
-            return seconds + (86400 * self.intervalCount)
-        elif self.intervalPeriod == 'hour':
-            return seconds + (3600 * self.intervalCount)
-        elif self.intervalPeriod == 'minute':
-            return seconds + (60 * self.intervalCount)
-        elif self.intervalPeriod == 'second':
-            return seconds + self.intervalCount
diff --git a/lib/bridgedb/email/server.py b/lib/bridgedb/email/server.py
index 678c154..e963e61 100644
--- a/lib/bridgedb/email/server.py
+++ b/lib/bridgedb/email/server.py
@@ -212,7 +212,7 @@ class MailContext(object):
         :type config: :class:`bridgedb.persistent.Conf`
         :type distributor: :class:`bridgedb.Dist.EmailBasedDistributor`.
         :param distributor: DOCDOC
-        :type schedule: :class:`bridgedb.Time.IntervalSchedule`.
+        :type schedule: :class:`bridgedb.schedule.ScheduledInterval`.
         :param schedule: DOCDOC
         """
         self.config = config
@@ -740,7 +740,7 @@ def addServer(config, distributor, schedule):
     :type distributor: :class:`bridgedb.Dist.EmailBasedDistributor`
     :param dist: A distributor which will handle database interactions, and
         will decide which bridges to give to who and when.
-    :type schedule: :class:`bridgedb.Time.IntervalSchedule`
+    :type schedule: :class:`bridgedb.schedule.ScheduledInterval`
     :param schedule: The schedule. XXX: Is this even used?
     """
     context = MailContext(config, distributor, schedule)
diff --git a/lib/bridgedb/schedule.py b/lib/bridgedb/schedule.py
new file mode 100644
index 0000000..6cef1a6
--- /dev/null
+++ b/lib/bridgedb/schedule.py
@@ -0,0 +1,267 @@
+# -*- coding: utf-8 ; test-case-name: bridgedb.test.test_schedule -*-
+#
+# This file is part of BridgeDB, a Tor bridge distribution system.
+#
+# :authors: Nick Mathewson
+#           Isis Lovecruft <isis@xxxxxxxxxxxxxx> 0xa3adb67a2cdb8b35
+# :copyright: (c) 2007-2014, The Tor Project, Inc.
+#             (c) 2014, Isis Lovecruft
+# :license: see LICENSE for licensing information
+
+"""This module implements functions for dividing time into chunks."""
+
+import calendar
+
+from datetime import datetime
+
+from zope import interface
+from zope.interface import implements
+from zope.interface import Attribute
+
+
+#: The known time intervals (or *periods*) for dividing time by.
+KNOWN_INTERVALS = ["second", "minute", "hour", "day", "week", "month"]
+
+
+class UnknownInterval(ValueError):
+    """Raised if an interval isn't one of the :data:`KNOWN_INTERVALS`."""
+
+
+def toUnixSeconds(timestruct):
+    """Convert a datetime struct to a Unix timestamp in seconds.
+
+    :param timestruct: A ``datetime.datetime`` object to convert into a
+        timestamp in Unix Era seconds.
+    :rtype: int
+    """
+    return calendar.timegm(timestruct)
+
+def fromUnixSeconds(timestamp):
+    """Convert a Unix timestamp to a datetime struct.
+
+    :param int timestamp: A timestamp in Unix Era seconds.
+    :rtype: :type:`datetime.datetime`
+    """
+    return datetime.fromtimestamp(timestamp)
+
+
+class ISchedule(interface.Interface):
+    """A ``Interface`` specification for a Schedule."""
+
+    intervalPeriod = Attribute(
+        "The type of period which this Schedule's intervals will rotate by.")
+    intervalCount = Attribute(
+        "Number of **intervalPeriod**s before rotation to the next interval")
+
+    def intervalStart(when=None):
+        """Get the start time of the interval that contains **when**."""
+
+    def getInterval(when=None):
+        """Get the interval which includes an arbitrary **when**."""
+
+    def nextIntervalStarts(when=None):
+        """Get the start of the interval after the one containing **when**."""
+
+
+class Unscheduled(object):
+    """A base ``Schedule`` that has only one period that contains all time."""
+
+    implements(ISchedule)
+
+    def __init__(self, period=None, count=None):
+        """Create a schedule for dividing time into intervals.
+
+        :param str period: One of the periods in :data:`KNOWN_INTERVALS`.
+        :param int count: The number of **period**s in an interval.
+        """
+        self.intervalCount = count
+        self.intervalPeriod = period
+
+    def intervalStart(self, when=0):
+        """Get the start time of the interval that contains **when**.
+
+        :param int when: The time which we're trying to find the corresponding
+            interval for.
+        :rtype: int
+        :returns: The Unix epoch timestamp for the start time of the interval
+            that contains **when**.
+        """
+        return toUnixSeconds(datetime.min.timetuple())
+
+    def getInterval(self, when=0):
+        """Get the interval that contains the time **when**.
+
+        :param int when: The time which we're trying to find the corresponding
+            interval for.
+        :rtype: str
+        :returns: A timestamp in the form ``YEAR-MONTH[-DAY[-HOUR]]``. It's
+            specificity depends on what type of interval we're using. For
+            example, if using ``"month"``, the return value would be something
+            like ``"2013-12"``.
+        """
+        return fromUnixSeconds(when).strftime('%04Y-%02m-%02d %02H:%02M:%02S')
+
+    def nextIntervalStarts(self, when=0):
+        """Return the start time of the interval starting _after_ when.
+
+        :rtype: int
+        :returns: Return the Y10K bug.
+        """
+        return toUnixSeconds(datetime.max.timetuple())
+
+
+class ScheduledInterval(Unscheduled):
+    """An class that splits time into periods, based on seconds, minutes,
+    hours, days, weeks, or months.
+
+    :ivar str intervalPeriod: One of the :data:`KNOWN_INTERVALS`.
+    :ivar int intervalCount: The number of times **intervalPeriod** should be
+        repeated within an interval.
+    """
+    implements(ISchedule)
+
+    def __init__(self, period=None, count=None):
+        """Create a schedule for dividing time into intervals.
+
+        :param str period: One of the periods in :data:`KNOWN_INTERVALS`.
+        :param int count: The number of **period**s in an interval.
+        """
+        super(ScheduledInterval, self).__init__(period, count)
+        self._setIntervalCount(count)
+        self._setIntervalPeriod(period)
+
+    def _setIntervalCount(self, count=None):
+        """Set our :ivar:`intervalCount`.
+
+        .. attention:: This method should be called _before_
+            :meth:`_setIntervalPeriod`, because the latter may change the
+            count, if it decides to change the period (for example, to
+            simplify things by changing weeks into days).
+
+        :param int count: The number of times the :ivar:`intervalPeriod`
+            should be repeated during the interval. Defaults to ``1``.
+        :raises UnknownInterval: if the specified **count** was invalid.
+        """
+        try:
+            if not count > 0:
+                count = 1
+            count = int(count)
+        except (TypeError, ValueError):
+            raise UnknownInterval("%s.intervalCount: %r ist not an integer."
+                                  % (self.__class__.__name__, count))
+        self.intervalCount = count
+
+    def _setIntervalPeriod(self, period=None):
+        """Set our :ivar:`intervalPeriod`.
+
+        :param str period: One of the :data:`KNOWN_INTERVALS`, or its
+            plural. Defaults to ``'hour'``.
+        :raises UnknownInterval: if the specified **period** is unknown.
+        """
+        if not period:
+            period = 'hour'
+        try:
+            period = period.lower()
+            # Depluralise the period if necessary, i.e., "months" -> "month".
+            if period.endswith('s'):
+                period = period[:-1]
+
+            if not period in KNOWN_INTERVALS:
+                raise ValueError
+        except (TypeError, AttributeError, ValueError):
+            raise UnknownInterval("%s doesn't know about the %r interval type."
+                                  % (self.__class__.__name__, period))
+        self.intervalPeriod = period
+
+        if period == 'week':
+            self.intervalPeriod = 'day'
+            self.intervalCount *= 7
+
+    def intervalStart(self, when=0):
+        """Get the start time of the interval that contains **when**.
+
+        :param int when: The time which we're trying to determine the start of
+            interval that contains it. This should be given in Unix seconds,
+            for example, taken from :func:`calendar.timegm`.
+        :rtype: int
+        :returns: The Unix epoch timestamp for the start time of the interval
+            that contains **when**.
+        """
+        if self.intervalPeriod == 'month':
+            # For months, we always start at the beginning of the month.
+            date = fromUnixSeconds(when)
+            months = (date.year * 12) + (date.month - 1)
+            months -= (months % self.intervalCount)
+            month = months % 12 + 1
+            return toUnixSeconds((months // 12, month, 1, 0, 0, 0))
+        elif self.intervalPeriod == 'day':
+            # For days, we start at the beginning of a day.
+            when -= when % (86400 * self.intervalCount)
+            return when
+        elif self.intervalPeriod == 'hour':
+            # For hours, we start at the beginning of an hour.
+            when -= when % (3600 * self.intervalCount)
+            return when
+        elif self.intervalPeriod == 'minute':
+            when -= when % (60 * self.intervalCount)
+            return when
+        elif self.intervalPeriod == 'second':
+            when -= when % self.intervalCount
+            return when
+
+    def getInterval(self, when=0):
+        """Get the interval that contains the time **when**.
+
+        >>> import calendar
+        >>> from bridgedb.schedule import ScheduledInterval
+        >>> sched = ScheduledInterval('month', 1)
+        >>> when = calendar.timegm((2007, 12, 12, 0, 0, 0))
+        >>> sched.getInterval(when)
+        '2007-12'
+        >>> then = calendar.timegm((2014, 05, 13, 20, 25, 13))
+        >>> sched.getInterval(then)
+        '2014-05'
+
+        :param int when: The time which we're trying to find the corresponding
+            interval for. Given in Unix seconds, for example, taken from
+            :func:`calendar.timegm`.
+        :rtype: str
+        :returns: A timestamp in the form ``YEAR-MONTH[-DAY[-HOUR]]``. It's
+            specificity depends on what type of interval we're using. For
+            example, if using ``"month"``, the return value would be something
+            like ``"2013-12"``.
+        """
+        date = fromUnixSeconds(self.intervalStart(when))
+
+        fstr = "%04Y-%02m"
+        if self.intervalPeriod != 'month':
+            fstr += "-%02d"
+            if self.intervalPeriod != 'day':
+                fstr += " %02H"
+                if self.intervalPeriod != 'hour':
+                    fstr += ":%02M"
+                    if self.intervalPeriod == 'minute':
+                        fstr += ":%02S"
+
+        return date.strftime(fstr)
+
+    def nextIntervalStarts(self, when=0):
+        """Return the start time of the interval starting _after_ when.
+
+        :returns: The Unix epoch timestamp for the start time of the interval
+            that contains **when**.
+        """
+        seconds = self.intervalStart(when)
+
+        if self.intervalPeriod == 'month':
+            date = fromUnixSeconds(seconds)
+            months = date.month + self.intervalCount
+            return toUnixSeconds((date.year, months, 1, 0, 0, 0))
+        elif self.intervalPeriod == 'day':
+            return seconds + (86400 * self.intervalCount)
+        elif self.intervalPeriod == 'hour':
+            return seconds + (3600 * self.intervalCount)
+        elif self.intervalPeriod == 'minute':
+            return seconds + (60 * self.intervalCount)
+        elif self.intervalPeriod == 'second':
+            return seconds + self.intervalCount
diff --git a/lib/bridgedb/test/test_HTTPServer.py b/lib/bridgedb/test/test_HTTPServer.py
index 8bc1da7..91ab17e 100644
--- a/lib/bridgedb/test/test_HTTPServer.py
+++ b/lib/bridgedb/test/test_HTTPServer.py
@@ -29,7 +29,7 @@ from twisted.web.resource import Resource
 from twisted.web.test import requesthelper
 
 from bridgedb import HTTPServer
-from bridgedb.Time import IntervalSchedule
+from bridgedb.schedule import ScheduledInterval
 
 
 # For additional logger output for debugging, comment out the following:
@@ -518,7 +518,7 @@ class WebResourceBridgesTests(unittest.TestCase):
         self.root = Resource()
 
         self.dist = DummyIPBasedDistributor()
-        self.sched = IntervalSchedule('hour', 1)
+        self.sched = ScheduledInterval('hour', 1)
         self.nBridgesPerRequest = 2
         self.bridgesResource = HTTPServer.WebResourceBridges(
             self.dist, self.sched, N=2,
diff --git a/lib/bridgedb/test/test_email_server.py b/lib/bridgedb/test/test_email_server.py
index b7e12c6..23c65b8 100644
--- a/lib/bridgedb/test/test_email_server.py
+++ b/lib/bridgedb/test/test_email_server.py
@@ -21,9 +21,9 @@ import types
 
 from bridgedb.Dist import EmailBasedDistributor
 from bridgedb.email import server
-from bridgedb.Time import NoSchedule
 from bridgedb.parse.addr import BadEmail
 from bridgedb.persistent import Conf
+from bridgedb.schedule import Unscheduled
 from bridgedb.test.test_HTTPServer import DummyBridge
 from bridgedb.test.util import fileCheckDecorator
 
@@ -73,7 +73,7 @@ def _createMailContext(config=None, distributor=None):
             domainmap=config.EMAIL_DOMAIN_MAP,
             domainrules=config.EMAIL_DOMAIN_RULES)
 
-    context = server.MailContext(config, distributor, NoSchedule())
+    context = server.MailContext(config, distributor, Unscheduled())
     return context
 
 
@@ -426,4 +426,4 @@ class EmailServerServiceTests(unittest.TestCase):
         self.skip = True
         raise unittest.SkipTest("Not finished yet")
         from twisted.internet import reactor
-        server.addServer(self.config, self.distributor, NoSchedule)
+        server.addServer(self.config, self.distributor, Unscheduled)



_______________________________________________
tor-commits mailing list
tor-commits@xxxxxxxxxxxxxxxxxxxx
https://lists.torproject.org/cgi-bin/mailman/listinfo/tor-commits