Merge lp:~salgado/launchpad/remove-crap into lp:launchpad

[Guilherme Salgado]

Just remove some crap that was no longer used:

  lib/schoolbell/
  lib/canonical/launchpad/components/cal.py
  lib/canonical/launchpad/components/crowd.py

= Launchpad lint =

Checking for conflicts. and issues in doctests and templates.
Running jslint, xmllint, pyflakes, and pylint.
Using normal rules.

Linting changed files:
  lib/canonical/launchpad/interfaces/launchpad.py
  lib/canonical/launchpad/zcml/configure.zcml

== Pyflakes notices ==

lib/canonical/launchpad/interfaces/launchpad.py
    25: 'UnexpectedFormData' imported but unused
    25: 'UnsafeFormGetSubmissionError' imported but unused
    25: 'NotFoundError' imported but unused
    25: 'IBasicLaunchpadRequest' imported but unused
    25: 'IOpenLaunchBag' imported but unused
    25: 'ILaunchpadRoot' imported but unused
    25: 'ILaunchBag' imported but unused

== Pylint notices ==

lib/canonical/launchpad/interfaces/launchpad.py
    17: [F0401] Unable to import 'lazr.restful.interfaces' (No module named restful)

[Jonathan Lange (jml)]

LAND IT!

review: Approve

=== removed file 'lib/canonical/launchpad/components/cal.py'
--- lib/canonical/launchpad/components/cal.py	2009-07-17 00:26:05 +0000
+++ lib/canonical/launchpad/components/cal.py	1970-01-01 00:00:00 +0000
@@ -1,89 +0,0 @@
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-"""
-Calendaring for Launchpad
-
-This package contains various components that don't fit into database/
-or browser/.
-"""
-
-__metaclass__ = type
-
-from zope.interface import implements
-from zope.component import getUtility
-
-from canonical.launchpad import _
-from schoolbell.interfaces import ICalendar
-from canonical.launchpad.interfaces import (
-    ILaunchBag, ILaunchpadCalendar, ILaunchpadMergedCalendar,
-    ICalendarSubscriptionSubset)
-
-from schoolbell.mixins import CalendarMixin, EditableCalendarMixin
-from schoolbell.icalendar import convert_calendar_to_ical
-
-
-def calendarFromCalendarOwner(calendarowner):
-    """Adapt ICalendarOwner to ICalendar."""
-    return calendarowner.calendar
-
-
-############# Merged Calendar #############
-
-
-class MergedCalendar(CalendarMixin, EditableCalendarMixin):
-    implements(ILaunchpadCalendar, ILaunchpadMergedCalendar)
-
-    def __init__(self):
-        self.id = None
-        self.revision = 0
-        self.owner = getUtility(ILaunchBag).user
-        if self.owner is None:
-            # The merged calendar can not be accessed when the user is
-            # not logged in.  However this object still needs to be
-            # instantiable when not logged in, so that the user gets
-            # redirected to the login page when trying to access the
-            # calendar, rather than seeing an error page.
-            return
-        self.subscriptions = ICalendarSubscriptionSubset(self.owner)
-        self.title = _('Merged Calendar for %s') % self.owner.displayname
-
-    def __iter__(self):
-        for calendar in self.subscriptions:
-            for event in calendar:
-                yield event
-
-    def expand(self, first, last):
-        for calendar in self.subscriptions:
-            for event in calendar.expand(first, last):
-                yield event
-
-    def addEvent(self, event):
-        calendar = self.owner.getOrCreateCalendar()
-        calendar.addEvent(event)
-
-    def removeEvent(self, event):
-        calendar = event.calendar
-        calendar.removeEvent(event)
-
-
-############# iCalendar export ###################
-
-class ViewICalendar:
-    """Publish an object implementing the ICalendar interface in
-    the iCalendar format.  This allows desktop calendar clients to
-    display the events."""
-    __used_for__ = ICalendar
-
-    def __init__(self, context, request):
-        self.context = context
-        self.request = request
-
-    def __call__(self):
-        result = convert_calendar_to_ical(self.context)
-        result = '\r\n'.join(result)
-
-        self.request.response.setHeader('Content-Type', 'text/calendar')
-        self.request.response.setHeader('Content-Length', len(result))
-
-        return result

=== removed file 'lib/canonical/launchpad/components/crowd.py'
--- lib/canonical/launchpad/components/crowd.py	2009-06-25 05:30:52 +0000
+++ lib/canonical/launchpad/components/crowd.py	1970-01-01 00:00:00 +0000
@@ -1,80 +0,0 @@
-# Copyright 2009 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-__metaclass__ = type
-
-from zope.interface import implements
-
-from canonical.launchpad.interfaces import ICrowd, IPerson, ITeam
-
-
-class CrowdOfOnePerson:
-    implements(ICrowd)
-    __used_for__ = IPerson
-
-    def __init__(self, person):
-        self.person = person
-
-    def __contains__(self, person_or_team):
-        return person_or_team.id == self.person.id
-
-    def __add__(self, crowd):
-        return CrowdsAddedTogether(crowd, self)
-
-
-class CrowdOfOneTeam:
-    implements(ICrowd)
-    __used_for__ = ITeam
-
-    def __init__(self, team):
-        self.team = team
-
-    def __contains__(self, person_or_team):
-        if person_or_team.id == self.team.id:
-            return True
-        return person_or_team.inTeam(self.team)
-
-    def __add__(self, crowd):
-        return CrowdsAddedTogether(crowd, self)
-
-
-class CrowdsAddedTogether:
-
-    implements(ICrowd)
-
-    def __init__(self, *crowds):
-        self.crowds = crowds
-
-    def __contains__(self, person_or_team):
-        for crowd in self.crowds:
-            if person_or_team in crowd:
-                return True
-        return False
-
-    def __add__(self, crowd):
-        return CrowdsAddedTogether(crowd, *self.crowds)
-
-
-# XXX ddaa 2005-04-01: This shouldn't be in components
-class AnyPersonCrowd:
-
-    implements(ICrowd)
-
-    def __contains__(self, person_or_team):
-        return IPerson.providedBy(person_or_team)
-
-    def __add__(self, crowd):
-        return CrowdsAddedTogether(crowd, self)
-
-# XXX ddaa 2005-04-01: This shouldn't be in components
-class EmptyCrowd:
-
-    implements(ICrowd)
-
-    def __contains__(self, person_or_team):
-        return False
-
-    def __add__(self, crowd):
-        return crowd
-
-

=== removed file 'lib/canonical/launchpad/doc/crowd.txt'
--- lib/canonical/launchpad/doc/crowd.txt	2009-08-13 15:12:16 +0000
+++ lib/canonical/launchpad/doc/crowd.txt	1970-01-01 00:00:00 +0000
@@ -1,124 +0,0 @@
-
-
-A person is adaptable to ICrowd.
-
-  >>> from canonical.launchpad.interfaces import IPersonSet, ICrowd
-  >>> from zope.component import getUtility
-  >>> personset = getUtility(IPersonSet)
-  >>> mark = personset.getByName('mark')
-  >>> print mark.name
-  mark
-  >>> mark_crowd = ICrowd(mark)
-
-The person is in that crowd.
-
-  >>> mark in mark_crowd
-  True
-
-
-A team is adaptable to ICrowd, but it gets a different adapter than that used
-for a person.
-
-  >>> vcs_imports = personset.getByName('vcs-imports')
-  >>> print vcs_imports.name
-  vcs-imports
-  >>> vcs_imports_crowd = ICrowd(vcs_imports)
-
-The team is in that crowd.
-
-  >>> vcs_imports in vcs_imports_crowd
-  True
-
-mark is not in that crowd, because he is not in the vcs-imports team.
-
-  >>> mark in vcs_imports_crowd
-  False
-
-lifeless is in the vcs-imports team.  So, lifeless is in that crowd.
-
-  >>> lifeless = personset.getByName('lifeless')
-  >>> print lifeless.name
-  lifeless
-  >>> lifeless in vcs_imports_crowd
-  True
-
-Adding mark_crowd to the vcs_imports_crowd gives us a crowd that contains
-mark and the vcs-imports team and lifeless, but not stevea.
-This tests ICrowd(team).__add__.
-
-  >>> combined_crowd = vcs_imports_crowd + mark_crowd
-  >>> stevea = personset.getByName('stevea')
-  >>> stevea not in combined_crowd
-  True
-  >>> lifeless in combined_crowd
-  True
-  >>> mark in combined_crowd
-  True
-  >>> vcs_imports in combined_crowd
-  True
-
-Now, to try it the other way around: adding vcs_imports_crowd to mark_crowd.
-This tests ICrowd(person).__add__.
-
-  >>> combined_crowd = mark_crowd + vcs_imports_crowd
-  >>> lifeless in combined_crowd
-  True
-  >>> mark in combined_crowd
-  True
-  >>> vcs_imports in combined_crowd
-  True
-
-There is an AnyPersonCrowd that contains any person or team.
-
-  >>> from canonical.launchpad.components.crowd import AnyPersonCrowd
-  >>> mark in AnyPersonCrowd()
-  True
-  >>> vcs_imports in AnyPersonCrowd()
-  True
-  >>> vcs_imports_crowd in AnyPersonCrowd()
-  False
-
-Adding an AnyPersonCrowd to some other crowd works as expected.
-
-  >>> combined_crowd = mark_crowd + AnyPersonCrowd()
-  >>> mark in combined_crowd
-  True
-  >>> stevea in combined_crowd
-  True
-
-Same goes for the other way around.
-
-  >>> combined_crowd = AnyPersonCrowd() + mark_crowd
-  >>> mark in combined_crowd
-  True
-  >>> stevea in combined_crowd
-  True
-
-
-The EmptyCrowd doens't contain anything.
-
-  >>> from canonical.launchpad.components.crowd import EmptyCrowd
-  >>> mark in EmptyCrowd()
-  False
-  >>> vcs_imports_crowd in EmptyCrowd()
-  False
-
-Adding a crowd to EmptyCrowd, and vice versa, gives you essentially that crowd.
-
-  >>> combined_crowd = EmptyCrowd() + vcs_imports_crowd
-  >>> vcs_imports in combined_crowd
-  True
-  >>> mark in combined_crowd
-  False
-  >>> lifeless in combined_crowd
-  True
-
-  >>> combined_crowd = vcs_imports_crowd + EmptyCrowd()
-  >>> vcs_imports in combined_crowd
-  True
-  >>> mark in combined_crowd
-  False
-  >>> lifeless in combined_crowd
-  True
-
-

=== modified file 'lib/canonical/launchpad/interfaces/launchpad.py'
--- lib/canonical/launchpad/interfaces/launchpad.py	2010-02-24 23:18:40 +0000
+++ lib/canonical/launchpad/interfaces/launchpad.py	2010-03-17 12:06:32 +0000
@@ -34,7 +34,6 @@
     'IAuthServerApplication',
     'IBasicLaunchpadRequest',
     'IBazaarApplication',
-    'ICrowd',
     'IFeedsApplication',
     'IHasAppointedDriver',
     'IHasAssignee',
@@ -244,25 +243,6 @@
         """
 
 
-class ICrowd(Interface):
-
-    def __contains__(person_or_team_or_anything):
-        """Return True if person_or_team_or_anything is in the crowd.
-
-        Note that a particular crowd can choose to answer 'True' to this
-        question, if that is what it is supposed to do.  So, crowds that
-        contain other crowds will want to allow the other crowds the
-        opportunity to answer __contains__ before that crowd does.
-        """
-
-    def __add__(crowd):
-        """Return a new ICrowd that is this crowd added to the given crowd.
-
-        The returned crowd contains the person or teams in
-        both this crowd and the given crowd.
-        """
-
-
 class IPrivateMaloneApplication(ILaunchpadApplication):
     """Private application root for malone."""
 

=== modified file 'lib/canonical/launchpad/zcml/configure.zcml'
--- lib/canonical/launchpad/zcml/configure.zcml	2010-02-18 17:00:54 +0000
+++ lib/canonical/launchpad/zcml/configure.zcml	2010-03-17 12:06:32 +0000
@@ -12,7 +12,6 @@
     <include file="account.zcml" />
     <include file="batchnavigator.zcml" />
     <include file="binaryandsourcepackagename.zcml" />
-    <include file="crowd.zcml" />
     <include file="datetime.zcml" />
     <include file="decoratedresultset.zcml" />
     <include file="emailaddress.zcml" />

=== removed file 'lib/canonical/launchpad/zcml/crowd.zcml'
--- lib/canonical/launchpad/zcml/crowd.zcml	2009-07-13 18:15:02 +0000
+++ lib/canonical/launchpad/zcml/crowd.zcml	1970-01-01 00:00:00 +0000
@@ -1,17 +0,0 @@
-<!-- Copyright 2009 Canonical Ltd.  This software is licensed under the
-     GNU Affero General Public License version 3 (see the file LICENSE).
--->
-
-<configure xmlns="http://namespaces.zope.org/zope">
-  <adapter
-      for="canonical.launchpad.interfaces.IPerson"
-      provides="canonical.launchpad.interfaces.ICrowd"
-      factory="canonical.launchpad.components.crowd.CrowdOfOnePerson"
-      />
-  <adapter
-      for="canonical.launchpad.interfaces.ITeam"
-      provides="canonical.launchpad.interfaces.ICrowd"
-      factory="canonical.launchpad.components.crowd.CrowdOfOneTeam"
-      />
-</configure>
-

=== removed symlink 'lib/mercurial'
=== target was u'../sourcecode/mercurial/mercurial'
=== removed directory 'lib/schoolbell'
=== removed file 'lib/schoolbell/README.txt'
--- lib/schoolbell/README.txt	2005-10-31 18:29:12 +0000
+++ lib/schoolbell/README.txt	1970-01-01 00:00:00 +0000
@@ -1,7 +0,0 @@
-SchoolBell
-==========
-
-SchoolBell is a calendaring library for Zope 3.
-
-See the docstring of __init__.py for a list of features and shortcomings.
-

=== removed file 'lib/schoolbell/__init__.py'
--- lib/schoolbell/__init__.py	2005-10-31 18:29:12 +0000
+++ lib/schoolbell/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,38 +0,0 @@
-"""
-Calendaring for Zope 3 applications.
-
-SchoolBell is a calendaring library for Zope 3.  Its main features are
-(currently most of these features are science fiction):
-
-- It can parse and generate iCalendar files.  Only a subset of the iCalendar
-  spec is supported, however it is a sensible subset that should be enough for
-  interoperation with desktop calendaring applications like Apple's iCal,
-  Mozilla Calendar, Evolution, and KOrganizer.
-
-- It has browser views for presenting calendars in various ways (daily, weekly,
-  monthly, yearly views).
-
-- It is storage independent -- your application could store the calendar in
-  ZODB, in a relational database, or elsewhere, as long as the storage
-  component provides the necessary interface.  A default content component
-  that stores data in ZODB is provided.
-
-- You can also generate calendars on the fly from other data (e.g. a bug
-  tracking system).  These calendars can be read-only (simpler) or read-write.
-
-- You can display several calendars in a single view by using calendar
-  composition.
-
-- It supports recurring events (daily, weekly, monthly and yearly).
-
-Things that are not currently supported:
-
-- Timezone handling (UTC times are converted into server's local time in the
-  iCalendar parser, but that's all).
-
-- All-day events (that is, events that only specify the date but not the time).
-
-- Informing the user when uploaded iCalendar files use features that are not
-  supported by SchoolBell.
-
-"""

=== removed file 'lib/schoolbell/browser.py'
--- lib/schoolbell/browser.py	2005-10-31 18:29:12 +0000
+++ lib/schoolbell/browser.py	1970-01-01 00:00:00 +0000
@@ -1,71 +0,0 @@
-r"""
-Browser views for schoolbell.
-
-iCalendar views
----------------
-
-CalendarICalendarView can export calendars in iCalendar format
-
-    >>> from datetime import datetime, timedelta
-    >>> from schoolbell.simple import ImmutableCalendar, SimpleCalendarEvent
-    >>> event = SimpleCalendarEvent(datetime(2004, 12, 16, 11, 46, 16),
-    ...                             timedelta(hours=1), "doctests",
-    ...                             location=u"Matar\u00f3",
-    ...                             unique_id="[e-mail]")
-    >>> calendar = ImmutableCalendar([event])
-
-    >>> from zope.publisher.browser import TestRequest
-    >>> view = CalendarICalendarView()
-    >>> view.context = calendar
-    >>> view.request = TestRequest()
-    >>> output = view.show()
-
-    >>> lines = output.splitlines(True)
-    >>> from pprint import pprint
-    >>> pprint(lines)
-    ['BEGIN:VCALENDAR\r\n',
-     'VERSION:2.0\r\n',
-     'PRODID:-//SchoolTool.org/NONSGML SchoolBell//EN\r\n',
-     'BEGIN:VEVENT\r\n',
-     'UID:[e-mail]\r\n',
-     'SUMMARY:doctests\r\n',
-     'LOCATION:Matar\xc3\xb3\r\n',
-     'DTSTART:20041216T114616\r\n',
-     'DURATION:PT1H\r\n',
-     'DTSTAMP:...\r\n',
-     'END:VEVENT\r\n',
-     'END:VCALENDAR']
-
-XXX: Should the last line also end in '\r\n'?  Go read RFC 2445 and experiment
-with calendaring clients.
-
-Register the iCalendar read view in ZCML as
-
-    <browser:page
-        for="schoolbell.interfaces.ICalendar"
-        name="calendar.ics"
-        permission="zope.Public"
-        class="schoolbell.browser.CalendarICalendarView"
-        attribute="show"
-        />
-
-"""
-
-from schoolbell.icalendar import convert_calendar_to_ical
-
-__metaclass__ = type
-
-
-class CalendarICalendarView:
-    """RFC 2445 (ICalendar) view for calendars."""
-
-    def show(self):
-        data = "\r\n".join(convert_calendar_to_ical(self.context))
-        request = self.request
-        if request is not None:
-            request.response.setHeader('Content-Type',
-                                       'text/calendar; charset=UTF-8')
-            request.response.setHeader('Content-Length', len(data))
-
-        return data
-

=== removed file 'lib/schoolbell/icalendar.py'
--- lib/schoolbell/icalendar.py	2010-02-09 01:31:05 +0000
+++ lib/schoolbell/icalendar.py	1970-01-01 00:00:00 +0000
@@ -1,1127 +0,0 @@
-r"""
-iCalendar parsing and generating.
-
-iCalendar (RFC 2445) is a big and hard-to-read specification.  This module
-supports only a subset of it: VEVENT components with a limited set of
-attributes and a limited recurrence model.  The subset should be sufficient
-for interoperation with desktop calendaring applications like Apple's iCal,
-Mozilla Calendar, Evolution and KOrganizer.
-
-If you have a calendar, you can convert it to an iCalendar file like this:
-
-    >>> from datetime import datetime, timedelta
-    >>> from schoolbell.simple import ImmutableCalendar, SimpleCalendarEvent
-    >>> event = SimpleCalendarEvent(datetime(2004, 12, 16, 10, 58, 47),
-    ...                             timedelta(hours=1), "doctests",
-    ...                             location=u"Matar\u00f3",
-    ...                             unique_id="[e-mail]")
-    >>> calendar = ImmutableCalendar([event])
-
-    >>> ical_file_as_string = "\r\n".join(convert_calendar_to_ical(calendar))
-
-The returned string is in UTF-8.
-
-    >>> event.location.encode("UTF-8") in ical_file_as_string
-    True
-
-You can also parse iCalendar files back into calendars:
-
-    >>> event_iterator = read_icalendar(ical_file_as_string)
-    >>> new_calendar = ImmutableCalendar(event_iterator)
-    >>> [e.title for e in new_calendar]
-    [u'doctests']
-
-"""
-
-import datetime
-import calendar
-import re
-import pytz
-from cStringIO import StringIO
-from schoolbell.simple import SimpleCalendarEvent
-
-_utc_tz = pytz.timezone('UTC')
-
-def convert_event_to_ical(event):
-    r"""Convert an ICalendarEvent to iCalendar VEVENT component.
-
-    Returns a list of strings (without newlines) in UTF-8.
-
-        >>> from datetime import datetime, timedelta
-        >>> event = SimpleCalendarEvent(datetime(2004, 12, 16, 10, 7, 29),
-        ...                             timedelta(hours=1), "iCal rendering",
-        ...                             location="Big room",
-        ...                             unique_id="[e-mail]")
-        >>> lines = convert_event_to_ical(event)
-        >>> print "\n".join(lines)
-        BEGIN:VEVENT
-        UID:[e-mail]
-        SUMMARY:iCal rendering
-        LOCATION:Big room
-        DTSTART:20041216T100729
-        DURATION:PT1H
-        DTSTAMP:...
-        END:VEVENT
-
-    """
-    dtstamp = datetime.datetime.utcnow().strftime("%Y%m%dT%H%M%SZ")
-    result = [
-        "BEGIN:VEVENT",
-        "UID:%s" % ical_text(event.unique_id),
-        "SUMMARY:%s" % ical_text(event.title)]
-    if event.description:
-        result.append("DESCRIPTION:%s" % ical_text(event.description))
-    if event.location:
-        result.append("LOCATION:%s" % ical_text(event.location))
-### if event.recurrence is not None:   # TODO
-###     start = event.dtstart
-###     result.extend(event.recurrence.iCalRepresentation(start))
-    result += [
-        "DTSTART:%s" % ical_datetime(event.dtstart),
-        "DURATION:%s" % ical_duration(event.duration),
-        "DTSTAMP:%s" % dtstamp,
-        "END:VEVENT",
-    ]
-    return result
-
-
-def convert_calendar_to_ical(calendar):
-    r"""Convert an ICalendar to iCalendar VCALENDAR component.
-
-    Returns a list of strings (without newlines) in UTF-8.  They should be
-    joined with '\r\n' to get a valid iCalendar file.
-
-        >>> from schoolbell.simple import ImmutableCalendar
-        >>> from schoolbell.simple import SimpleCalendarEvent
-        >>> from datetime import datetime, timedelta
-        >>> event = SimpleCalendarEvent(datetime(2004, 12, 16, 10, 7, 29),
-        ...                             timedelta(hours=1), "iCal rendering",
-        ...                             location="Big room",
-        ...                             unique_id="[e-mail]")
-        >>> calendar = ImmutableCalendar([event])
-        >>> lines = convert_calendar_to_ical(calendar)
-        >>> print "\n".join(lines)
-        BEGIN:VCALENDAR
-        VERSION:2.0
-        PRODID:-//SchoolTool.org/NONSGML SchoolBell//EN
-        BEGIN:VEVENT
-        UID:[e-mail]
-        SUMMARY:iCal rendering
-        LOCATION:Big room
-        DTSTART:20041216T100729
-        DURATION:PT1H
-        DTSTAMP:...
-        END:VEVENT
-        END:VCALENDAR
-
-    Empty calendars are not allowed by RFC 2445, so we have to invent a dummy
-    event:
-
-        >>> lines = convert_calendar_to_ical(ImmutableCalendar())
-        >>> print "\n".join(lines)
-        BEGIN:VCALENDAR
-        VERSION:2.0
-        PRODID:-//SchoolTool.org/NONSGML SchoolBell//EN
-        BEGIN:VEVENT
-        UID:...
-        SUMMARY:Empty calendar
-        DTSTART:19700101T000000
-        DURATION:P0D
-        DTSTAMP:...
-        END:VEVENT
-        END:VCALENDAR
-
-    """
-    header = [
-        "BEGIN:VCALENDAR",
-        "VERSION:2.0",
-        "PRODID:-//SchoolTool.org/NONSGML SchoolBell//EN",
-    ]
-    footer = [
-        "END:VCALENDAR"
-    ]
-    events = []
-    for event in calendar:
-        events += convert_event_to_ical(event)
-    if not events:
-        placeholder = SimpleCalendarEvent(datetime.datetime(1970, 1, 1),
-                                          datetime.timedelta(0),
-                                          "Empty calendar")
-        events += convert_event_to_ical(placeholder)
-    return header + events + footer
-
-
-def ical_text(value):
-    r"""Format value according to iCalendar TEXT escaping rules.
-
-    Converts Unicode strings to UTF-8 as well.
-
-        >>> ical_text('Foo')
-        'Foo'
-        >>> ical_text(u'Matar\u00f3')
-        'Matar\xc3\xb3'
-        >>> ical_text('\\')
-        '\\\\'
-        >>> ical_text(';')
-        '\\;'
-        >>> ical_text(',')
-        '\\,'
-        >>> ical_text('\n')
-        '\\n'
-    """
-    return (value.encode('UTF-8')
-                 .replace('\\', '\\\\')
-                 .replace(';', '\\;')
-                 .replace(',', '\\,')
-                 .replace('\n', '\\n'))
-
-
-def ical_datetime(value):
-    """Format a datetime as an iCalendar DATETIME value.
-
-        >>> from datetime import datetime
-        >>> from pytz import timezone
-        >>> ical_datetime(datetime(2004, 12, 16, 10, 45, 07))
-        '20041216T104507'
-        >>> ical_datetime(datetime(2004, 12, 16, 10, 45, 07,
-        ...                        tzinfo=timezone('Australia/Perth')))
-        '20041216T024507Z'
-
-    """
-    if value.tzinfo:
-        value = value.astimezone(_utc_tz)
-        return value.strftime('%Y%m%dT%H%M%SZ')
-    return value.strftime('%Y%m%dT%H%M%S')
-
-
-def ical_duration(value):
-    """Format a timedelta as an iCalendar DURATION value.
-
-        >>> from datetime import timedelta
-        >>> ical_duration(timedelta(11))
-        'P11D'
-        >>> ical_duration(timedelta(-14))
-        '-P14D'
-        >>> ical_duration(timedelta(1, 7384))
-        'P1DT2H3M4S'
-        >>> ical_duration(timedelta(1, 7380))
-        'P1DT2H3M'
-        >>> ical_duration(timedelta(1, 7200))
-        'P1DT2H'
-        >>> ical_duration(timedelta(0, 7200))
-        'PT2H'
-        >>> ical_duration(timedelta(0, 7384))
-        'PT2H3M4S'
-        >>> ical_duration(timedelta(0, 184))
-        'PT3M4S'
-        >>> ical_duration(timedelta(0, 22))
-        'PT22S'
-        >>> ical_duration(timedelta(0, 3622))
-        'PT1H0M22S'
-    """
-    sign = ""
-    if value.days < 0:
-        sign = "-"
-    timepart = ""
-    if value.seconds:
-        timepart = "T"
-        hours = value.seconds // 3600
-        minutes = value.seconds % 3600 // 60
-        seconds = value.seconds % 60
-        if hours:
-            timepart += "%dH" % hours
-        if minutes or (hours and seconds):
-            timepart += "%dM" % minutes
-        if seconds:
-            timepart += "%dS" % seconds
-    if value.days == 0 and timepart:
-        return "%sP%s" % (sign, timepart)
-    else:
-        return "%sP%dD%s" % (sign, abs(value.days), timepart)
-
-
-def read_icalendar(icalendar_text):
-    """Read an iCalendar file and return calendar events.
-
-    Returns an iterator over calendar events.
-
-    `icalendar_text` can be a file object or a string.  It is assumed that
-    the iCalendar file contains UTF-8 text.
-
-    Unsuppored features of the iCalendar file (e.g. VTODO components, complex
-    recurrence rules, unknown properties) are silently ignored.
-    """
-    if isinstance(icalendar_text, str):
-        icalendar_text = StringIO(icalendar_text)
-    reader = ICalReader(icalendar_text)
-    for vevent in reader.iterEvents():
-        # TODO: ignore empty calendar placeholder
-
-        # Currently SchoolBell does not support all-day events, so we must
-        # convert them into ordinary events that last 24 hours
-        dtstart = vevent.dtstart
-        if not isinstance(dtstart, datetime.datetime):
-            dtstart = datetime.datetime.combine(dtstart,
-                                                datetime.time(0))
-
-        yield SimpleCalendarEvent(dtstart, vevent.duration, vevent.summary,
-                                  location=vevent.location,
-                                  unique_id=vevent.uid,
-                                  recurrence=vevent.rrule)
-
-
-#
-# The rest of this module could use some review and refactoring
-#
-
-class ICalReader:
-    """An object which reads in an iCalendar file.
-
-    The `iterEvents` method returns an iterator over all VEvent objects
-    corresponding to the events in the iCalendar file.
-
-    Short grammar of iCalendar files (RFC 2445 is the full spec):
-
-      contentline        = name *(";" param ) ":" value CRLF
-        ; content line first must be unfolded by replacing CRLF followed by a
-        ; single WSP with an empty string
-      name               = x-name / iana-token
-      x-name             = "X-" [vendorid "-"] 1*(ALPHA / DIGIT / "-")
-      iana-token         = 1*(ALPHA / DIGIT / "-")
-      vendorid           = 3*(ALPHA / DIGIT)
-      param              = param-name "=" param-value *("," param-value)
-      param-name         = iana-token / x-token
-      param-value        = paramtext / quoted-string
-      paramtext          = *SAFE-CHAR
-      value              = *VALUE-CHAR
-      quoted-string      = DQUOTE *QSAFE-CHAR DQUOTE
-
-      NON-US-ASCII       = %x80-F8
-      QSAFE-CHAR         = WSP / %x21 / %x23-7E / NON-US-ASCII
-                         ; Any character except CTLs and DQUOTE
-      SAFE-CHAR          = WSP / %x21 / %x23-2B / %x2D-39 / %x3C-7E
-                          / NON-US-ASCII
-                         ; Any character except CTLs, DQUOTE, ";", ":", ","
-      VALUE-CHAR         = WSP / %x21-7E / NON-US-ASCII  ; anything except CTLs
-      CR                 = %x0D
-      LF                 = %x0A
-      CRLF               = CR LF
-      CTL                = %x00-08 / %x0A-1F / %x7F
-      ALPHA              = %x41-5A / %x61-7A             ; A-Z / a-z
-      DIGIT              = %x30-39                       ; 0-9
-      DQUOTE             = %x22                          ; Quotation Mark
-      WSP                = SPACE / HTAB
-      SPACE              = %x20
-      HTAB               = %x09
-    """
-
-    def __init__(self, file, charset='UTF-8'):
-        self.file = file
-        self.charset = charset
-
-    def _parseRow(record_str):
-        """Parse a single content line.
-
-        A content line consists of a property name (optionally followed by a
-        number of parameters) and a value, separated by a colon.  Parameters
-        (if present) are separated from the property name and from each other
-        with semicolons.  Parameters are of the form name=value; value
-        can be double-quoted.
-
-        Returns a tuple (name, value, param_dict).  Case-insensitive values
-        (i.e. property names, parameter names, unquoted parameter values) are
-        uppercased.
-
-        Raises ICalParseError on syntax errors.
-
-        >>> ICalReader._parseRow('foo:bar')
-        ('FOO', 'bar', {})
-        >>> ICalReader._parseRow('foo;value=bar:BAZFOO')
-        ('FOO', 'BAZFOO', {'VALUE': 'BAR'})
-        """
-
-        it = iter(record_str)
-        getChar = it.next
-
-        def err(msg):
-            raise ICalParseError("%s in line:\n%s" % (msg, record_str))
-
-        try:
-            c = getChar()
-            # name
-            key = ''
-            while c.isalnum() or c == '-':
-                key += c
-                c = getChar()
-            if not key:
-                err("Missing property name")
-            key = key.upper()
-            # optional parameters
-            params = {}
-            while c == ';':
-                c = getChar()
-                # param name
-                param = ''
-                while c.isalnum() or c == '-':
-                    param += c
-                    c = getChar()
-                if not param:
-                    err("Missing parameter name")
-                param = param.upper()
-                # =
-                if c != '=':
-                    err("Expected '='")
-                # value (or rather a list of values)
-                pvalues = []
-                while True:
-                    c = getChar()
-                    if c == '"':
-                        c = getChar()
-                        pvalue = ''
-                        while c >= ' ' and c not in ('\177', '"'):
-                            pvalue += c
-                            c = getChar()
-                        # value is case-sensitive in this case
-                        if c != '"':
-                            err("Expected '\"'")
-                        c = getChar()
-                    else:
-                        # unquoted value
-                        pvalue = ''
-                        while c >= ' ' and c not in ('\177', '"', ';', ':',
-                                                     ','):
-                            pvalue += c
-                            c = getChar()
-                        pvalue = pvalue.upper()
-                    pvalues.append(pvalue)
-                    if c != ',':
-                        break
-                if len(pvalues) > 1:
-                    params[param] = pvalues
-                else:
-                    params[param] = pvalues[0]
-            # colon and value
-            if c != ':':
-                err("Expected ':'")
-            value = ''.join(it)
-        except StopIteration:
-            err("Syntax error")
-        else:
-            return (key, value, params)
-
-    _parseRow = staticmethod(_parseRow)
-
-    def _iterRow(self):
-        """A generator that returns one record at a time, as a tuple of
-        (name, value, params).
-        """
-        record = []
-        for line in self.file.readlines():
-            if line[0] in '\t ':
-                line = line[1:]
-            elif record:
-                row = "".join(record).decode(self.charset)
-                yield self._parseRow(row)
-                record = []
-            if line.endswith('\r\n'):
-                record.append(line[:-2])
-            elif line.endswith('\n'):
-                # strictly speaking this is a violation of RFC 2445
-                record.append(line[:-1])
-            else:
-                # strictly speaking this is a violation of RFC 2445
-                record.append(line)
-        if record:
-            row = "".join(record).decode(self.charset)
-            yield self._parseRow(row)
-
-    def iterEvents(self):
-        """Iterate over all VEVENT objects in an ICalendar file."""
-        iterator = self._iterRow()
-
-        # Check that the stream begins with BEGIN:VCALENDAR
-        try:
-            key, value, params = iterator.next()
-            if (key, value, params) != ('BEGIN', 'VCALENDAR', {}):
-                raise ICalParseError('This is not iCalendar')
-        except StopIteration:
-            # The file is empty.  Mozilla produces a 0-length file when
-            # publishing an empty calendar.  Let's accept it as a valid
-            # calendar that has no events.  I'm not sure if a 0-length
-            # file is a valid text/calendar object according to RFC 2445.
-            raise
-        component_stack = ['VCALENDAR']
-
-        # Extract all VEVENT components
-        obj = None
-        for key, value, params in iterator:
-            if key == "BEGIN":
-                if obj is not None:
-                    # Subcomponents terminate the processing of a VEVENT
-                    # component.  We can get away with this now, because we're
-                    # not interested in alarms and RFC 2445 specifies, that all
-                    # properties inside a VEVENT component ought to precede any
-                    # VALARM subcomponents.
-                    obj.validate()
-                    yield obj
-                    obj = None
-                if not component_stack and value != "VCALENDAR":
-                    raise ICalParseError("Text outside VCALENDAR component")
-                if value == "VEVENT":
-                    obj = VEvent()
-                component_stack.append(value)
-            elif key == "END":
-                if obj is not None and value == "VEVENT":
-                    obj.validate()
-                    yield obj
-                    obj = None
-                if not component_stack or component_stack[-1] != value:
-                    raise ICalParseError("Mismatched BEGIN/END")
-                component_stack.pop()
-            elif obj is not None:
-                obj.add(key, value, params)
-            elif not component_stack:
-                raise ICalParseError("Text outside VCALENDAR component")
-        if component_stack:
-            raise ICalParseError("Unterminated components")
-
-
-def parse_text(value):
-    r"""Parse iCalendar TEXT value.
-
-        >>> parse_text('Foo')
-        'Foo'
-        >>> parse_text('\\\\')
-        '\\'
-        >>> parse_text('\\;')
-        ';'
-        >>> parse_text('\\,')
-        ','
-        >>> parse_text('\\n')
-        '\n'
-        >>> parse_text('A string with\\; some\\\\ characters\\nin\\Nit')
-        'A string with; some\\ characters\nin\nit'
-        >>> parse_text('Unterminated \\')
-        Traceback (most recent call last):
-          ...
-        IndexError: string index out of range
-
-    """
-    if '\\' not in value:
-        return value
-    out = []
-    prev = 0
-    while True:
-        idx = value.find('\\', prev)
-        if idx == -1:
-            break
-        out.append(value[prev:idx])
-        if value[idx + 1] in 'nN':
-            out.append('\n')
-        else:
-            out.append(value[idx + 1])
-        prev = idx + 2
-    out.append(value[prev:])
-    return "".join(out)
-
-
-def parse_date(value):
-    """Parse iCalendar DATE value.  Returns a date instance.
-
-        >>> parse_date('20030405')
-        datetime.date(2003, 4, 5)
-        >>> parse_date('20030405T060708')
-        Traceback (most recent call last):
-          ...
-        ValueError: Invalid iCalendar date: '20030405T060708'
-        >>> parse_date('')
-        Traceback (most recent call last):
-          ...
-        ValueError: Invalid iCalendar date: ''
-        >>> parse_date('yyyymmdd')
-        Traceback (most recent call last):
-          ...
-        ValueError: Invalid iCalendar date: 'yyyymmdd'
-    """
-    if len(value) != 8:
-        raise ValueError('Invalid iCalendar date: %r' % value)
-    try:
-        y, m, d = int(value[0:4]), int(value[4:6]), int(value[6:8])
-    except ValueError:
-        raise ValueError('Invalid iCalendar date: %r' % value)
-    else:
-        return datetime.date(y, m, d)
-
-
-def parse_date_time(value):
-    """Parse iCalendar DATE-TIME value.  Returns a datetime instance.
-
-    A simple usage example:
-
-    >>> parse_date_time('20030405T060708')
-    datetime.datetime(2003, 4, 5, 6, 7, 8)
-
-    Examples of invalid arguments:
-
-    >>> parse_date_time('20030405T060708A')
-    Traceback (most recent call last):
-      ...
-    ValueError: Invalid iCalendar date-time: '20030405T060708A'
-    >>> parse_date_time('')
-    Traceback (most recent call last):
-      ...
-    ValueError: Invalid iCalendar date-time: ''
-
-    For timezone tests see tests.test_icalendar.TestParseDateTime.
-
-    """
-    datetime_rx = re.compile(r'(\d{4})(\d{2})(\d{2})'
-                             r'T(\d{2})(\d{2})(\d{2})(Z?)$')
-    match = datetime_rx.match(value)
-    if match is None:
-        raise ValueError('Invalid iCalendar date-time: %r' % value)
-    y, m, d, hh, mm, ss, utc = match.groups()
-    dt = datetime.datetime(int(y), int(m), int(d),
-                           int(hh), int(mm), int(ss))
-    if utc:
-        # In the future we might want to get the timezone from the iCalendar
-        # file, but for now using the local timezone of the server should
-        # be adequate.
-        timetuple = dt.timetuple()
-        ticks = calendar.timegm(timetuple)
-        dt = datetime.datetime.fromtimestamp(ticks)
-
-    return dt
-
-
-def parse_duration(value):
-    """Parse iCalendar DURATION value.  Returns a timedelta instance.
-
-    >>> parse_duration('+P11D')
-    datetime.timedelta(11)
-    >>> parse_duration('-P2W')
-    datetime.timedelta(-14)
-    >>> parse_duration('P1DT2H3M4S')
-    datetime.timedelta(1, 7384)
-    >>> parse_duration('P1DT2H3M')
-    datetime.timedelta(1, 7380)
-    >>> parse_duration('P1DT2H')
-    datetime.timedelta(1, 7200)
-    >>> parse_duration('PT2H')
-    datetime.timedelta(0, 7200)
-    >>> parse_duration('PT2H3M4S')
-    datetime.timedelta(0, 7384)
-    >>> parse_duration('PT3M4S')
-    datetime.timedelta(0, 184)
-    >>> parse_duration('PT22S')
-    datetime.timedelta(0, 22)
-    >>> parse_duration('')
-    Traceback (most recent call last):
-      ...
-    ValueError: Invalid iCalendar duration: ''
-    >>> parse_duration('xyzzy')
-    Traceback (most recent call last):
-      ...
-    ValueError: Invalid iCalendar duration: 'xyzzy'
-    >>> parse_duration('P')
-    Traceback (most recent call last):
-      ...
-    ValueError: Invalid iCalendar duration: 'P'
-    >>> parse_duration('P1WT2H')
-    Traceback (most recent call last):
-      ...
-    ValueError: Invalid iCalendar duration: 'P1WT2H'
-    """
-    date_part = r'(\d+)D'
-    time_part = r'T(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?'
-    datetime_part = '(?:%s)?(?:%s)?' % (date_part, time_part)
-    weeks_part = r'(\d+)W'
-    duration_rx = re.compile(r'([-+]?)P(?:%s|%s)$'
-                             % (weeks_part, datetime_part))
-    match = duration_rx.match(value)
-    if match is None:
-        raise ValueError('Invalid iCalendar duration: %r' % value)
-    sign, weeks, days, hours, minutes, seconds = match.groups()
-    if weeks:
-        value = datetime.timedelta(weeks=int(weeks))
-    else:
-        if (days is None and hours is None
-            and minutes is None and seconds is None):
-            raise ValueError('Invalid iCalendar duration: %r'
-                             % value)
-        value = datetime.timedelta(days=int(days or 0),
-                                   hours=int(hours or 0),
-                                   minutes=int(minutes or 0),
-                                   seconds=int(seconds or 0))
-    if sign == '-':
-        value = -value
-    return value
-
-
-def parse_period(value):
-    """Parse iCalendar PERIOD value.  Returns a Period instance.
-
-    >>> p = parse_period('20030405T060708/20030405T060709')
-    >>> print repr(p).replace('),', '),\\n      ')
-    Period(datetime.datetime(2003, 4, 5, 6, 7, 8),
-           datetime.datetime(2003, 4, 5, 6, 7, 9))
-    >>> parse_period('20030405T060708/PT1H1M1S')
-    Period(datetime.datetime(2003, 4, 5, 6, 7, 8), datetime.timedelta(0, 3661))
-    >>> parse_period('xyzzy')
-    Traceback (most recent call last):
-      ...
-    ValueError: Invalid iCalendar period: 'xyzzy'
-    >>> parse_period('foo/foe')
-    Traceback (most recent call last):
-      ...
-    ValueError: Invalid iCalendar period: 'foo/foe'
-    """
-    parts = value.split('/')
-    if len(parts) != 2:
-        raise ValueError('Invalid iCalendar period: %r' % value)
-    try:
-        start = parse_date_time(parts[0])
-        try:
-            end_or_duration = parse_date_time(parts[1])
-        except ValueError:
-            end_or_duration = parse_duration(parts[1])
-    except ValueError:
-        raise ValueError('Invalid iCalendar period: %r' % value)
-    else:
-        return Period(start, end_or_duration)
-
-
-## TODO: implement recurrences
-
-## def _parse_recurrence_weekly(args):
-##     """Parse iCalendar weekly recurrence rule.
-## 
-##     args is a mapping from attribute names in RRULE to their string values.
-## 
-##     >>> _parse_recurrence_weekly({})
-##     WeeklyRecurrenceRule(1, None, None, (), ())
-##     >>> _parse_recurrence_weekly({'BYDAY': 'WE'})
-##     WeeklyRecurrenceRule(1, None, None, (), (2,))
-##     >>> _parse_recurrence_weekly({'BYDAY': 'MO,WE,SU'})
-##     WeeklyRecurrenceRule(1, None, None, (), (0, 2, 6))
-## 
-##     """
-##     from schooltool.cal import WeeklyRecurrenceRule
-##     weekdays = []
-##     days = args.get('BYDAY', None)
-##     if days is not None:
-##         for day in days.split(','):
-##             weekdays.append(ical_weekdays.index(day))
-##     return WeeklyRecurrenceRule(weekdays=weekdays)
-## 
-## 
-## def _parse_recurrence_monthly(args):
-##     """Parse iCalendar monthly recurrence rule.
-## 
-##     args is a mapping from attribute names in RRULE to their string values.
-## 
-##     Month-day recurrency is the default:
-## 
-##     >>> _parse_recurrence_monthly({})
-##     MonthlyRecurrenceRule(1, None, None, (), 'monthday')
-## 
-##     3rd Tuesday in a month:
-## 
-##     >>> _parse_recurrence_monthly({'BYDAY': '3TU'})
-##     MonthlyRecurrenceRule(1, None, None, (), 'weekday')
-## 
-##     Last Wednesday:
-## 
-##     >>> _parse_recurrence_monthly({'BYDAY': '-1WE'})
-##     MonthlyRecurrenceRule(1, None, None, (), 'lastweekday')
-##     """
-##     from schooltool.cal import MonthlyRecurrenceRule
-##     if 'BYDAY' in args:
-##         if args['BYDAY'][0] == '-':
-##             monthly = 'lastweekday'
-##         else:
-##             monthly = 'weekday'
-##     else:
-##         monthly = 'monthday'
-##     return MonthlyRecurrenceRule(monthly=monthly)
-## 
-## 
-## def parse_recurrence_rule(value):
-##     """Parse iCalendar RRULE entry.
-## 
-##     Returns the corresponding subclass of RecurrenceRule.
-## 
-##     params is a mapping from attribute names in RRULE to their string values,
-## 
-##     A trivial example of a daily recurrence:
-## 
-##     >>> parse_recurrence_rule('FREQ=DAILY')
-##     DailyRecurrenceRule(1, None, None, ())
-## 
-##     A slightly more complex example:
-## 
-##     >>> parse_recurrence_rule('FREQ=DAILY;INTERVAL=5;COUNT=7')
-##     DailyRecurrenceRule(5, 7, None, ())
-## 
-##     An example that includes use of UNTIL:
-## 
-##     >>> parse_recurrence_rule('FREQ=DAILY;UNTIL=20041008T000000')
-##     DailyRecurrenceRule(1, None, datetime.datetime(2004, 10, 8, 0, 0), ())
-##     >>> parse_recurrence_rule('FREQ=DAILY;UNTIL=20041008')
-##     DailyRecurrenceRule(1, None, datetime.datetime(2004, 10, 8, 0, 0), ())
-## 
-##     Of course, other recurrence frequencies may be used:
-## 
-##     >>> parse_recurrence_rule('FREQ=WEEKLY;BYDAY=MO,WE,SU')
-##     WeeklyRecurrenceRule(1, None, None, (), (0, 2, 6))
-##     >>> parse_recurrence_rule('FREQ=MONTHLY')
-##     MonthlyRecurrenceRule(1, None, None, (), 'monthday')
-##     >>> parse_recurrence_rule('FREQ=YEARLY')
-##     YearlyRecurrenceRule(1, None, None, ())
-## 
-##     You have to provide a valid recurrence frequency, or you will get an error:
-## 
-##     >>> parse_recurrence_rule('')
-##     Traceback (most recent call last):
-##       ...
-##     ValueError: Invalid frequency of recurrence: None
-##     >>> parse_recurrence_rule('FREQ=bogus')
-##     Traceback (most recent call last):
-##       ...
-##     ValueError: Invalid frequency of recurrence: 'bogus'
-## 
-##     Unknown keys in params are ignored silently:
-## 
-##     >>> parse_recurrence_rule('FREQ=DAILY;WHATEVER=IGNORED')
-##     DailyRecurrenceRule(1, None, None, ())
-## 
-##     """
-##     from schooltool.cal import DailyRecurrenceRule, YearlyRecurrenceRule
-## 
-##     # split up the given value into parameters
-##     params = {}
-##     if value:
-##         for pair in value.split(';'):
-##             k, v = pair.split('=', 1)
-##             params[k] = v
-## 
-##     # parse common recurrency attributes
-##     interval = int(params.pop('INTERVAL', '1'))
-##     count = params.pop('COUNT', None)
-##     if count is not None:
-##         count = int(count)
-##     until = params.pop('UNTIL', None)
-##     if until is not None:
-##         if len(until) == 8:
-##             until = datetime.datetime.combine(parse_date(until),
-##                                               datetime.time(0, 0))
-##         else:
-##             until = parse_date_time(until)
-## 
-##     # instantiate the corresponding recurrence rule
-##     freq = params.pop('FREQ', None)
-##     if freq == 'DAILY':
-##         rule = DailyRecurrenceRule()
-##     elif freq == 'WEEKLY':
-##         rule = _parse_recurrence_weekly(params)
-##     elif freq == 'MONTHLY':
-##         rule = _parse_recurrence_monthly(params)
-##     elif freq == 'YEARLY':
-##         rule = YearlyRecurrenceRule()
-##     else:
-##         raise ValueError('Invalid frequency of recurrence: %r' % freq)
-## 
-##     return rule.replace(interval=interval, count=count, until=until)
-## 
-
-def parse_recurrence_rule(value):
-    return None # XXX
-
-
-class VEvent:
-    """iCalendar event.
-
-    Life cycle: when a VEvent is created, a number of properties should be
-    added to it using the add method.  Then validate should be called.
-    After that you can start using query methods (getOne, hasProp, iterDates).
-
-    Events are classified into two kinds:
-     - normal events
-     - all-day events
-
-    All-day events are identified by their DTSTART property having a DATE value
-    instead of the default DATE-TIME.  All-day events should satisfy the
-    following requirements (otherwise an exception will be raised):
-     - DURATION property (if defined) should be an integral number of days
-     - DTEND property (if defined) should have a DATE value
-     - any RDATE and EXDATE properties should only contain DATE values
-
-    The first two requirements are stated in RFC 2445; I'm not so sure about
-    the third one.
-    """
-
-    default_type = {
-        # Default value types for some properties
-        'DTSTAMP': 'DATE-TIME',
-        'DTSTART': 'DATE-TIME',
-        'CREATED': 'DATE-TIME',
-        'DTEND': 'DATE-TIME',
-        'DURATION': 'DURATION',
-        'LAST-MODIFIED': 'DATE-TIME',
-        'PRIORITY': 'INTEGER',
-        'RECURRENCE-ID': 'DATE-TIME',
-        'SEQUENCE': 'INTEGER',
-        'URL': 'URI',
-        'ATTACH': 'URI',
-        'EXDATE': 'DATE-TIME',
-        'EXRULE': 'RECUR',
-        'RDATE': 'DATE-TIME',
-        'RRULE': 'RECUR',
-        'LOCATION': 'TEXT',
-        'UID': 'TEXT',
-    }
-
-    converters = {
-        'INTEGER': int,
-        'DATE': parse_date,
-        'DATE-TIME': parse_date_time,
-        'DURATION': parse_duration,
-        'PERIOD': parse_period,
-        'TEXT': parse_text,
-        'RECUR': parse_recurrence_rule,
-    }
-
-    singleton_properties = set([
-        'DTSTAMP',
-        'DTSTART',
-        'UID',
-        'CLASS',
-        'CREATED',
-        'DESCRIPTION',
-        'DTEND',
-        'DURATION',
-        'GEO',
-        'LAST-MODIFIED',
-        'LOCATION',
-        'ORGANIZER',
-        'PRIORITY',
-        'RECURRENCE-ID',
-        'SEQUENCE',
-        'STATUS',
-        'SUMMARY',
-        'TRANSP',
-        'URL',
-    ])
-
-    rdate_types = set(['DATE', 'DATE-TIME', 'PERIOD'])
-    exdate_types = set(['DATE', 'DATE-TIME'])
-
-    def __init__(self):
-        self._props = {}
-
-    def add(self, property, value, params=None):
-        """Add a property.
-
-        Property name is case insensitive.  Params should be a dict from
-        uppercased parameter names to their values.
-
-        Multiple calls to add with the same property name override the
-        value.  This is sufficient for now, but will have to be changed
-        soon.
-        """
-        if params is None:
-            params = {}
-        key = property.upper()
-        if key in self._props:
-            if key in self.singleton_properties:
-                raise ICalParseError("Property %s cannot occur more than once"
-                                     % key)
-            self._props[key].append((value, params))
-        else:
-            self._props[key] = [(value, params)]
-
-    def validate(self):
-        """Check that this VEvent has all the necessary properties.
-
-        Also sets the following attributes:
-          uid               The unique id of this event
-          summary           Textual summary of this event
-          all_day_event     True if this is an all-day event
-          dtstart           start of the event (inclusive)
-          dtend             end of the event (not inclusive)
-          duration          length of the event
-          location          location of the event
-          rrule             recurrency rule
-          rdates            a list of recurrence dates or periods
-          exdates           a list of exception dates
-        """
-        if not self.hasProp('UID'):
-            raise ICalParseError("VEVENT must have a UID property")
-        if not self.hasProp('DTSTART'):
-            raise ICalParseError("VEVENT must have a DTSTART property")
-        if self._getType('DTSTART') not in ('DATE', 'DATE-TIME'):
-            raise ICalParseError("DTSTART property should have a DATE or"
-                                 " DATE-TIME value")
-        if self.hasProp('DTEND'):
-            if self._getType('DTEND') != self._getType('DTSTART'):
-                raise ICalParseError("DTEND property should have the same type"
-                                     " as DTSTART")
-            if self.hasProp('DURATION'):
-                raise ICalParseError("VEVENT cannot have both a DTEND"
-                                     " and a DURATION property")
-        if self.hasProp('DURATION'):
-            if self._getType('DURATION') != 'DURATION':
-                raise ICalParseError("DURATION property should have type"
-                                     " DURATION")
-
-        self.uid = self.getOne('UID')
-        self.summary = self.getOne('SUMMARY')
-
-        self.all_day_event = self._getType('DTSTART') == 'DATE'
-        self.dtstart = self.getOne('DTSTART')
-        if self.hasProp('DURATION'):
-            self.duration = self.getOne('DURATION')
-            self.dtend = self.dtstart + self.duration
-        else:
-            self.dtend = self.getOne('DTEND', None)
-            if self.dtend is None:
-                self.dtend = self.dtstart
-                if self.all_day_event:
-                    self.dtend += datetime.date.resolution
-            self.duration = self.dtend - self.dtstart
-
-        self.location = self.getOne('LOCATION', None)
-
-        if self.dtstart > self.dtend:
-            raise ICalParseError("Event start time should precede end time")
-        elif self.all_day_event and self.dtstart == self.dtend:
-            raise ICalParseError("Event start time should precede end time")
-
-        self.rdates = self._extractListOfDates('RDATE', self.rdate_types,
-                                               self.all_day_event)
-        self.exdates = self._extractListOfDates('EXDATE', self.exdate_types,
-                                                self.all_day_event)
-
-        self.rrule = self.getOne('RRULE', None)
-        if self.rrule is not None and self.exdates:
-            if self._getType('EXDATE') == 'DATE-TIME':
-                exceptions = [dt.date() for dt in self.exdates]
-            else:
-                exceptions = self.exdates
-            self.rrule = self.rrule.replace(exceptions=exceptions)
-
-    def _extractListOfDates(self, key, accepted_types, all_day_event):
-        """Parse a comma separated list of values.
-
-        If all_day_event is True, only accepts DATE values.  Otherwise accepts
-        all value types listed in 'accepted_types'.
-        """
-        dates = []
-        default_type = self.default_type[key]
-        for value, params in self._props.get(key, []):
-            value_type = params.get('VALUE', default_type)
-            if value_type not in accepted_types:
-                raise ICalParseError('Invalid value type for %s: %s'
-                                     % (key, value_type))
-            if all_day_event and value_type != 'DATE':
-                raise ICalParseError('I do not understand how to interpret '
-                                     '%s values in %s for all-day events.'
-                                     % (value_type, key))
-            converter = self.converters.get(value_type)
-            dates.extend(map(converter, value.split(',')))
-        return dates
-
-    def _getType(self, property):
-        """Return the type of the property value."""
-        key = property.upper()
-        values = self._props[key]
-        assert len(values) == 1
-        value, params = values[0]
-        default_type = self.default_type.get(key, 'TEXT')
-        return params.get('VALUE', default_type)
-
-    def getOne(self, property, default=None):
-        """Return the value of a property as an appropriate Python object.
-
-        Only call getOne for properties that do not occur more than once.
-        """
-        try:
-            values = self._props[property.upper()]
-            assert len(values) == 1
-            value, params = values[0]
-        except KeyError:
-            return default
-        else:
-            converter = self.converters.get(self._getType(property))
-            if converter is None:
-                return value
-            else:
-                return converter(value)
-
-    def hasProp(self, property):
-        """Return True if this VEvent has a named property."""
-        return property.upper() in self._props
-
-    def iterDates(self):
-        """Iterate over all dates within this event.
-
-        This is only valid for all-day events at the moment.
-        """
-        if not self.all_day_event:
-            raise ValueError('iterDates is only defined for all-day events')
-
-        # Find out the set of start dates
-        start_set = {self.dtstart: None}
-        for rdate in self.rdates:
-            start_set[rdate] = rdate
-        for exdate in self.exdates:
-            if exdate in start_set:
-                del start_set[exdate]
-
-        # Find out the set of all dates
-        date_set = set(start_set)
-        duration = self.duration.days
-        for d in start_set:
-            for n in range(1, duration):
-                d += datetime.date.resolution
-                date_set.add(d)
-
-        # Yield all dates in chronological order
-        dates = list(date_set)
-        dates.sort()
-        for d in dates:
-            yield d
-
-
-class Period:
-    """A period of time"""
-
-    def __init__(self, start, end_or_duration):
-        self.start = start
-        self.end_or_duration = end_or_duration
-        if isinstance(end_or_duration, datetime.timedelta):
-            self.duration = end_or_duration
-            self.end = self.start + self.duration
-        else:
-            self.end = end_or_duration
-            self.duration = self.end - self.start
-        if self.start > self.end:
-            raise ValueError("Start time is greater than end time")
-
-    def __repr__(self):
-        return "Period(%r, %r)" % (self.start, self.end_or_duration)
-
-    def __cmp__(self, other):
-        if not isinstance(other, Period):
-            raise NotImplementedError('Cannot compare Period with %r' % other)
-        return cmp((self.start, self.end), (other.start, other.end))
-
-    def overlaps(self, other):
-        if self.start > other.start:
-            return other.overlaps(self)
-        if self.start <= other.start < self.end:
-            return True
-        return False
-
-class ICalParseError(Exception):
-    """Invalid syntax in an iCalendar file."""

=== removed file 'lib/schoolbell/interfaces.py'
--- lib/schoolbell/interfaces.py	2005-11-17 21:44:26 +0000
+++ lib/schoolbell/interfaces.py	1970-01-01 00:00:00 +0000
@@ -1,396 +0,0 @@
-"""
-Interface definitions for SchoolBell.
-
-There are two interfaces for calendars: `ICalendar` for read-only calendars,
-and `IEditCalendar` for read-write calendars.
-
-Semantically calendars are unordered sets of events.  Events themselves
-(`ICalendarEvent`) are immutable and comparable.  If you have an editable
-calendar, and want to change an event in it, you need to create a new event
-object and put it into the calendar:
-
-    calendar.removeEvent(event)
-    replacement_event = event.replace(title=u"New title", ...)
-    calendar.addEvent(replacement_event)
-
-Calendars have globally unique IDs.  If you are changing an event in the
-fashion demonstrated above, you should preserve its unique_id attribute.
-
-"""
-
-from zope.interface import Interface
-from zope.schema import Text, TextLine, Int, Datetime, Date, List, Set, Choice
-from zope.schema import Field, Object
-
-
-class ICalendar(Interface):
-    """Calendar.
-
-    A calendar is a set of calendar events (see ICalendarEvent).  Recurring
-    events are listed only once.
-    """
-
-    def __iter__():
-        """Return an iterator over all events in this calendar.
-
-        The order of events is not defined.
-        """
-
-    def find(unique_id):
-        """Return an event with the given unique id.
-
-        Raises a KeyError if there is no event with this id.
-        """
-
-    def expand(first, last):
-        """Return an iterator over all expanded events in a given time period.
-
-        "Expanding" here refers to expanding recurring events, that is,
-        creating objects for all occurrences of recurring events.  If a
-        recurring event has occurreces that overlap the specified time
-        interval, every such occurrence is represented as a new calendar event
-        with the `dtstart` attribute replaced with the date and time of that
-        occurrence.  These events provide IExpandedCalendarEvent and have an
-        additional attribute which points to the original event.
-
-        `first` and `last` are datetime.datetimes and define a half-open
-        time interval.
-
-        The order of returned events is not defined.
-        """
-
-
-class IEditCalendar(ICalendar):
-    """Editable calendar.
-
-    Calendar events are read-only, so to change an event you need to remove
-    the old event, and add a replacement event in the calendar.
-    """
-
-    def clear():
-        """Remove all events."""
-
-    def addEvent(event):
-        """Add an event to the calendar.
-
-        Raises ValueError if an event with the same unique_id already exists
-        in the calendar.
-
-        Returns the newly added event (which may be a copy of the argument,
-        e.g. if the calendar needs its events to be instances of a particular
-        class).
-
-        It is perhaps not a good idea to add calendar events that have no
-        occurrences into calendars (see ICalendarEvent.hasOccurrences), as they
-        will be invisible in date-based of calendar views.
-
-        Do not call addEvent while iterating over the calendar.
-        """
-
-    def removeEvent(event):
-        """Remove event from the calendar.
-
-        Raises ValueError if event is not present in the calendar.
-
-        Do not call removeEvent while iterating over the calendar.
-        """
-
-    def update(calendar):
-        """Add all events from another calendar.
-
-            cal1.update(cal2)
-
-        is equivalent to
-
-            for event in cal2:
-                cal1.addEvent(event)
-        """
-
-
-class IRecurrenceRule(Interface):
-    """Base interface of the recurrence rules.
-
-    Recurrence rules are stored as attributes of ICalendarEvent.  They
-    are also immutable and comparable.  To modify the recurrence
-    rule of an event, you need to create a new recurrence rule, and a new
-    event:
-
-        replacement_rule = event.recurrence.replace(count=3, until=None)
-        replacement_event = event.replace(recurrence=replacement_rule)
-        calendar.removeEvent(event)
-        calendar.addEvent(replacement_event)
-
-    """
-
-    interval = Int(
-        title=u"Interval",
-        min=1,
-        description=u"""
-        Interval of recurrence (a positive integer).
-
-        For example, to indicate that an event occurs every second day,
-        you would create a DailyRecurrenceRule witl interval equal to 2.
-        """)
-
-    count = Int(
-        title=u"Count",
-        required=False,
-        description=u"""
-        Number of times the event is repeated.
-
-        Can be None or an integer value.  If count is not None then
-        until must be None.  If both count and until are None the
-        event repeats forever.
-        """)
-
-    until = Date(
-        title=u"Until",
-        required=False,
-        description=u"""
-        The date of the last recurrence of the event.
-
-        Can be None or a datetime.date instance.  If until is not None
-        then count must be None.  If both count and until are None the
-        event repeats forever.
-        """)
-
-    exceptions = List(
-        title=u"Exceptions",
-        value_type=Date(),
-        description=u"""
-        A list of days when this event does not occur.
-
-        Values in this list must be instances of datetime.date.
-        """)
-
-    def replace(**kw):
-        """Return a copy of this recurrence rule with new specified fields."""
-
-    def __eq__(other):
-        """See if self == other."""
-
-    def __ne__(other):
-        """See if self != other."""
-
-    def apply(event, enddate=None):
-       """Apply this rule to an event.
-
-       This is a generator that returns the dates on which the event should
-       recur.  Be careful when iterating over these dates -- rules that do not
-       have either 'until' or 'count' attributes will go on forever.
-
-       The optional enddate attribute can be used to set a range on the dates
-       generated by this function (inclusive).
-       """
-
-    def iCalRepresentation(dtstart):
-       """Return the rule in iCalendar format.
-
-       Returns a list of strings.  XXX more details, please
-
-       dtstart is a datetime representing the date that the recurring
-       event starts on.
-       """
-
-
-class IDailyRecurrenceRule(IRecurrenceRule):
-    """Daily recurrence."""
-
-
-class IYearlyRecurrenceRule(IRecurrenceRule):
-    """Yearly recurrence."""
-
-
-class IWeeklyRecurrenceRule(IRecurrenceRule):
-    """Weekly recurrence."""
-
-    weekdays = Set(
-        title=u"Weekdays",
-        value_type=Int(min=0, max=6),
-        description=u"""
-        A set of weekdays when this event occurs.
-
-        Weekdays are represented as integers from 0 (Monday) to 6 (Sunday).
-        This is what the `calendar` and `datetime` modules use.
-
-        The event repeats on the weekday of the first occurence even
-        if that weekday is not in this set.
-        """)
-
-
-class IMonthlyRecurrenceRule(IRecurrenceRule):
-    """Monthly recurrence."""
-
-    monthly = Choice(
-        title=u"Type",
-        values=('monthday', 'weekday', 'lastweekday'),
-        description=u"""
-        Specification of a monthly occurence.
-
-        Can be one of three values: 'monthday', 'weekday', 'lastweekday'.
-
-        'monthday'    specifies that the event recurs on the same day of month
-                      (e.g., 25th day of a month).
-
-        'weekday'     specifies that the event recurs on the same week
-                      within a month on the same weekday, indexed from the
-                      first (e.g. 3rd Friday of a month).
-
-        'lastweekday' specifies that the event recurs on the same week
-                      within a month on the same weekday, indexed from the
-                      end of month (e.g. 2nd last Friday of a month).
-        """)
-
-
-class ICalendarEvent(Interface):
-    """A calendar event.
-
-    Calendar events are immutable and comparable.
-
-    Events are compared in chronological order, so lists of events can be
-    sorted.  If two events start at the same time, they are ordered according
-    to their titles.
-
-    While `unique_id` is a globally unique ID of a calendar event, you can
-    have several calendar event objects with the same value of `unique_id`,
-    and they will not be equal if any their attributes are different.
-    Semantically these objects are different versions of the same calendar
-    event.
-
-    If you need to modify a calendar event in a calendar, you should do
-    the following:
-
-        calendar.removeEvent(event)
-        replacement_event = event.replace(title=u"New title", ...)
-        calendar.addEvent(replacement_event)
-
-    """
-
-    id = Int(
-        title=u"An internal ID for the event",
-        required=True, readonly=True,
-        description=u"""An ID for the event, guaranteed to be unique locally
-        but not globally.""")
-
-    calendar = Object(
-        title=u"Calendar",
-        schema=ICalendar,
-        description=u"""
-        The calendar this event belongs to.
-        """)
-
-    unique_id = TextLine(
-        title=u"UID",
-        description=u"""
-        A globally unique id for this calendar event.
-
-        iCalendar (RFC 2445) recommeds using the RFC 822 addr-spec syntax
-        for unique IDs.  Put the current timestamp and a random number
-        on the left of the @ sign, and put the hostname on the right.
-        """)
-
-    dtstart = Datetime(
-        title=u"Starting date and time",
-        description=u"""Format: yyyy-mm-dd hh:mm"""
-        )
-
-    duration = Field(title=u"Duration")
-        # The duration of the event (datetime.timedelta).
-        # You can compute the event end date/time by adding duration to dtstart.
-        # zope.schema does not have TimeInterval.
-
-    title = TextLine(title=u"Name")
-
-    description = Text(title=u"Description")
-
-    location = TextLine(
-        title=u"Location",
-        required=False,
-        description=u"""Where the event will take place.""")
-
-    recurrence = Object(
-        title=u"Recurrence",
-        schema=IRecurrenceRule,
-        required=False,
-        description=u"""
-        The recurrence rule, if this is a recurring event, otherwise None.
-        """)
-
-    def replace(**kw):
-        """Return a calendar event with new specified fields.
-
-        This is useful for editing calendars.  For example, to change the
-        title and location of an event in a calendar, you would do
-
-            calendar.removeEvent(event)
-            replacement_event = event.replace(title=u"New title",
-                                              location=None)
-            calendar.addEvent(replacement_event)
-
-        """
-
-    def __eq__(other):
-        """See if self == other."""
-
-    def __ne__(other):
-        """See if self != other."""
-
-    def __lt__(other):
-        """See if self < other."""
-
-    def __gt__(other):
-        """See if self > other."""
-
-    def __le__(other):
-        """See if self <= other."""
-
-    def __ge__(other):
-        """See if self >= other."""
-
-    def hasOccurrences():
-        """Does the event have any occurrences?
-
-        Normally all events have at least one occurrence.  However if you have
-        a repeating event that repeats a finite number of times, and all those
-        repetitions are listed as exceptions, then hasOccurrences() will return
-        False.  There are other corner cases as well (e.g. a recurring event
-        with until date that is earlier than dtstart).
-        """
-
-
-class IExpandedCalendarEvent(ICalendarEvent):
-    """A single occurrence of a recurring calendar event.
-
-    The original event is stored in the `original` attribute.  The `dtstart`
-    attribute contains the date and time of this occurrence and may differ
-    from the `dtstart` attribute of the original event.  All other attributes
-    are the same.
-    """
-
-    dtstart = Datetime(
-        title=u"Start",
-        description=u"""
-        Date and time when this occurrence of the event starts.
-        """)
-
-    original = Object(
-        title=u"Original",
-        schema=ICalendarEvent,
-        description=u"""
-        The recurring event that generated this occurrence.
-        """)
-
-    def replace(**kw):
-        """Return a calendar event with new specified fields.
-
-            expanded_event.replace(**kw)
-
-        is (almost) equivalent to
-
-            expanded_event.original.replace(**kw)
-
-        In other words, the returned event will not provide
-        IExpandedCalendarEvent and its dtstart attribute will be the date and
-        time of the original event rather than this specific occurrence.
-        """
-

=== removed file 'lib/schoolbell/mixins.py'
--- lib/schoolbell/mixins.py	2005-10-31 18:29:12 +0000
+++ lib/schoolbell/mixins.py	1970-01-01 00:00:00 +0000
@@ -1,314 +0,0 @@
-"""
-Mixins for implementing calendars.
-"""
-
-__metaclass__ = type
-
-
-class CalendarMixin:
-    """Mixin for implementing ICalendar methods.
-
-    You do not have to use this mixin, however it might make implementation
-    easier, albeit potentially slower.
-
-    A class that uses this mixin must already implement ICalendar.__iter__.
-
-        >>> from schoolbell.interfaces import ICalendar
-        >>> from zope.interface import implements
-        >>> class MyCalendar(CalendarMixin):
-        ...     implements(ICalendar)
-        ...     def __iter__(self):
-        ...         return iter([])
-        >>> from zope.interface.verify import verifyObject
-        >>> verifyObject(ICalendar, MyCalendar())
-        True
-
-    """
-
-    def find(self, unique_id):
-        """Find a calendar event with a given UID.
-
-        This particular implementation simply performs a linear search by
-        iterating over all events and looking at their UIDs.
-
-            >>> from schoolbell.interfaces import ICalendar
-            >>> from zope.interface import implements
-
-            >>> class Event:
-            ...     def __init__(self, uid):
-            ...         self.unique_id = uid
-
-            >>> class MyCalendar(CalendarMixin):
-            ...     implements(ICalendar)
-            ...     def __iter__(self):
-            ...         return iter([Event(uid) for uid in 'a', 'b'])
-            >>> cal = MyCalendar()
-
-            >>> cal.find('a').unique_id
-            'a'
-            >>> cal.find('b').unique_id
-            'b'
-            >>> cal.find('c')
-            Traceback (most recent call last):
-              ...
-            KeyError: 'c'
-
-        """
-        for event in self:
-            if event.unique_id == unique_id:
-                return event
-        raise KeyError(unique_id)
-
-    def expand(self, first, last):
-        """Return an iterator over all expanded events in a given time period.
-
-        See ICalendar for more details.
-
-            >>> from datetime import datetime, timedelta
-            >>> from schoolbell.interfaces import ICalendar
-            >>> from zope.interface import implements
-
-            >>> class Event:
-            ...     def __init__(self, dtstart, duration, title):
-            ...         self.dtstart = dtstart
-            ...         self.duration = duration
-            ...         self.title = title
-
-            >>> class MyCalendar(CalendarMixin):
-            ...     implements(ICalendar)
-            ...     def __iter__(self):
-            ...         return iter([Event(datetime(2004, 12, 14, 12, 30),
-            ...                            timedelta(hours=1), 'a'),
-            ...                      Event(datetime(2004, 12, 15, 16, 30),
-            ...                            timedelta(hours=1), 'b'),
-            ...                      Event(datetime(2004, 12, 15, 14, 30),
-            ...                            timedelta(hours=1), 'c'),
-            ...                      Event(datetime(2004, 12, 16, 17, 30),
-            ...                            timedelta(hours=1), 'd'),
-            ...                     ])
-            >>> cal = MyCalendar()
-
-        We will define a convenience function for showing all events returned
-        by expand:
-
-            >>> def show(first, last):
-            ...     events = cal.expand(first, last)
-            ...     print '[%s]' % ', '.join([e.title for e in events])
-
-        Events that fall inside the interval
-
-            >>> show(datetime(2004, 12, 1), datetime(2004, 12, 31))
-            [a, b, c, d]
-
-            >>> show(datetime(2004, 12, 15), datetime(2004, 12, 16))
-            [b, c]
-
-        Events that fall partially in the interval
-
-            >>> show(datetime(2004, 12, 15, 17, 0),
-            ...      datetime(2004, 12, 16, 18, 0))
-            [b, d]
-
-        Corner cases: if event.dtstart + event.duration == last, or
-        event.dtstart == first, the event is not included.
-
-            >>> show(datetime(2004, 12, 15, 15, 30),
-            ...      datetime(2004, 12, 15, 16, 30))
-            []
-
-        TODO: recurring events
-
-        """
-        for event in self:
-            # TODO: recurring events
-            dtstart = event.dtstart
-            dtend = dtstart + event.duration
-            if dtend > first and dtstart < last:
-                yield event
-
-
-class EditableCalendarMixin:
-    """Mixin for implementing some IEditCalendar methods.
-
-    This mixin implements `clear` and `update` by using `addEvent` and
-    `removeEvent`.
-
-        >>> class Event:
-        ...     def __init__(self, uid):
-        ...         self.unique_id = uid
-
-        >>> class SampleCalendar(EditableCalendarMixin):
-        ...     def __init__(self):
-        ...         self._events = {}
-        ...     def __iter__(self):
-        ...         return self._events.itervalues()
-        ...     def addEvent(self, event):
-        ...         self._events[event.unique_id] = event
-        ...     def removeEvent(self, event):
-        ...         del self._events[event.unique_id]
-
-        >>> cal = SampleCalendar()
-        >>> cal.addEvent(Event('a'))
-        >>> cal.addEvent(Event('b'))
-        >>> cal.addEvent(Event('c'))
-        >>> len(list(cal))
-        3
-
-        >>> cal2 = SampleCalendar()
-        >>> cal2.update(cal)
-        >>> len(list(cal2))
-        3
-
-        >>> cal.clear()
-        >>> list(cal)
-        []
-
-    """
-
-    def update(self, calendar):
-        """Add all events from another calendar to this calendar."""
-        for event in calendar:
-            self.addEvent(event)
-
-    def clear(self):
-        """Remove all events from the calendar."""
-        for event in list(self):
-            self.removeEvent(event)
-
-
-class CalendarEventMixin:
-    """Mixin for implementing ICalendarEvent comparison methods.
-
-    Calendar events are equal iff all their attributes are equal.  We can get a
-    list of those attributes easily because ICalendarEvent is a schema.
-
-        >>> from schoolbell.interfaces import ICalendarEvent
-        >>> from zope.schema import getFieldNames
-        >>> all_attrs = getFieldNames(ICalendarEvent)
-        >>> 'unique_id' in all_attrs
-        True
-        >>> '__eq__' not in all_attrs
-        True
-
-    We will create a bunch of Event objects that differ in exactly one
-    attribute and compare them.
-
-        >>> class Event(CalendarEventMixin):
-        ...     def __init__(self, **kw):
-        ...         for attr in all_attrs:
-        ...             setattr(self, attr, '%s_default_value' % attr)
-        ...         for attr, value in kw.items():
-        ...             setattr(self, attr, value)
-
-        >>> e1 = Event()
-        >>> for attr in all_attrs:
-        ...     e2 = Event()
-        ...     setattr(e2, attr, 'some other value')
-        ...     assert e1 != e2, 'change in %s was not noticed' % attr
-
-    If you have two events with the same values in all ICalendarEvent
-    attributes, they are equal
-
-        >>> e1 = Event()
-        >>> e2 = Event()
-        >>> e1 == e2
-        True
-
-    even if they have extra attributes
-
-        >>> e1 = Event()
-        >>> e1.annotation = 'a'
-        >>> e2 = Event()
-        >>> e2.annotation = 'b'
-        >>> e1 == e2
-        True
-
-    Events are ordered by their date and time, title and, finally, UID (to
-    break any ties and provide a stable consistent ordering).
-
-        >>> from datetime import datetime
-
-        >>> e1 = Event(dtstart=datetime(2004, 12, 15))
-        >>> e2 = Event(dtstart=datetime(2004, 12, 16))
-        >>> e1 < e2
-        True
-
-        >>> e1 = Event(dtstart=datetime(2004, 12, 15), title="A")
-        >>> e2 = Event(dtstart=datetime(2004, 12, 15), title="B")
-        >>> e1 < e2
-        True
-
-        >>> e1 = Event(dtstart=datetime(2004, 12, 1), title="A", unique_id="X")
-        >>> e2 = Event(dtstart=datetime(2004, 12, 1), title="A", unique_id="Y")
-        >>> e1 < e2
-        True
-
-    """
-
-    def __eq__(self, other):
-        """Check whether two calendar events are equal."""
-        return (self.unique_id, self.dtstart, self.duration, self.title,
-                self.location, self.recurrence) \
-               == (other.unique_id, other.dtstart, other.duration, other.title,
-                   other.location, other.recurrence)
-
-    def __ne__(self, other):
-        return not self.__eq__(other)
-
-    def __lt__(self, other):
-        return (self.dtstart, self.title, self.unique_id) \
-               < (other.dtstart, other.title, other.unique_id)
-
-    def __gt__(self, other):
-        return (self.dtstart, self.title, self.unique_id) \
-               > (other.dtstart, other.title, other.unique_id)
-
-    def __le__(self, other):
-        return (self.dtstart, self.title, self.unique_id) \
-               <= (other.dtstart, other.title, other.unique_id)
-
-    def __ge__(self, other):
-        return (self.dtstart, self.title, self.unique_id) \
-               >= (other.dtstart, other.title, other.unique_id)
-
-    def hasOccurrences(self):
-        raise NotImplementedError # TODO
-
-    def replace(self, **kw):
-        r"""Return a copy of this event with some attributes replaced.
-
-            >>> from schoolbell.interfaces import ICalendarEvent
-            >>> from zope.schema import getFieldNames
-            >>> all_attrs = getFieldNames(ICalendarEvent)
-            >>> class Event(CalendarEventMixin):
-            ...     def __init__(self, **kw):
-            ...         for attr in all_attrs:
-            ...             setattr(self, attr, '%s_default_value' % attr)
-            ...         for attr, value in kw.items():
-            ...             setattr(self, attr, value)
-
-            >>> from datetime import datetime, timedelta
-            >>> e1 = Event(dtstart=datetime(2004, 12, 15, 18, 57),
-            ...            duration=timedelta(minutes=15),
-            ...            title='Work on schoolbell.simple',
-            ...            location=None)
-
-            >>> e2 = e1.replace(location=u'Matar\u00f3')
-            >>> e2 == e1
-            False
-            >>> e2.title == e1.title
-            True
-            >>> e2.location
-            u'Matar\xf3'
-
-            >>> e3 = e2.replace(location=None)
-            >>> e3 == e1
-            True
-
-        """
-        # The import is here to avoid cyclic dependencies
-        from schoolbell.simple import SimpleCalendarEvent
-        for attr in ['dtstart', 'duration', 'title', 'description',
-                     'location', 'unique_id', 'recurrence']:
-            kw.setdefault(attr, getattr(self, attr))
-        return SimpleCalendarEvent(**kw)

=== removed file 'lib/schoolbell/simple.py'
--- lib/schoolbell/simple.py	2005-10-31 18:29:12 +0000
+++ lib/schoolbell/simple.py	1970-01-01 00:00:00 +0000
@@ -1,96 +0,0 @@
-"""
-Simple calendar events and calendars.
-"""
-
-import datetime
-import random
-import email.Utils
-from zope.interface import implements
-from schoolbell.interfaces import ICalendar, ICalendarEvent
-from schoolbell.mixins import CalendarEventMixin, CalendarMixin
-
-__metaclass__ = type
-
-
-class SimpleCalendarEvent(CalendarEventMixin):
-    """A simple implementation of ICalendarEvent.
-
-        >>> from datetime import datetime, timedelta
-        >>> from zope.interface.verify import verifyObject
-        >>> e = SimpleCalendarEvent(datetime(2004, 12, 15, 18, 57),
-        ...                         timedelta(minutes=15),
-        ...                         'Work on schoolbell.simple')
-        >>> verifyObject(ICalendarEvent, e)
-        True
-
-    If you do not specify a unique ID, a random one is generated
-
-        >>> e.unique_id is not None
-        True
-
-    """
-
-    implements(ICalendarEvent)
-
-    def __init__(self, dtstart, duration, title, description=None, location=None, unique_id=None,
-                 recurrence=None):
-        self.dtstart = dtstart
-        self.duration = duration
-        self.title = title
-        self.description=description
-        self.location = location
-        self.recurrence = recurrence
-        self.unique_id = unique_id
-        if not self.unique_id:
-            self.unique_id = new_unique_id()
-
-
-class ImmutableCalendar(CalendarMixin):
-    """A simple read-only calendar.
-
-        >>> from datetime import datetime, timedelta
-        >>> from zope.interface.verify import verifyObject
-        >>> e = SimpleCalendarEvent(datetime(2004, 12, 15, 18, 57),
-        ...                         timedelta(minutes=15),
-        ...                         'Work on schoolbell.simple')
-        >>> calendar = ImmutableCalendar([e])
-        >>> verifyObject(ICalendar, calendar)
-        True
-
-        >>> [e.title for e in calendar]
-        ['Work on schoolbell.simple']
-
-    """
-
-    implements(ICalendar)
-
-    def __init__(self, events=()):
-        self._events = tuple(events)
-
-    def __iter__(self):
-        return iter(self._events)
-
-
-def new_unique_id():
-    """Generate a new unique ID for a calendar event.
-
-    UID is randomly generated and follows RFC 822 addr-spec:
-
-        >>> uid = new_unique_id()
-        >>> '@' in uid
-        True
-
-    Note that it does not have the angle brackets
-
-        >>> '<' not in uid
-        True
-        >>> '>' not in uid
-        True
-
-    """
-    more_uniqueness = '%d.%d' % (datetime.datetime.now().microsecond,
-                                 random.randrange(10 ** 6, 10 ** 7))
-    # generate an rfc-822 style id and strip angle brackets
-    unique_id = email.Utils.make_msgid(more_uniqueness)[1:-1]
-    return unique_id
-

=== removed directory 'lib/schoolbell/tests'
=== removed file 'lib/schoolbell/tests/__init__.py'
--- lib/schoolbell/tests/__init__.py	2005-10-31 18:29:12 +0000
+++ lib/schoolbell/tests/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,1 +0,0 @@
-"""Unit tests for SchoolBell"""

=== removed file 'lib/schoolbell/tests/test_icalendar.py'
--- lib/schoolbell/tests/test_icalendar.py	2005-10-31 18:29:12 +0000
+++ lib/schoolbell/tests/test_icalendar.py	1970-01-01 00:00:00 +0000
@@ -1,782 +0,0 @@
-"""
-Unit tests for schoolbell.icalendar
-"""
-
-import unittest
-import difflib
-import time
-import os
-from pprint import pformat
-from textwrap import dedent
-from datetime import date, timedelta, datetime
-from StringIO import StringIO
-
-from zope.testing import doctest
-
-
-def diff(old, new, oldlabel="expected output", newlabel="actual output"):
-    """Display a unified diff between old text and new text."""
-    old = old.splitlines()
-    new = new.splitlines()
-
-    diff = ['--- %s' % oldlabel, '+++ %s' % newlabel]
-
-    def dump(tag, x, lo, hi):
-        for i in xrange(lo, hi):
-            diff.append(tag + x[i])
-
-    differ = difflib.SequenceMatcher(a=old, b=new)
-    for tag, alo, ahi, blo, bhi in differ.get_opcodes():
-        if tag == 'replace':
-            dump('-', old, alo, ahi)
-            dump('+', new, blo, bhi)
-        elif tag == 'delete':
-            dump('-', old, alo, ahi)
-        elif tag == 'insert':
-            dump('+', new, blo, bhi)
-        elif tag == 'equal':
-            dump(' ', old, alo, ahi)
-        else:
-            raise AssertionError('unknown tag %r' % tag)
-    return "\n".join(diff)
-
-
-class TimezoneTestMixin:
-    """A mixin for tests that fiddle with timezones."""
-
-    def setUp(self):
-        self.have_tzset = hasattr(time, 'tzset')
-        self.touched_tz = False
-        self.old_tz = os.getenv('TZ')
-
-    def tearDown(self):
-        if self.touched_tz:
-            self.setTZ(self.old_tz)
-
-    def setTZ(self, tz):
-        self.touched_tz = True
-        if tz is None:
-            os.unsetenv('TZ')
-        else:
-            os.putenv('TZ', tz)
-        time.tzset()
-
-
-class TestParseDateTime(TimezoneTestMixin, unittest.TestCase):
-
-    def test_timezones(self):
-        # The simple tests are in the doctest of parse_date_time.
-        from schoolbell.icalendar import parse_date_time
-
-        if not self.have_tzset:
-            return # Do not run this test on Windows
-
-        self.setTZ('UTC')
-        dt = parse_date_time('20041029T125031Z')
-        self.assertEquals(dt, datetime(2004, 10, 29, 12, 50, 31))
-
-        self.setTZ('EET-2EEST')
-        dt = parse_date_time('20041029T095031Z') # daylight savings
-        self.assertEquals(dt, datetime(2004, 10, 29, 12, 50, 31))
-        dt = parse_date_time('20041129T095031Z') # no daylight savings
-        self.assertEquals(dt, datetime(2004, 11, 29, 11, 50, 31))
-
-
-class TestPeriod(unittest.TestCase):
-
-    def test(self):
-        from schoolbell.icalendar import Period
-        dt1 = datetime(2001, 2, 3, 14, 30, 5)
-        dt2 = datetime(2001, 2, 3, 16, 35, 20)
-        td = dt2 - dt1
-        p1 = Period(dt1, dt2)
-        self.assertEquals(p1.start, dt1)
-        self.assertEquals(p1.end, dt2)
-        self.assertEquals(p1.duration, td)
-
-        p2 = Period(dt1, td)
-        self.assertEquals(p2.start, dt1)
-        self.assertEquals(p2.end, dt2)
-        self.assertEquals(p2.duration, td)
-
-        self.assertEquals(p1, p2)
-
-        p = Period(dt1, timedelta(0))
-        self.assertEquals(p.start, dt1)
-        self.assertEquals(p.end, dt1)
-        self.assertEquals(p.duration, timedelta(0))
-
-        self.assertRaises(ValueError, Period, dt2, dt1)
-        self.assertRaises(ValueError, Period, dt1, -td)
-
-    def test_overlap(self):
-        from schoolbell.icalendar import Period
-        p1 = Period(datetime(2004, 1, 1, 12, 0), timedelta(hours=1))
-        p2 = Period(datetime(2004, 1, 1, 11, 30), timedelta(hours=1))
-        p3 = Period(datetime(2004, 1, 1, 12, 30), timedelta(hours=1))
-        p4 = Period(datetime(2004, 1, 1, 11, 0), timedelta(hours=3))
-
-        self.assert_(p1.overlaps(p2))
-        self.assert_(p2.overlaps(p1))
-
-        self.assert_(p1.overlaps(p3))
-        self.assert_(p3.overlaps(p1))
-
-        self.assert_(not p2.overlaps(p3))
-        self.assert_(not p3.overlaps(p2))
-
-        self.assert_(p1.overlaps(p4))
-        self.assert_(p4.overlaps(p1))
-
-        self.assert_(p1.overlaps(p1))
-
-
-class TestVEvent(unittest.TestCase):
-
-    def test_add(self):
-        from schoolbell.icalendar import VEvent, ICalParseError
-        vevent = VEvent()
-        value, params = 'bar', {'VALUE': 'TEXT'}
-        vevent.add('foo', value, params)
-        self.assertEquals(vevent._props, {'FOO': [(value, params)]})
-        value2 = 'guug'
-        vevent.add('fie', value2)
-        self.assertEquals(vevent._props, {'FOO': [(value, params)],
-                                          'FIE': [(value2, {})]})
-        vevent.add('fie', value, params)
-        self.assertEquals(vevent._props, {'FOO': [(value, params)],
-                                          'FIE': [(value2, {}),
-                                                  (value, params)]})
-
-        # adding a singleton property twice
-        vevent.add('uid', '1')
-        self.assertRaises(ICalParseError, vevent.add, 'uid', '2')
-
-    def test_hasProp(self):
-        from schoolbell.icalendar import VEvent
-        vevent = VEvent()
-        vevent.add('foo', 'bar', {})
-        self.assert_(vevent.hasProp('foo'))
-        self.assert_(vevent.hasProp('Foo'))
-        self.assert_(not vevent.hasProp('baz'))
-
-    def test__getType(self):
-        from schoolbell.icalendar import VEvent
-        vevent = VEvent()
-        vevent.add('x-explicit', '', {'VALUE': 'INTEGER'})
-        vevent.add('dtstart', 'implicit type', {})
-        vevent.add('x-default', '', {})
-        self.assertEquals(vevent._getType('x-explicit'), 'INTEGER')
-        self.assertEquals(vevent._getType('dtstart'), 'DATE-TIME')
-        self.assertEquals(vevent._getType('x-default'), 'TEXT')
-        self.assertEquals(vevent._getType('X-Explicit'), 'INTEGER')
-        self.assertEquals(vevent._getType('DtStart'), 'DATE-TIME')
-        self.assertEquals(vevent._getType('X-Default'), 'TEXT')
-        self.assertRaises(KeyError, vevent._getType, 'nonexistent')
-
-    def test_getOne(self):
-        from schoolbell.icalendar import VEvent
-        vevent = VEvent()
-
-        vevent.add('foo', 'bar', {})
-        self.assertEquals(vevent.getOne('foo'), 'bar')
-        self.assertEquals(vevent.getOne('Foo'), 'bar')
-        self.assertEquals(vevent.getOne('baz'), None)
-        self.assertEquals(vevent.getOne('baz', 'quux'), 'quux')
-        self.assertEquals(vevent.getOne('dtstart', 'quux'), 'quux')
-
-        vevent.add('int-foo', '42', {'VALUE': 'INTEGER'})
-        vevent.add('int-bad', 'xyzzy', {'VALUE': 'INTEGER'})
-        self.assertEquals(vevent.getOne('int-foo'), 42)
-        self.assertEquals(vevent.getOne('Int-Foo'), 42)
-        self.assertRaises(ValueError, vevent.getOne, 'int-bad')
-
-        vevent.add('date-foo', '20030405', {'VALUE': 'DATE'})
-        vevent.add('date-bad1', '20030405T1234', {'VALUE': 'DATE'})
-        vevent.add('date-bad2', '2003', {'VALUE': 'DATE'})
-        vevent.add('date-bad3', '200301XX', {'VALUE': 'DATE'})
-        self.assertEquals(vevent.getOne('date-Foo'), date(2003, 4, 5))
-        self.assertRaises(ValueError, vevent.getOne, 'date-bad1')
-        self.assertRaises(ValueError, vevent.getOne, 'date-bad2')
-        self.assertRaises(ValueError, vevent.getOne, 'date-bad3')
-
-        vevent.add('datetime-foo1', '20030405T060708', {'VALUE': 'DATE-TIME'})
-        vevent.add('datetime-foo2', '20030405T060708', {'VALUE': 'DATE-TIME'})
-        vevent.add('datetime-bad1', '20030405T010203444444',
-                                                        {'VALUE': 'DATE-TIME'})
-        vevent.add('datetime-bad2', '2003', {'VALUE': 'DATE-TIME'})
-        self.assertEquals(vevent.getOne('datetime-foo1'),
-                          datetime(2003, 4, 5, 6, 7, 8))
-        self.assertEquals(vevent.getOne('Datetime-Foo2'),
-                          datetime(2003, 4, 5, 6, 7, 8))
-        self.assertRaises(ValueError, vevent.getOne, 'datetime-bad1')
-        self.assertRaises(ValueError, vevent.getOne, 'datetime-bad2')
-
-        vevent.add('dur-foo1', '+P11D', {'VALUE': 'DURATION'})
-        vevent.add('dur-foo2', '-P2W', {'VALUE': 'DURATION'})
-        vevent.add('dur-foo3', 'P1DT2H3M4S', {'VALUE': 'DURATION'})
-        vevent.add('dur-foo4', 'PT2H', {'VALUE': 'DURATION'})
-        vevent.add('dur-bad1', 'xyzzy', {'VALUE': 'DURATION'})
-        self.assertEquals(vevent.getOne('dur-foo1'), timedelta(days=11))
-        self.assertEquals(vevent.getOne('Dur-Foo2'), -timedelta(weeks=2))
-        self.assertEquals(vevent.getOne('Dur-Foo3'),
-                          timedelta(days=1, hours=2, minutes=3, seconds=4))
-        self.assertEquals(vevent.getOne('DUR-FOO4'), timedelta(hours=2))
-        self.assertRaises(ValueError, vevent.getOne, 'dur-bad1')
-
-        vevent.add('unknown', 'magic', {'VALUE': 'UNKNOWN-TYPE'})
-        self.assertEquals(vevent.getOne('unknown'), 'magic')
-
-    def test_iterDates(self):
-        from schoolbell.icalendar import VEvent
-        vevent = VEvent()
-        vevent.all_day_event = True
-        vevent.dtstart = date(2003, 1, 2)
-        vevent.dtend = date(2003, 1, 5)
-        vevent.duration = timedelta(days=3)
-        vevent.rdates = []
-        vevent.exdates = []
-        self.assertEquals(list(vevent.iterDates()),
-                    [date(2003, 1, 2), date(2003, 1, 3), date(2003, 1, 4)])
-
-        vevent.all_day_event = False;
-        self.assertRaises(ValueError, list, vevent.iterDates())
-
-    def test_iterDates_with_rdate_exdate(self):
-        from schoolbell.icalendar import VEvent
-        vevent = VEvent()
-        vevent.all_day_event = True
-        vevent.dtstart = date(2003, 1, 5)
-        vevent.dtend = date(2003, 1, 6)
-        vevent.duration = timedelta(days=1)
-        vevent.rdates = [date(2003, 1, 2), date(2003, 1, 8), date(2003, 1, 8)]
-        vevent.exdates = []
-        expected = [date(2003, 1, 2), date(2003, 1, 5), date(2003, 1, 8)]
-        self.assertEquals(list(vevent.iterDates()), expected)
-
-        vevent.exdates = [date(2003, 1, 6)]
-        expected = [date(2003, 1, 2), date(2003, 1, 5), date(2003, 1, 8)]
-        self.assertEquals(list(vevent.iterDates()), expected)
-
-        vevent.exdates = [date(2003, 1, 2), date(2003, 1, 2)]
-        expected = [date(2003, 1, 5), date(2003, 1, 8)]
-        self.assertEquals(list(vevent.iterDates()), expected)
-
-        vevent.exdates = [date(2003, 1, 5)]
-        expected = [date(2003, 1, 2), date(2003, 1, 8)]
-        self.assertEquals(list(vevent.iterDates()), expected)
-
-        vevent.dtend = date(2003, 1, 7)
-        vevent.duration = timedelta(days=2)
-        vevent.exdates = [date(2003, 1, 5), date(2003, 1, 3)]
-        expected = [date(2003, 1, 2), date(2003, 1, 3),
-                    date(2003, 1, 8), date(2003, 1, 9)]
-        self.assertEquals(list(vevent.iterDates()), expected)
-
-    def test_validate_error_cases(self):
-        from schoolbell.icalendar import VEvent, ICalParseError
-
-        vevent = VEvent()
-        self.assertRaises(ICalParseError, vevent.validate)
-
-        vevent = VEvent()
-        vevent.add('dtstart', 'xyzzy', {'VALUE': 'TEXT'})
-        self.assertRaises(ICalParseError, vevent.validate)
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203', {'VALUE': 'DATE'})
-        vevent.add('dtend', '20010203T0000', {'VALUE': 'DATE-TIME'})
-        self.assertRaises(ICalParseError, vevent.validate)
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203', {'VALUE': 'DATE'})
-        vevent.add('dtend', '20010203', {'VALUE': 'DATE'})
-        vevent.add('duration', 'P1D', {})
-        self.assertRaises(ICalParseError, vevent.validate)
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203', {'VALUE': 'DATE'})
-        vevent.add('duration', 'two years', {'VALUE': 'TEXT'})
-        self.assertRaises(ICalParseError, vevent.validate)
-
-    def test_validate_all_day_events(self):
-        from schoolbell.icalendar import VEvent, ICalParseError
-
-        vevent = VEvent()
-        vevent.add('summary', 'An event', {})
-        vevent.add('uid', 'unique', {})
-        vevent.add('dtstart', '20010203', {'VALUE': 'DATE'})
-        vevent.validate()
-        self.assert_(vevent.all_day_event)
-        self.assertEquals(vevent.summary, 'An event')
-        self.assertEquals(vevent.uid, 'unique')
-        self.assertEquals(vevent.dtend, date(2001, 2, 4))
-        self.assertEquals(vevent.duration, timedelta(days=1))
-
-        vevent = VEvent()
-        vevent.add('summary', 'An\\nevent\\; with backslashes', {})
-        vevent.add('uid', 'unique2', {})
-        vevent.add('dtstart', '20010203', {'VALUE': 'DATE'})
-        vevent.add('dtend', '20010205', {'VALUE': 'DATE'})
-        vevent.validate()
-        self.assertEquals(vevent.summary, 'An\nevent; with backslashes')
-        self.assert_(vevent.all_day_event)
-        self.assertEquals(vevent.dtstart, date(2001, 2, 3))
-        self.assertEquals(vevent.uid, 'unique2')
-        self.assertEquals(vevent.dtend, date(2001, 2, 5))
-        self.assertEquals(vevent.duration, timedelta(days=2))
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203', {'VALUE': 'DATE'})
-        vevent.add('uid', 'unique3', {})
-        vevent.add('duration', 'P2D')
-        vevent.validate()
-        self.assertEquals(vevent.summary, None)
-        self.assert_(vevent.all_day_event)
-        self.assertEquals(vevent.dtstart, date(2001, 2, 3))
-        self.assertEquals(vevent.uid, 'unique3')
-        self.assertEquals(vevent.dtend, date(2001, 2, 5))
-        self.assertEquals(vevent.duration, timedelta(days=2))
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203', {'VALUE': 'DATE'})
-        vevent.add('uid', 'unique4', {})
-        vevent.add('dtend', '20010201', {'VALUE': 'DATE'})
-        self.assertRaises(ICalParseError, vevent.validate)
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203', {'VALUE': 'DATE'})
-        vevent.add('uid', 'unique5', {})
-        vevent.add('dtend', '20010203', {'VALUE': 'DATE'})
-        self.assertRaises(ICalParseError, vevent.validate)
-
-    def test_validate_not_all_day_events(self):
-        from schoolbell.icalendar import VEvent, ICalParseError
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203T040506')
-        vevent.add('uid', 'unique', {})
-        vevent.validate()
-        self.assert_(not vevent.all_day_event)
-        self.assertEquals(vevent.dtstart, datetime(2001, 2, 3, 4, 5, 6))
-        self.assertEquals(vevent.dtend, datetime(2001, 2, 3, 4, 5, 6))
-        self.assertEquals(vevent.duration, timedelta(days=0))
-        self.assertEquals(vevent.rdates, [])
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203T040000')
-        vevent.add('uid', 'unique', {})
-        vevent.add('dtend', '20010204T050102')
-        vevent.validate()
-        self.assert_(not vevent.all_day_event)
-        self.assertEquals(vevent.dtstart, datetime(2001, 2, 3, 4, 0, 0))
-        self.assertEquals(vevent.dtend, datetime(2001, 2, 4, 5, 1, 2))
-        self.assertEquals(vevent.duration, timedelta(days=1, hours=1,
-                                                     minutes=1, seconds=2))
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203T040000')
-        vevent.add('uid', 'unique', {})
-        vevent.add('duration', 'P1DT1H1M2S')
-        vevent.validate()
-        self.assert_(not vevent.all_day_event)
-        self.assertEquals(vevent.dtstart, datetime(2001, 2, 3, 4, 0, 0))
-        self.assertEquals(vevent.dtend, datetime(2001, 2, 4, 5, 1, 2))
-        self.assertEquals(vevent.duration, timedelta(days=1, hours=1,
-                                                     minutes=1, seconds=2))
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203T010203')
-        vevent.add('uid', 'unique', {})
-        vevent.add('rdate', '20010205T040506')
-        vevent.add('exdate', '20010206T040506')
-        vevent.validate()
-        self.assertEquals(vevent.rdates, [datetime(2001, 2, 5, 4, 5, 6)])
-        self.assertEquals(vevent.exdates, [datetime(2001, 2, 6, 4, 5, 6)])
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203T010203')
-        vevent.add('uid', 'unique', {})
-        vevent.add('exdate', '20010206,20020307', {'VALUE': 'DATE'})
-        vevent.add('rrule', 'FREQ=DAILY')
-        vevent.validate()
-        self.assertEquals(vevent.exdates, [date(2001, 2, 6), date(2002, 3, 7)])
-
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203T010203')
-        vevent.add('uid', 'unique', {})
-        vevent.add('dtend', '20010203T010202')
-        self.assertRaises(ICalParseError, vevent.validate)
-
-    def test_validate_location(self):
-        from schoolbell.icalendar import VEvent
-        vevent = VEvent()
-        vevent.add('dtstart', '20010203T040506')
-        vevent.add('uid', 'unique5', {})
-        vevent.add('location', 'Somewhere')
-        vevent.validate()
-        self.assertEquals(vevent.location, 'Somewhere')
-
-# TODO: recurring events
-##  def test_validate_rrule(self):
-##      from schoolbell.icalendar import VEvent
-##      vevent = VEvent()
-##      vevent.add('dtstart', '20010203T040506')
-##      vevent.add('uid', 'unique5', {})
-##      vevent.add('location', 'Somewhere')
-##      vevent.add('rrule', 'FREQ=DAILY;COUNT=3')
-##      vevent.validate()
-##
-##      self.assertEquals(vevent.rrule.interval, 1)
-##      self.assertEquals(vevent.rrule.count, 3)
-##      self.assertEquals(vevent.rrule.until, None)
-##      self.assertEquals(vevent.rrule.exceptions, ())
-##
-##  def test_validate_rrule_exceptions(self):
-##      from schoolbell.icalendar import VEvent
-##      vevent = VEvent()
-##      vevent.add('dtstart', '20010203T040506')
-##      vevent.add('uid', 'unique5', {})
-##      vevent.add('location', 'Somewhere')
-##      vevent.add('rrule', 'FREQ=MONTHLY;BYDAY=3MO')
-##      vevent.add('exdate', '19960402T010000,19960404T010000',)
-##      vevent.validate()
-##
-##      self.assertEquals(vevent.rrule.interval, 1)
-##      self.assertEquals(vevent.rrule.count, None)
-##      self.assertEquals(vevent.rrule.until, None)
-##      self.assertEquals(vevent.rrule.monthly, 'weekday')
-##      self.assertEquals(vevent.rrule.exceptions,
-##                        (date(1996, 4, 2), date(1996, 4, 4)))
-##      self.assert_(not isinstance(vevent.rrule.exceptions[0], datetime))
-
-    def test_extractListOfDates(self):
-        from schoolbell.icalendar import VEvent, Period, ICalParseError
-
-        vevent = VEvent()
-        vevent.add('rdate', '20010205T040506')
-        vevent.add('rdate', '20010206T040506,20010207T000000')
-        vevent.add('rdate', '20010208', {'VALUE': 'DATE'})
-        vevent.add('rdate', '20010209T000000/20010210T000000',
-                   {'VALUE': 'PERIOD'})
-        rdates = vevent._extractListOfDates('RDATE', vevent.rdate_types, False)
-        expected = [datetime(2001, 2, 5, 4, 5, 6),
-                    datetime(2001, 2, 6, 4, 5, 6),
-                    datetime(2001, 2, 7, 0, 0, 0),
-                    date(2001, 2, 8),
-                    Period(datetime(2001, 2, 9), datetime(2001, 2, 10)),
-                   ]
-        self.assertEqual(expected, rdates,
-                         diff(pformat(expected), pformat(rdates)))
-
-        vevent = VEvent()
-        vevent.add('rdate', '20010205T040506', {'VALUE': 'TEXT'})
-        self.assertRaises(ICalParseError, vevent._extractListOfDates, 'RDATE',
-                                          vevent.rdate_types, False)
-
-        vevent = VEvent()
-        vevent.add('exdate', '20010205T040506/P1D', {'VALUE': 'PERIOD'})
-        self.assertRaises(ICalParseError, vevent._extractListOfDates, 'EXDATE',
-                                          vevent.exdate_types, False)
-
-        vevent = VEvent()
-        vevent.add('rdate', '20010208', {'VALUE': 'DATE'})
-        rdates = vevent._extractListOfDates('RDATE', vevent.rdate_types, True)
-        expected = [date(2001, 2, 8)]
-        self.assertEqual(expected, rdates,
-                         diff(pformat(expected), pformat(rdates)))
-
-        vevent = VEvent()
-        vevent.add('rdate', '20010205T040506', {'VALUE': 'DATE-TIME'})
-        self.assertRaises(ICalParseError, vevent._extractListOfDates, 'RDATE',
-                                          vevent.rdate_types, True)
-
-        vevent = VEvent()
-        vevent.add('rdate', '20010209T000000/20010210T000000',
-                   {'VALUE': 'PERIOD'})
-        self.assertRaises(ICalParseError, vevent._extractListOfDates, 'RDATE',
-                                          vevent.rdate_types, True)
-
-
-class TestICalReader(unittest.TestCase):
-
-    example_ical = dedent("""\
-        BEGIN:VCALENDAR
-        VERSION
-         :2.0
-        PRODID
-         :-//Mozilla.org/NONSGML Mozilla Calendar V1.0//EN
-        METHOD
-         :PUBLISH
-        BEGIN:VEVENT
-        UID
-         :956630271
-        SUMMARY
-         :Christmas Day
-        CLASS
-         :PUBLIC
-        X-MOZILLA-ALARM-DEFAULT-UNITS
-         :minutes
-        X-MOZILLA-ALARM-DEFAULT-LENGTH
-         :15
-        X-MOZILLA-RECUR-DEFAULT-UNITS
-         :weeks
-        X-MOZILLA-RECUR-DEFAULT-INTERVAL
-         :1
-        DTSTART
-         ;VALUE=DATE
-         :20031225
-        DTEND
-         ;VALUE=DATE
-         :20031226
-        DTSTAMP
-         :20020430T114937Z
-        END:VEVENT
-        END:VCALENDAR
-        BEGIN:VCALENDAR
-        VERSION
-         :2.0
-        PRODID
-         :-//Mozilla.org/NONSGML Mozilla Calendar V1.0//EN
-        METHOD
-         :PUBLISH
-        BEGIN:VEVENT
-        UID
-         :911737808
-        SUMMARY
-         :Boxing Day
-        CLASS
-         :PUBLIC
-        X-MOZILLA-ALARM-DEFAULT-UNITS
-         :minutes
-        X-MOZILLA-ALARM-DEFAULT-LENGTH
-         :15
-        X-MOZILLA-RECUR-DEFAULT-UNITS
-         :weeks
-        X-MOZILLA-RECUR-DEFAULT-INTERVAL
-         :1
-        DTSTART
-         ;VALUE=DATE
-         :20030501
-        DTSTAMP
-         :20020430T114937Z
-        END:VEVENT
-        BEGIN:VEVENT
-        UID
-         :wh4t3v3r
-        DTSTART;VALUE=DATE:20031225
-        SUMMARY:Christmas again!
-        END:VEVENT
-        END:VCALENDAR
-        """)
-
-    def test_iterEvents(self):
-        from schoolbell.icalendar import ICalReader, ICalParseError
-        file = StringIO(self.example_ical)
-        reader = ICalReader(file)
-        result = list(reader.iterEvents())
-        self.assertEqual(len(result), 3)
-        vevent = result[0]
-        self.assertEqual(vevent.getOne('x-mozilla-recur-default-units'),
-                         'weeks')
-        self.assertEqual(vevent.getOne('dtstart'), date(2003, 12, 25))
-        self.assertEqual(vevent.dtstart, date(2003, 12, 25))
-        self.assertEqual(vevent.getOne('dtend'), date(2003, 12, 26))
-        self.assertEqual(vevent.dtend, date(2003, 12, 26))
-        vevent = result[1]
-        self.assertEqual(vevent.getOne('dtstart'), date(2003, 05, 01))
-        self.assertEqual(vevent.dtstart, date(2003, 05, 01))
-        vevent = result[2]
-        self.assertEqual(vevent.getOne('dtstart'), date(2003, 12, 25))
-        self.assertEqual(vevent.dtstart, date(2003, 12, 25))
-
-        reader = ICalReader(StringIO(dedent("""\
-                    BEGIN:VCALENDAR
-                    BEGIN:VEVENT
-                    UID:hello
-                    DTSTART;VALUE=DATE:20010203
-                    BEGIN:VALARM
-                    X-PROP:foo
-                    END:VALARM
-                    END:VEVENT
-                    END:VCALENDAR
-                    """)))
-        result = list(reader.iterEvents())
-        self.assertEquals(len(result), 1)
-        vevent = result[0]
-        self.assert_(vevent.hasProp('uid'))
-        self.assert_(vevent.hasProp('dtstart'))
-        self.assert_(not vevent.hasProp('x-prop'))
-
-        reader = ICalReader(StringIO(dedent("""\
-                    BEGIN:VCALENDAR
-                    BEGIN:VEVENT
-                    DTSTART;VALUE=DATE:20010203
-                    END:VEVENT
-                    END:VCALENDAR
-                    """)))
-        # missing UID
-        self.assertRaises(ICalParseError, list, reader.iterEvents())
-
-        reader = ICalReader(StringIO(dedent("""\
-                    BEGIN:VCALENDAR
-                    BEGIN:VEVENT
-                    DTSTART;VALUE=DATE:20010203
-                    """)))
-        self.assertRaises(ICalParseError, list, reader.iterEvents())
-
-        reader = ICalReader(StringIO(dedent("""\
-                    BEGIN:VCALENDAR
-                    BEGIN:VEVENT
-                    DTSTART;VALUE=DATE:20010203
-                    END:VCALENDAR
-                    END:VEVENT
-                    """)))
-        self.assertRaises(ICalParseError, list, reader.iterEvents())
-
-        reader = ICalReader(StringIO(dedent("""\
-                    BEGIN:VCALENDAR
-                    END:VCALENDAR
-                    X-PROP:foo
-                    """)))
-        self.assertRaises(ICalParseError, list, reader.iterEvents())
-
-        reader = ICalReader(StringIO(dedent("""\
-                    BEGIN:VCALENDAR
-                    END:VCALENDAR
-                    BEGIN:VEVENT
-                    END:VEVENT
-                    """)))
-        self.assertRaises(ICalParseError, list, reader.iterEvents())
-
-        reader = ICalReader(StringIO(dedent("""\
-                    BEGIN:VCALENDAR
-                    BEGIN:VEVENT
-                    DTSTART;VALUE=DATE:20010203
-                    END:VEVENT
-                    END:VCALENDAR
-                    END:UNIVERSE
-                    """)))
-        self.assertRaises(ICalParseError, list, reader.iterEvents())
-
-        reader = ICalReader(StringIO(dedent("""\
-                    DTSTART;VALUE=DATE:20010203
-                    """)))
-        self.assertRaises(ICalParseError, list, reader.iterEvents())
-
-        reader = ICalReader(StringIO(dedent("""\
-                    This is just plain text
-                    """)))
-        self.assertRaises(ICalParseError, list, reader.iterEvents())
-
-        reader = ICalReader(StringIO(""))
-        self.assertEquals(list(reader.iterEvents()), [])
-
-    def test_iterRow(self):
-        from schoolbell.icalendar import ICalReader
-        file = StringIO("key1\n"
-                        " :value1\n"
-                        "key2\n"
-                        " ;VALUE=foo\n"
-                        " :value2\n"
-                        "key3;VALUE=bar:value3\n")
-        reader = ICalReader(file)
-        self.assertEqual(list(reader._iterRow()),
-                         [('KEY1', 'value1', {}),
-                          ('KEY2', 'value2', {'VALUE': 'FOO'}),
-                          ('KEY3', 'value3', {'VALUE': 'BAR'})])
-
-        file = StringIO("key1:value1\n"
-                        "key2;VALUE=foo:value2\n"
-                        "key3;VALUE=bar:value3\n")
-        reader = ICalReader(file)
-        self.assertEqual(list(reader._iterRow()),
-                         [('KEY1', 'value1', {}),
-                          ('KEY2', 'value2', {'VALUE': 'FOO'}),
-                          ('KEY3', 'value3', {'VALUE': 'BAR'})])
-
-        file = StringIO("key1:value:with:colons:in:it\n")
-        reader = ICalReader(file)
-        self.assertEqual(list(reader._iterRow()),
-                         [('KEY1', 'value:with:colons:in:it', {})])
-
-        reader = ICalReader(StringIO("ke\r\n y1\n\t:value\r\n  1 \r\n ."))
-        self.assertEqual(list(reader._iterRow()),
-                         [('KEY1', 'value 1 .', {})])
-
-        reader = ICalReader(StringIO("key;param=\xe2\x98\xbb:\r\n"
-                                     " value \xe2\x98\xbb\r\n"))
-        self.assertEqual(list(reader._iterRow()),
-                         [("KEY", u"value \u263B", {'PARAM': u'\u263B'})])
-
-    def test_parseRow(self):
-        from schoolbell.icalendar import ICalReader, ICalParseError
-        parseRow = ICalReader._parseRow
-        self.assertEqual(parseRow("key:"), ("KEY", "", {}))
-        self.assertEqual(parseRow("key:value"), ("KEY", "value", {}))
-        self.assertEqual(parseRow("key:va:lu:e"), ("KEY", "va:lu:e", {}))
-        self.assertRaises(ICalParseError, parseRow, "key but no value")
-        self.assertRaises(ICalParseError, parseRow, ":value but no key")
-        self.assertRaises(ICalParseError, parseRow, "bad name:")
-
-        self.assertEqual(parseRow("key;param=:value"),
-                         ("KEY", "value", {'PARAM': ''}))
-        self.assertEqual(parseRow("key;param=pvalue:value"),
-                         ("KEY", "value", {'PARAM': 'PVALUE'}))
-        self.assertEqual(parseRow('key;param=pvalue;param2=value2:value'),
-                         ("KEY", "value", {'PARAM': 'PVALUE',
-                                           'PARAM2': 'VALUE2'}))
-        self.assertEqual(parseRow('key;param="pvalue":value'),
-                         ("KEY", "value", {'PARAM': 'pvalue'}))
-        self.assertEqual(parseRow('key;param=pvalue;param2="value2":value'),
-                         ("KEY", "value", {'PARAM': 'PVALUE',
-                                           'PARAM2': 'value2'}))
-        self.assertRaises(ICalParseError, parseRow, "k;:no param")
-        self.assertRaises(ICalParseError, parseRow, "k;a?=b:bad param")
-        self.assertRaises(ICalParseError, parseRow, "k;a=\":bad param")
-        self.assertRaises(ICalParseError, parseRow, "k;a=\"\177:bad param")
-        self.assertRaises(ICalParseError, parseRow, "k;a=\001:bad char")
-        self.assertEqual(parseRow("key;param=a,b,c:value"),
-                         ("KEY", "value", {'PARAM': ['A', 'B', 'C']}))
-        self.assertEqual(parseRow('key;param=a,"b,c",d:value'),
-                         ("KEY", "value", {'PARAM': ['A', 'b,c', 'D']}))
-def diff(old, new, oldlabel="expected output", newlabel="actual output"):
-    """Display a unified diff between old text and new text."""
-    old = old.splitlines()
-    new = new.splitlines()
-
-    diff = ['--- %s' % oldlabel, '+++ %s' % newlabel]
-
-    def dump(tag, x, lo, hi):
-        for i in xrange(lo, hi):
-            diff.append(tag + x[i])
-
-    differ = difflib.SequenceMatcher(a=old, b=new)
-    for tag, alo, ahi, blo, bhi in differ.get_opcodes():
-        if tag == 'replace':
-            dump('-', old, alo, ahi)
-            dump('+', new, blo, bhi)
-        elif tag == 'delete':
-            dump('-', old, alo, ahi)
-        elif tag == 'insert':
-            dump('+', new, blo, bhi)
-        elif tag == 'equal':
-            dump(' ', old, alo, ahi)
-        else:
-            raise AssertionError('unknown tag %r' % tag)
-    return "\n".join(diff)
-
-
-
-def test_suite():
-    suite = unittest.TestSuite()
-    suite.addTest(doctest.DocTestSuite('schoolbell.icalendar',
-                        optionflags=doctest.ELLIPSIS | doctest.REPORT_UDIFF))
-    suite.addTest(unittest.makeSuite(TestParseDateTime))
-    suite.addTest(unittest.makeSuite(TestPeriod))
-    suite.addTest(unittest.makeSuite(TestVEvent))
-    suite.addTest(unittest.makeSuite(TestICalReader))
-    return suite
-
-if __name__ == '__main__':
-    unittest.main(defaultTest='test_suite')

=== removed file 'lib/schoolbell/tests/test_schoolbell.py'
--- lib/schoolbell/tests/test_schoolbell.py	2005-10-31 18:29:12 +0000
+++ lib/schoolbell/tests/test_schoolbell.py	1970-01-01 00:00:00 +0000
@@ -1,74 +0,0 @@
-"""
-Unit tests for schoolbell
-
-When this module grows too big, it will be split into a number of modules in
-a package called tests.  Each of those new modules will be named test_foo.py
-and will test schoolbell.foo.
-"""
-
-import unittest
-from zope.testing import doctest
-
-
-def doctest_interfaces():
-    """Look for syntax errors in interfaces.py
-
-        >>> import schoolbell.interfaces
-
-    """
-
-
-def doctest_simple_CalendarEventMixin_replace():
-    """Make sure CalendarEventMixin.replace does not forget any attributes.
-
-        >>> from schoolbell.interfaces import ICalendarEvent
-        >>> from zope.schema import getFieldNames
-        >>> all_attrs = getFieldNames(ICalendarEvent)
-
-    We will use SimpleCalendarEvent which is a trivial subclass of
-    CalendarEventMixin
-
-        >>> from datetime import datetime, timedelta
-        >>> from schoolbell.simple import SimpleCalendarEvent
-        >>> e1 = SimpleCalendarEvent(datetime(2004, 12, 15, 18, 57),
-        ...                          timedelta(minutes=15),
-        ...                          'Work on schoolbell.simple')
-
-        >>> for attr in all_attrs:
-        ...     e2 = e1.replace(**{attr: 'new value'})
-        ...     assert getattr(e2, attr) == 'new value', attr
-        ...     assert e2 != e1, attr
-        ...     assert e2.replace(**{attr: getattr(e1, attr)}) == e1, attr
-
-    """
-
-
-def doctest_weeknum_bounds():
-    """Unit test for schoolbell.utils.weeknum_bounds.
-
-    Check that weeknum_bounds is the reverse of datetime.isocalendar().
-
-        >>> from datetime import date
-        >>> from schoolbell.utils import weeknum_bounds
-        >>> d = date(2000, 1, 1)
-        >>> while d < date(2010, 1, 1):
-        ...     year, weeknum, weekday = d.isocalendar()
-        ...     l, h = weeknum_bounds(year, weeknum)
-        ...     assert l <= d <= h
-        ...     d += d.resolution
-
-    """
-
-
-def test_suite():
-    suite = unittest.TestSuite()
-    suite.addTest(doctest.DocTestSuite())
-    suite.addTest(doctest.DocTestSuite('schoolbell.mixins'))
-    suite.addTest(doctest.DocTestSuite('schoolbell.simple'))
-    suite.addTest(doctest.DocTestSuite('schoolbell.utils'))
-    suite.addTest(doctest.DocTestSuite('schoolbell.browser',
-                        optionflags=doctest.ELLIPSIS | doctest.REPORT_UDIFF))
-    return suite
-
-if __name__ == '__main__':
-    unittest.main(defaultTest='test_suite')

=== removed file 'lib/schoolbell/utils.py'
--- lib/schoolbell/utils.py	2005-10-31 18:29:12 +0000
+++ lib/schoolbell/utils.py	1970-01-01 00:00:00 +0000
@@ -1,164 +0,0 @@
-"""
-Utility functions for SchoolBell.
-
-These include various date manipulation routines.
-"""
-
-import calendar
-from datetime import datetime, date, timedelta, tzinfo
-
-
-def prev_month(date):
-    """Calculate the first day of the previous month for a given date.
-
-        >>> prev_month(date(2004, 8, 1))
-        datetime.date(2004, 7, 1)
-        >>> prev_month(date(2004, 8, 31))
-        datetime.date(2004, 7, 1)
-        >>> prev_month(date(2004, 12, 15))
-        datetime.date(2004, 11, 1)
-        >>> prev_month(date(2005, 1, 28))
-        datetime.date(2004, 12, 1)
-
-    """
-    return (date.replace(day=1) - timedelta(1)).replace(day=1)
-
-
-def next_month(date):
-    """Calculate the first day of the next month for a given date.
-
-        >>> next_month(date(2004, 8, 1))
-        datetime.date(2004, 9, 1)
-        >>> next_month(date(2004, 8, 31))
-        datetime.date(2004, 9, 1)
-        >>> next_month(date(2004, 12, 15))
-        datetime.date(2005, 1, 1)
-        >>> next_month(date(2004, 2, 28))
-        datetime.date(2004, 3, 1)
-        >>> next_month(date(2004, 2, 29))
-        datetime.date(2004, 3, 1)
-        >>> next_month(date(2005, 2, 28))
-        datetime.date(2005, 3, 1)
-
-    """
-    return (date.replace(day=28) + timedelta(7)).replace(day=1)
-
-
-def week_start(date, first_day_of_week=0):
-    """Calculate the first day of the week for a given date.
-
-    Assuming that week starts on Mondays:
-
-        >>> week_start(date(2004, 8, 19))
-        datetime.date(2004, 8, 16)
-        >>> week_start(date(2004, 8, 15))
-        datetime.date(2004, 8, 9)
-        >>> week_start(date(2004, 8, 14))
-        datetime.date(2004, 8, 9)
-        >>> week_start(date(2004, 8, 21))
-        datetime.date(2004, 8, 16)
-        >>> week_start(date(2004, 8, 22))
-        datetime.date(2004, 8, 16)
-        >>> week_start(date(2004, 8, 23))
-        datetime.date(2004, 8, 23)
-
-    Assuming that week starts on Sundays:
-
-        >>> import calendar
-        >>> week_start(date(2004, 8, 19), calendar.SUNDAY)
-        datetime.date(2004, 8, 15)
-        >>> week_start(date(2004, 8, 15), calendar.SUNDAY)
-        datetime.date(2004, 8, 15)
-        >>> week_start(date(2004, 8, 14), calendar.SUNDAY)
-        datetime.date(2004, 8, 8)
-        >>> week_start(date(2004, 8, 21), calendar.SUNDAY)
-        datetime.date(2004, 8, 15)
-        >>> week_start(date(2004, 8, 22), calendar.SUNDAY)
-        datetime.date(2004, 8, 22)
-        >>> week_start(date(2004, 8, 23), calendar.SUNDAY)
-        datetime.date(2004, 8, 22)
-
-    """
-    assert 0 <= first_day_of_week < 7
-    delta = date.weekday() - first_day_of_week
-    if delta < 0:
-        delta += 7
-    return date - timedelta(delta)
-
-
-def weeknum_bounds(year, weeknum):
-    """Calculate the inclusive date bounds for a (year, weeknum) tuple.
-
-    Week numbers are as defined in ISO 8601 and returned by
-    datetime.date.isocalendar().
-
-        >>> weeknum_bounds(2003, 52)
-        (datetime.date(2003, 12, 22), datetime.date(2003, 12, 28))
-        >>> weeknum_bounds(2004, 1)
-        (datetime.date(2003, 12, 29), datetime.date(2004, 1, 4))
-        >>> weeknum_bounds(2004, 2)
-        (datetime.date(2004, 1, 5), datetime.date(2004, 1, 11))
-
-    """
-    # The first week of a year is at least 4 days long, so January 4th
-    # is in the first week.
-    firstweek = week_start(date(year, 1, 4), calendar.MONDAY)
-    # move forward to the right week number
-    weekstart = firstweek + timedelta(weeks=weeknum-1)
-    weekend = weekstart + timedelta(days=6)
-    return (weekstart, weekend)
-
-
-def check_weeknum(year, weeknum):
-    """Check to see whether a (year, weeknum) tuple refers to a real
-    ISO week number.
-
-        >>> check_weeknum(2004, 1)
-        True
-        >>> check_weeknum(2004, 53)
-        True
-        >>> check_weeknum(2004, 0)
-        False
-        >>> check_weeknum(2004, 54)
-        False
-        >>> check_weeknum(2003, 52)
-        True
-        >>> check_weeknum(2003, 53)
-        False
-
-    """
-    weekstart, weekend = weeknum_bounds(year, weeknum)
-    isoyear, isoweek, isoday = weekstart.isocalendar()
-    return (year, weeknum) == (isoyear, isoweek)
-
-class Slots(dict):
-    """A dict with automatic key selection.
-
-    The add method automatically selects the lowest unused numeric key
-    (starting from 0).
-
-    Example:
-
-      >>> s = Slots()
-      >>> s.add("first")
-      >>> s
-      {0: 'first'}
-
-      >>> s.add("second")
-      >>> s
-      {0: 'first', 1: 'second'}
-
-    The keys can be reused:
-
-      >>> del s[0]
-      >>> s.add("third")
-      >>> s
-      {0: 'third', 1: 'second'}
-
-    """
-
-    def add(self, obj):
-        i = 0
-        while i in self:
-            i += 1
-        self[i] = obj