site reorg

21 files changed, 0 insertions, 1596 deletions

diff --git a/lib/taggit/__init__.py b/lib/taggit/__init__.py
deleted file mode 100644
index 3a055a1..0000000
--- a/lib/taggit/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-VERSION = (0, 9, 2)
diff --git a/lib/taggit/admin.py b/lib/taggit/admin.py
deleted file mode 100644
index 5155b6f..0000000
--- a/lib/taggit/admin.py
+++ /dev/null
@@ -1,16 +0,0 @@
-from django.contrib import admin
-
-from taggit.models import Tag, TaggedItem
-
-
-class TaggedItemInline(admin.StackedInline):
-    model = TaggedItem
-
-class TagAdmin(admin.ModelAdmin):
-    list_display = ["name"]
-    inlines = [
-        TaggedItemInline
-    ]
-
-
-admin.site.register(Tag, TagAdmin)
diff --git a/lib/taggit/forms.py b/lib/taggit/forms.py
deleted file mode 100644
index e0198bd..0000000
--- a/lib/taggit/forms.py
+++ /dev/null
@@ -1,21 +0,0 @@
-from django import forms
-from django.utils.translation import ugettext as _
-
-from taggit.utils import parse_tags, edit_string_for_tags
-
-
-class TagWidget(forms.TextInput):
-    def render(self, name, value, attrs=None):
-        if value is not None and not isinstance(value, basestring):
-            value = edit_string_for_tags([o.tag for o in value.select_related("tag")])
-        return super(TagWidget, self).render(name, value, attrs)
-
-class TagField(forms.CharField):
-    widget = TagWidget
-
-    def clean(self, value):
-        value = super(TagField, self).clean(value)
-        try:
-            return parse_tags(value)
-        except ValueError:
-            raise forms.ValidationError(_("Please provide a comma-separated list of tags."))
diff --git a/lib/taggit/locale/de/LC_MESSAGES/django.mo b/lib/taggit/locale/de/LC_MESSAGES/django.mo
deleted file mode 100644
index 3d9eaaf..0000000
--- a/lib/taggit/locale/de/LC_MESSAGES/django.mo
+++ /dev/null
diff --git a/lib/taggit/locale/de/LC_MESSAGES/django.po b/lib/taggit/locale/de/LC_MESSAGES/django.po
deleted file mode 100644
index 98ecdac..0000000
--- a/lib/taggit/locale/de/LC_MESSAGES/django.po
+++ /dev/null
@@ -1,67 +0,0 @@
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: django-taggit\n"
-"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2010-09-07 09:26-0700\n"
-"PO-Revision-Date: 2010-09-07 09:26-0700\n"
-"Last-Translator: Jannis Leidel <jannis@leidel.info>\n"
-"Language-Team: German <de@li.org>\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=2; plural=(n != 1)\n"
-
-#: forms.py:20
-msgid "Please provide a comma-separated list of tags."
-msgstr "Bitte eine durch Komma getrennte Schlagwortliste eingeben."
-
-#: managers.py:39 managers.py:83 models.py:50
-msgid "Tags"
-msgstr "Schlagwörter"
-
-#: managers.py:84
-msgid "A comma-separated list of tags."
-msgstr "Eine durch Komma getrennte Schlagwortliste."
-
-#: models.py:10
-msgid "Name"
-msgstr "Name"
-
-#: models.py:11
-msgid "Slug"
-msgstr "Kürzel"
-
-#: models.py:49
-msgid "Tag"
-msgstr "Schlagwort"
-
-#: models.py:56
-#, python-format
-msgid "%(object)s tagged with %(tag)s"
-msgstr "%(object)s verschlagwortet mit %(tag)s"
-
-#: models.py:100
-msgid "Object id"
-msgstr "Objekt-ID"
-
-#: models.py:104 models.py:110
-msgid "Content type"
-msgstr "Inhaltstyp"
-
-#: models.py:138
-msgid "Tagged Item"
-msgstr "Verschlagwortetes Objekt"
-
-#: models.py:139
-msgid "Tagged Items"
-msgstr "Verschlagwortete Objekte"
-
-#: contrib/suggest/models.py:57
-msgid ""
-"Enter a valid Regular Expression. To make it case-insensitive include \"(?i)"
-"\" in your expression."
-msgstr ""
-"Bitte einen regulären Ausdruck eingeben. Fügen Sie \"(?i) \" dem "
-"Ausdruck hinzu, um nicht zwischen Groß- und Kleinschreibung zu "
-"unterscheiden."
diff --git a/lib/taggit/locale/en/LC_MESSAGES/django.po b/lib/taggit/locale/en/LC_MESSAGES/django.po
deleted file mode 100644
index c5642c7..0000000
--- a/lib/taggit/locale/en/LC_MESSAGES/django.po
+++ /dev/null
@@ -1,68 +0,0 @@
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#
-#, fuzzy
-msgid ""
-msgstr ""
-"Project-Id-Version: PACKAGE VERSION\n"
-"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2010-09-07 09:45-0700\n"
-"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
-"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-#: forms.py:20
-msgid "Please provide a comma-separated list of tags."
-msgstr ""
-
-#: managers.py:39 managers.py:83 models.py:50
-msgid "Tags"
-msgstr ""
-
-#: managers.py:84
-msgid "A comma-separated list of tags."
-msgstr ""
-
-#: models.py:10
-msgid "Name"
-msgstr ""
-
-#: models.py:11
-msgid "Slug"
-msgstr ""
-
-#: models.py:49
-msgid "Tag"
-msgstr ""
-
-#: models.py:56
-#, python-format
-msgid "%(object)s tagged with %(tag)s"
-msgstr ""
-
-#: models.py:100
-msgid "Object id"
-msgstr ""
-
-#: models.py:104 models.py:110
-msgid "Content type"
-msgstr ""
-
-#: models.py:138
-msgid "Tagged Item"
-msgstr ""
-
-#: models.py:139
-msgid "Tagged Items"
-msgstr ""
-
-#: contrib/suggest/models.py:57
-msgid ""
-"Enter a valid Regular Expression. To make it case-insensitive include \"(?i)"
-"\" in your expression."
-msgstr ""
diff --git a/lib/taggit/locale/he/LC_MESSAGES/django.mo b/lib/taggit/locale/he/LC_MESSAGES/django.mo
deleted file mode 100644
index 562db71..0000000
--- a/lib/taggit/locale/he/LC_MESSAGES/django.mo
+++ /dev/null
diff --git a/lib/taggit/locale/he/LC_MESSAGES/django.po b/lib/taggit/locale/he/LC_MESSAGES/django.po
deleted file mode 100644
index e27a878..0000000
--- a/lib/taggit/locale/he/LC_MESSAGES/django.po
+++ /dev/null
@@ -1,69 +0,0 @@
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#
-msgid ""
-msgstr ""
-"Project-Id-Version: Django Taggit\n"
-"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2010-06-26 12:47-0500\n"
-"PO-Revision-Date: 2010-06-26 12:54-0600\n"
-"Last-Translator: Alex <alex.gaynor@gmail.com>\n"
-"Language-Team: LANGUAGE <LL@li.org>\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=2; plural=(n != 1);\n"
-
-#: forms.py:20
-msgid "Please provide a comma-separated list of tags."
-msgstr "נא לספק רשימה של תגים מופרדת עם פסיקים."
-
-#: managers.py:41
-#: managers.py:113
-#: models.py:18
-msgid "Tags"
-msgstr "תגיות"
-
-#: managers.py:114
-msgid "A comma-separated list of tags."
-msgstr "רשימה של תגים מופרדת עם פסיקים."
-
-#: models.py:10
-msgid "Name"
-msgstr "שם"
-
-#: models.py:11
-msgid "Slug"
-msgstr ""
-
-#: models.py:17
-msgid "Tag"
-msgstr "תג"
-
-#: models.py:56
-#, python-format
-msgid "%(object)s tagged with %(tag)s"
-msgstr "%(object)s מתויג עם %(tag)s"
-
-#: models.py:86
-msgid "Object id"
-msgstr ""
-
-#: models.py:87
-msgid "Content type"
-msgstr ""
-
-#: models.py:92
-msgid "Tagged Item"
-msgstr ""
-
-#: models.py:93
-msgid "Tagged Items"
-msgstr ""
-
-#: contrib/suggest/models.py:57
-msgid "Enter a valid Regular Expression. To make it case-insensitive include \"(?i)\" in your expression."
-msgstr ""
-
diff --git a/lib/taggit/locale/nl/LC_MESSAGES/django.mo b/lib/taggit/locale/nl/LC_MESSAGES/django.mo
deleted file mode 100644
index 28e7b7e..0000000
--- a/lib/taggit/locale/nl/LC_MESSAGES/django.mo
+++ /dev/null
diff --git a/lib/taggit/locale/nl/LC_MESSAGES/django.po b/lib/taggit/locale/nl/LC_MESSAGES/django.po
deleted file mode 100644
index 7871b0b..0000000
--- a/lib/taggit/locale/nl/LC_MESSAGES/django.po
+++ /dev/null
@@ -1,64 +0,0 @@
-msgid ""
-msgstr ""
-"Project-Id-Version: django-taggit\n"
-"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2010-09-07 09:45-0700\n"
-"PO-Revision-Date: 2010-09-07 23:04+0100\n"
-"Last-Translator: Jeffrey Gelens <jeffrey@gelens.org>\n"
-"Language-Team: Dutch\n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-
-#: forms.py:20
-msgid "Please provide a comma-separated list of tags."
-msgstr "Geef een door komma gescheiden lijst van tags."
-
-#: managers.py:39
-#: managers.py:83
-#: models.py:50
-msgid "Tags"
-msgstr "Tags"
-
-#: managers.py:84
-msgid "A comma-separated list of tags."
-msgstr "Een door komma gescheiden lijst van tags."
-
-#: models.py:10
-msgid "Name"
-msgstr "Naam"
-
-#: models.py:11
-msgid "Slug"
-msgstr "Slug"
-
-#: models.py:49
-msgid "Tag"
-msgstr "Tag"
-
-#: models.py:56
-#, python-format
-msgid "%(object)s tagged with %(tag)s"
-msgstr "%(object)s getagged met %(tag)s"
-
-#: models.py:100
-msgid "Object id"
-msgstr "Object-id"
-
-#: models.py:104
-#: models.py:110
-msgid "Content type"
-msgstr "Inhoudstype"
-
-#: models.py:138
-msgid "Tagged Item"
-msgstr "Object getagged"
-
-#: models.py:139
-msgid "Tagged Items"
-msgstr "Objecten getagged"
-
-#: contrib/suggest/models.py:57
-msgid "Enter a valid Regular Expression. To make it case-insensitive include \"(?i)\" in your expression."
-msgstr "Voer een valide reguliere expressie in. Voeg \"(?i)\" aan de expressie toe om deze hoofdletter ongevoelig te maken."
-
diff --git a/lib/taggit/locale/ru/LC_MESSAGES/django.mo b/lib/taggit/locale/ru/LC_MESSAGES/django.mo
deleted file mode 100644
index 61a7e39..0000000
--- a/lib/taggit/locale/ru/LC_MESSAGES/django.mo
+++ /dev/null
diff --git a/lib/taggit/locale/ru/LC_MESSAGES/django.po b/lib/taggit/locale/ru/LC_MESSAGES/django.po
deleted file mode 100644
index 42e3ebe..0000000
--- a/lib/taggit/locale/ru/LC_MESSAGES/django.po
+++ /dev/null
@@ -1,70 +0,0 @@
-# SOME DESCRIPTIVE TITLE.
-# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
-# This file is distributed under the same license as the PACKAGE package.
-# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
-#
-msgid ""
-msgstr ""
-"Project-Id-Version: Django Taggit\n"
-"Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2010-06-11 11:28+0700\n"
-"PO-Revision-Date: 2010-06-11 11:30+0700\n"
-"Last-Translator: Igor 'idle sign' Starikov <idlesign@yandex.ru>\n"
-"Language-Team: \n"
-"MIME-Version: 1.0\n"
-"Content-Type: text/plain; charset=UTF-8\n"
-"Content-Transfer-Encoding: 8bit\n"
-"Plural-Forms: nplurals=3; plural=n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2;\n"
-"X-Poedit-Language: Russian\n"
-
-#: forms.py:20
-msgid "Please provide a comma-separated list of tags."
-msgstr "Укажите метки через запятую."
-
-#: managers.py:41
-#: managers.py:101
-#: models.py:17
-msgid "Tags"
-msgstr "Метки"
-
-#: managers.py:102
-msgid "A comma-separated list of tags."
-msgstr "Список меток через запятую."
-
-#: models.py:9
-msgid "Name"
-msgstr "Название"
-
-#: models.py:10
-msgid "Slug"
-msgstr "Слаг"
-
-#: models.py:16
-msgid "Tag"
-msgstr "Метка"
-
-#: models.py:55
-#, python-format
-msgid "%(object)s tagged with %(tag)s"
-msgstr "элемент «%(object)s» с меткой «%(tag)s»"
-
-#: models.py:82
-msgid "Object id"
-msgstr "ID объекта"
-
-#: models.py:83
-msgid "Content type"
-msgstr "Тип содержимого"
-
-#: models.py:87
-msgid "Tagged Item"
-msgstr "Элемент с меткой"
-
-#: models.py:88
-msgid "Tagged Items"
-msgstr "Элементы с меткой"
-
-#: contrib/suggest/models.py:57
-msgid "Enter a valid Regular Expression. To make it case-insensitive include \"(?i)\" in your expression."
-msgstr "Введите регулярное выражение. Чтобы сделать его чувствительным к регистру укажите \"(?i)\"."
-
diff --git a/lib/taggit/managers.py b/lib/taggit/managers.py
deleted file mode 100644
index 55201b4..0000000
--- a/lib/taggit/managers.py
+++ /dev/null
@@ -1,244 +0,0 @@
-from django.contrib.contenttypes.generic import GenericRelation
-from django.contrib.contenttypes.models import ContentType
-from django.db import models
-from django.db.models.fields.related import ManyToManyRel, RelatedField, add_lazy_relation
-from django.db.models.related import RelatedObject
-from django.utils.text import capfirst
-from django.utils.translation import ugettext_lazy as _
-
-from taggit.forms import TagField
-from taggit.models import TaggedItem, GenericTaggedItemBase
-from taggit.utils import require_instance_manager
-
-
-try:
-    all
-except NameError:
-    # 2.4 compat
-    try:
-        from django.utils.itercompat import all
-    except ImportError:
-        # 1.1.X compat
-        def all(iterable):
-            for item in iterable:
-                if not item:
-                    return False
-            return True
-
-
-class TaggableRel(ManyToManyRel):
-    def __init__(self):
-        self.related_name = None
-        self.limit_choices_to = {}
-        self.symmetrical = True
-        self.multiple = True
-        self.through = None
-
-
-class TaggableManager(RelatedField):
-    def __init__(self, verbose_name=_("Tags"),
-        help_text=_("A comma-separated list of tags."), through=None, blank=False):
-        self.through = through or TaggedItem
-        self.rel = TaggableRel()
-        self.verbose_name = verbose_name
-        self.help_text = help_text
-        self.blank = blank
-        self.editable = True
-        self.unique = False
-        self.creates_table = False
-        self.db_column = None
-        self.choices = None
-        self.serialize = False
-        self.null = True
-        self.creation_counter = models.Field.creation_counter
-        models.Field.creation_counter += 1
-
-    def __get__(self, instance, model):
-        if instance is not None and instance.pk is None:
-            raise ValueError("%s objects need to have a primary key value "
-                "before you can access their tags." % model.__name__)
-        manager = _TaggableManager(
-            through=self.through, model=model, instance=instance
-        )
-        return manager
-
-    def contribute_to_class(self, cls, name):
-        self.name = self.column = name
-        self.model = cls
-        cls._meta.add_field(self)
-        setattr(cls, name, self)
-        if not cls._meta.abstract:
-            if isinstance(self.through, basestring):
-                def resolve_related_class(field, model, cls):
-                    self.through = model
-                    self.post_through_setup(cls)
-                add_lazy_relation(
-                    cls, self, self.through, resolve_related_class
-                )
-            else:
-                self.post_through_setup(cls)
-
-    def post_through_setup(self, cls):
-        self.use_gfk = (
-            self.through is None or issubclass(self.through, GenericTaggedItemBase)
-        )
-        self.rel.to = self.through._meta.get_field("tag").rel.to
-        if self.use_gfk:
-            tagged_items = GenericRelation(self.through)
-            tagged_items.contribute_to_class(cls, "tagged_items")
-
-    def save_form_data(self, instance, value):
-        getattr(instance, self.name).set(*value)
-
-    def formfield(self, form_class=TagField, **kwargs):
-        defaults = {
-            "label": capfirst(self.verbose_name),
-            "help_text": self.help_text,
-            "required": not self.blank
-        }
-        defaults.update(kwargs)
-        return form_class(**defaults)
-
-    def value_from_object(self, instance):
-        if instance.pk:
-            return self.through.objects.filter(**self.through.lookup_kwargs(instance))
-        return self.through.objects.none()
-
-    def related_query_name(self):
-        return self.model._meta.module_name
-
-    def m2m_reverse_name(self):
-        return self.through._meta.get_field_by_name("tag")[0].column
-
-    def m2m_target_field_name(self):
-        return self.model._meta.pk.name
-
-    def m2m_reverse_target_field_name(self):
-        return self.rel.to._meta.pk.name
-
-    def m2m_column_name(self):
-        if self.use_gfk:
-            return self.through._meta.virtual_fields[0].fk_field
-        return self.through._meta.get_field('content_object').column
-
-    def db_type(self, connection=None):
-        return None
-
-    def m2m_db_table(self):
-        return self.through._meta.db_table
-
-    def extra_filters(self, pieces, pos, negate):
-        if negate or not self.use_gfk:
-            return []
-        prefix = "__".join(["tagged_items"] + pieces[:pos-2])
-        cts = map(ContentType.objects.get_for_model, _get_subclasses(self.model))
-        if len(cts) == 1:
-            return [("%s__content_type" % prefix, cts[0])]
-        return [("%s__content_type__in" % prefix, cts)]
-
-    def bulk_related_objects(self, new_objs, using):
-        return []
-
-
-class _TaggableManager(models.Manager):
-    def __init__(self, through, model, instance):
-        self.through = through
-        self.model = model
-        self.instance = instance
-
-    def get_query_set(self):
-        return self.through.tags_for(self.model, self.instance)
-
-    def _lookup_kwargs(self):
-        return self.through.lookup_kwargs(self.instance)
-
-    @require_instance_manager
-    def add(self, *tags):
-        str_tags = set([
-            t
-            for t in tags
-            if not isinstance(t, self.through.tag_model())
-        ])
-        tag_objs = set(tags) - str_tags
-        # If str_tags has 0 elements Django actually optimizes that to not do a
-        # query.  Malcolm is very smart.
-        existing = self.through.tag_model().objects.filter(
-            name__in=str_tags
-        )
-        tag_objs.update(existing)
-
-        for new_tag in str_tags - set(t.name for t in existing):
-            tag_objs.add(self.through.tag_model().objects.create(name=new_tag))
-
-        for tag in tag_objs:
-            self.through.objects.get_or_create(tag=tag, **self._lookup_kwargs())
-
-    @require_instance_manager
-    def set(self, *tags):
-        self.clear()
-        self.add(*tags)
-
-    @require_instance_manager
-    def remove(self, *tags):
-        self.through.objects.filter(**self._lookup_kwargs()).filter(
-            tag__name__in=tags).delete()
-
-    @require_instance_manager
-    def clear(self):
-        self.through.objects.filter(**self._lookup_kwargs()).delete()
-
-    def most_common(self):
-        return self.get_query_set().annotate(
-            num_times=models.Count(self.through.tag_relname())
-        ).order_by('-num_times')
-
-    @require_instance_manager
-    def similar_objects(self):
-        lookup_kwargs = self._lookup_kwargs()
-        lookup_keys = sorted(lookup_kwargs)
-        qs = self.through.objects.values(*lookup_kwargs.keys())
-        qs = qs.annotate(n=models.Count('pk'))
-        qs = qs.exclude(**lookup_kwargs)
-        qs = qs.filter(tag__in=self.all())
-        qs = qs.order_by('-n')
-
-        # TODO: This all feels like a bit of a hack.
-        items = {}
-        if len(lookup_keys) == 1:
-            # Can we do this without a second query by using a select_related()
-            # somehow?
-            f = self.through._meta.get_field_by_name(lookup_keys[0])[0]
-            objs = f.rel.to._default_manager.filter(**{
-                "%s__in" % f.rel.field_name: [r["content_object"] for r in qs]
-            })
-            for obj in objs:
-                items[(getattr(obj, f.rel.field_name),)] = obj
-        else:
-            preload = {}
-            for result in qs:
-                preload.setdefault(result['content_type'], set())
-                preload[result["content_type"]].add(result["object_id"])
-
-            for ct, obj_ids in preload.iteritems():
-                ct = ContentType.objects.get_for_id(ct)
-                for obj in ct.model_class()._default_manager.filter(pk__in=obj_ids):
-                    items[(ct.pk, obj.pk)] = obj
-
-        results = []
-        for result in qs:
-            obj = items[
-                tuple(result[k] for k in lookup_keys)
-            ]
-            obj.similar_tags = result["n"]
-            results.append(obj)
-        return results
-
-
-def _get_subclasses(model):
-    subclasses = [model]
-    for f in model._meta.get_all_field_names():
-        field = model._meta.get_field_by_name(f)[0]
-        if (isinstance(field, RelatedObject) and
-            getattr(field.field.rel, "parent_link", None)):
-            subclasses.extend(_get_subclasses(field.model))
-    return subclasses
diff --git a/lib/taggit/models.py b/lib/taggit/models.py
deleted file mode 100644
index d8a0a41..0000000
--- a/lib/taggit/models.py
+++ /dev/null
@@ -1,160 +0,0 @@
-import django
-from django.contrib.contenttypes.models import ContentType
-from django.contrib.contenttypes.generic import GenericForeignKey
-from django.db import models, IntegrityError, transaction
-from django.template.defaultfilters import slugify as default_slugify
-from django.utils.translation import ugettext_lazy as _, ugettext
-
-
-class TagBase(models.Model):
-    name = models.CharField(verbose_name=_('Name'), max_length=100)
-    slug = models.SlugField(verbose_name=_('Slug'), unique=True, max_length=100)
-
-    def __unicode__(self):
-        return self.name
-
-    class Meta:
-        abstract = True
-
-    def save(self, *args, **kwargs):
-        if not self.pk and not self.slug:
-            self.slug = self.slugify(self.name)
-            if django.VERSION >= (1, 2):
-                from django.db import router
-                using = kwargs.get("using") or router.db_for_write(
-                    type(self), instance=self)
-                # Make sure we write to the same db for all attempted writes,
-                # with a multi-master setup, theoretically we could try to
-                # write and rollback on different DBs
-                kwargs["using"] = using
-                trans_kwargs = {"using": using}
-            else:
-                trans_kwargs = {}
-            i = 0
-            while True:
-                i += 1
-                try:
-                    sid = transaction.savepoint(**trans_kwargs)
-                    res = super(TagBase, self).save(*args, **kwargs)
-                    transaction.savepoint_commit(sid, **trans_kwargs)
-                    return res
-                except IntegrityError:
-                    transaction.savepoint_rollback(sid, **trans_kwargs)
-                    self.slug = self.slugify(self.name, i)
-        else:
-            return super(TagBase, self).save(*args, **kwargs)
-
-    def slugify(self, tag, i=None):
-        slug = default_slugify(tag)
-        if i is not None:
-            slug += "_%d" % i
-        return slug
-
-
-class Tag(TagBase):
-    class Meta:
-        verbose_name = _("Tag")
-        verbose_name_plural = _("Tags")
-
-
-
-class ItemBase(models.Model):
-    def __unicode__(self):
-        return ugettext("%(object)s tagged with %(tag)s") % {
-            "object": self.content_object,
-            "tag": self.tag
-        }
-
-    class Meta:
-        abstract = True
-
-    @classmethod
-    def tag_model(cls):
-        return cls._meta.get_field_by_name("tag")[0].rel.to
-
-    @classmethod
-    def tag_relname(cls):
-        return cls._meta.get_field_by_name('tag')[0].rel.related_name
-
-    @classmethod
-    def lookup_kwargs(cls, instance):
-        return {
-            'content_object': instance
-        }
-
-    @classmethod
-    def bulk_lookup_kwargs(cls, instances):
-        return {
-            "content_object__in": instances,
-        }
-
-
-class TaggedItemBase(ItemBase):
-    if django.VERSION < (1, 2):
-        tag = models.ForeignKey(Tag, related_name="%(class)s_items")
-    else:
-        tag = models.ForeignKey(Tag, related_name="%(app_label)s_%(class)s_items")
-
-    class Meta:
-        abstract = True
-
-    @classmethod
-    def tags_for(cls, model, instance=None):
-        if instance is not None:
-            return cls.tag_model().objects.filter(**{
-                '%s__content_object' % cls.tag_relname(): instance
-            })
-        return cls.tag_model().objects.filter(**{
-            '%s__content_object__isnull' % cls.tag_relname(): False
-        }).distinct()
-
-
-class GenericTaggedItemBase(ItemBase):
-    object_id = models.IntegerField(verbose_name=_('Object id'), db_index=True)
-    if django.VERSION < (1, 2):
-        content_type = models.ForeignKey(
-            ContentType,
-            verbose_name=_('Content type'),
-            related_name="%(class)s_tagged_items"
-        )
-    else:
-        content_type = models.ForeignKey(
-            ContentType,
-            verbose_name=_('Content type'),
-            related_name="%(app_label)s_%(class)s_tagged_items"
-        )
-    content_object = GenericForeignKey()
-
-    class Meta:
-        abstract=True
-
-    @classmethod
-    def lookup_kwargs(cls, instance):
-        return {
-            'object_id': instance.pk,
-            'content_type': ContentType.objects.get_for_model(instance)
-        }
-
-    @classmethod
-    def bulk_lookup_kwargs(cls, instances):
-        # TODO: instances[0], can we assume there are instances.
-        return {
-            "object_id__in": [instance.pk for instance in instances],
-            "content_type": ContentType.objects.get_for_model(instances[0]),
-        }
-
-    @classmethod
-    def tags_for(cls, model, instance=None):
-        ct = ContentType.objects.get_for_model(model)
-        kwargs = {
-            "%s__content_type" % cls.tag_relname(): ct
-        }
-        if instance is not None:
-            kwargs["%s__object_id" % cls.tag_relname()] = instance.pk
-        return cls.tag_model().objects.filter(**kwargs).distinct()
-
-
-class TaggedItem(GenericTaggedItemBase, TaggedItemBase):
-    class Meta:
-        verbose_name = _("Tagged Item")
-        verbose_name_plural = _("Tagged Items")
diff --git a/lib/taggit/tests/__init__.py b/lib/taggit/tests/__init__.py
deleted file mode 100644
index e69de29..0000000
--- a/lib/taggit/tests/__init__.py
+++ /dev/null
diff --git a/lib/taggit/tests/forms.py b/lib/taggit/tests/forms.py
deleted file mode 100644
index 2cdc6a8..0000000
--- a/lib/taggit/tests/forms.py
+++ /dev/null
@@ -1,20 +0,0 @@
-from django import forms
-
-from taggit.tests.models import Food, DirectFood, CustomPKFood, OfficialFood
-
-
-class FoodForm(forms.ModelForm):
-    class Meta:
-        model = Food
-
-class DirectFoodForm(forms.ModelForm):
-    class Meta:
-        model = DirectFood
-
-class CustomPKFoodForm(forms.ModelForm):
-    class Meta:
-        model = CustomPKFood
-
-class OfficialFoodForm(forms.ModelForm):
-    class Meta:
-        model = OfficialFood
diff --git a/lib/taggit/tests/models.py b/lib/taggit/tests/models.py
deleted file mode 100644
index a0e21e0..0000000
--- a/lib/taggit/tests/models.py
+++ /dev/null
@@ -1,143 +0,0 @@
-from django.db import models
-
-from taggit.managers import TaggableManager
-from taggit.models import (TaggedItemBase, GenericTaggedItemBase, TaggedItem,
-    TagBase, Tag)
-
-
-class Food(models.Model):
-    name = models.CharField(max_length=50)
-
-    tags = TaggableManager()
-
-    def __unicode__(self):
-        return self.name
-
-class Pet(models.Model):
-    name = models.CharField(max_length=50)
-
-    tags = TaggableManager()
-
-    def __unicode__(self):
-        return self.name
-
-class HousePet(Pet):
-    trained = models.BooleanField()
-
-
-# Test direct-tagging with custom through model
-
-class TaggedFood(TaggedItemBase):
-    content_object = models.ForeignKey('DirectFood')
-
-class TaggedPet(TaggedItemBase):
-    content_object = models.ForeignKey('DirectPet')
-
-class DirectFood(models.Model):
-    name = models.CharField(max_length=50)
-
-    tags = TaggableManager(through="TaggedFood")
-
-class DirectPet(models.Model):
-    name = models.CharField(max_length=50)
-
-    tags = TaggableManager(through=TaggedPet)
-
-    def __unicode__(self):
-        return self.name
-
-class DirectHousePet(DirectPet):
-    trained = models.BooleanField()
-
-
-# Test custom through model to model with custom PK
-
-class TaggedCustomPKFood(TaggedItemBase):
-    content_object = models.ForeignKey('CustomPKFood')
-
-class TaggedCustomPKPet(TaggedItemBase):
-    content_object = models.ForeignKey('CustomPKPet')
-
-class CustomPKFood(models.Model):
-    name = models.CharField(max_length=50, primary_key=True)
-
-    tags = TaggableManager(through=TaggedCustomPKFood)
-
-    def __unicode__(self):
-        return self.name
-
-class CustomPKPet(models.Model):
-    name = models.CharField(max_length=50, primary_key=True)
-
-    tags = TaggableManager(through=TaggedCustomPKPet)
-
-    def __unicode__(self):
-        return self.name
-
-class CustomPKHousePet(CustomPKPet):
-    trained = models.BooleanField()
-
-# Test custom through model to a custom tag model
-
-class OfficialTag(TagBase):
-    official = models.BooleanField()
-
-class OfficialThroughModel(GenericTaggedItemBase):
-    tag = models.ForeignKey(OfficialTag, related_name="tagged_items")
-
-class OfficialFood(models.Model):
-    name = models.CharField(max_length=50)
-
-    tags = TaggableManager(through=OfficialThroughModel)
-
-    def __unicode__(self):
-        return self.name
-
-class OfficialPet(models.Model):
-    name = models.CharField(max_length=50)
-
-    tags = TaggableManager(through=OfficialThroughModel)
-
-    def __unicode__(self):
-        return self.name
-
-class OfficialHousePet(OfficialPet):
-    trained = models.BooleanField()
-
-
-class Media(models.Model):
-    tags = TaggableManager()
-
-    class Meta:
-        abstract = True
-
-class Photo(Media):
-    pass
-
-class Movie(Media):
-    pass
-
-
-class ArticleTag(Tag):
-    class Meta:
-        proxy = True
-
-    def slugify(self, tag, i=None):
-        slug = "category-%s" % tag.lower()
-
-        if i is not None:
-            slug += "-%d" % i
-        return slug
-
-class ArticleTaggedItem(TaggedItem):
-    class Meta:
-        proxy = True
-
-    @classmethod
-    def tag_model(self):
-        return ArticleTag
-
-class Article(models.Model):
-    title = models.CharField(max_length=100)
-
-    tags = TaggableManager(through=ArticleTaggedItem)
diff --git a/lib/taggit/tests/runtests.py b/lib/taggit/tests/runtests.py
deleted file mode 100755
index 23bfb91..0000000
--- a/lib/taggit/tests/runtests.py
+++ /dev/null
@@ -1,34 +0,0 @@
-#!/usr/bin/env python
-import os
-import sys
-
-from django.conf import settings
-
-if not settings.configured:
-    settings.configure(
-        DATABASE_ENGINE='sqlite3',
-        INSTALLED_APPS=[
-            'django.contrib.contenttypes',
-            'taggit',
-            'taggit.tests',
-        ]
-    )
-
-from django.test.simple import run_tests
-
-
-def runtests(*test_args):
-    if not test_args:
-        test_args = ['tests']
-    parent = os.path.join(
-        os.path.dirname(os.path.abspath(__file__)),
-        "..",
-        "..",
-    )
-    sys.path.insert(0, parent)
-    failures = run_tests(test_args, verbosity=1, interactive=True)
-    sys.exit(failures)
-
-
-if __name__ == '__main__':
-    runtests(*sys.argv[1:])
diff --git a/lib/taggit/tests/tests.py b/lib/taggit/tests/tests.py
deleted file mode 100644
index e627701..0000000
--- a/lib/taggit/tests/tests.py
+++ /dev/null
@@ -1,475 +0,0 @@
-from unittest import TestCase as UnitTestCase
-
-import django
-from django.conf import settings
-from django.core.exceptions import ValidationError
-from django.db import connection
-from django.test import TestCase, TransactionTestCase
-
-from taggit.managers import TaggableManager
-from taggit.models import Tag, TaggedItem
-from taggit.tests.forms import (FoodForm, DirectFoodForm, CustomPKFoodForm,
-    OfficialFoodForm)
-from taggit.tests.models import (Food, Pet, HousePet, DirectFood, DirectPet,
-    DirectHousePet, TaggedPet, CustomPKFood, CustomPKPet, CustomPKHousePet,
-    TaggedCustomPKPet, OfficialFood, OfficialPet, OfficialHousePet,
-    OfficialThroughModel, OfficialTag, Photo, Movie, Article)
-from taggit.utils import parse_tags, edit_string_for_tags
-
-
-class BaseTaggingTest(object):
-    def assert_tags_equal(self, qs, tags, sort=True, attr="name"):
-        got = map(lambda tag: getattr(tag, attr), qs)
-        if sort:
-            got.sort()
-            tags.sort()
-        self.assertEqual(got, tags)
-
-    def assert_num_queries(self, n, f, *args, **kwargs):
-        original_DEBUG = settings.DEBUG
-        settings.DEBUG = True
-        current = len(connection.queries)
-        try:
-            f(*args, **kwargs)
-            self.assertEqual(
-                len(connection.queries) - current,
-                n,
-            )
-        finally:
-            settings.DEBUG = original_DEBUG
-
-    def _get_form_str(self, form_str):
-        if django.VERSION >= (1, 3):
-            form_str %= {
-                "help_start": '<span class="helptext">',
-                "help_stop": "</span>"
-            }
-        else:
-            form_str %= {
-                "help_start": "",
-                "help_stop": ""
-            }
-        return form_str
-
-    def assert_form_renders(self, form, html):
-        self.assertEqual(str(form), self._get_form_str(html))
-
-class BaseTaggingTestCase(TestCase, BaseTaggingTest):
-    pass
-
-class BaseTaggingTransactionTestCase(TransactionTestCase, BaseTaggingTest):
-    pass
-
-
-class TagModelTestCase(BaseTaggingTransactionTestCase):
-    food_model = Food
-    tag_model = Tag
-
-    def test_unique_slug(self):
-        apple = self.food_model.objects.create(name="apple")
-        apple.tags.add("Red", "red")
-
-    def test_update(self):
-        special = self.tag_model.objects.create(name="special")
-        special.save()
-
-    def test_add(self):
-        apple = self.food_model.objects.create(name="apple")
-        yummy = self.tag_model.objects.create(name="yummy")
-        apple.tags.add(yummy)
-
-    def test_slugify(self):
-        a = Article.objects.create(title="django-taggit 1.0 Released")
-        a.tags.add("awesome", "release", "AWESOME")
-        self.assert_tags_equal(a.tags.all(), [
-            "category-awesome",
-            "category-release",
-            "category-awesome-1"
-        ], attr="slug")
-
-class TagModelDirectTestCase(TagModelTestCase):
-    food_model = DirectFood
-    tag_model = Tag
-
-class TagModelCustomPKTestCase(TagModelTestCase):
-    food_model = CustomPKFood
-    tag_model = Tag
-
-class TagModelOfficialTestCase(TagModelTestCase):
-    food_model = OfficialFood
-    tag_model = OfficialTag
-
-class TaggableManagerTestCase(BaseTaggingTestCase):
-    food_model = Food
-    pet_model = Pet
-    housepet_model = HousePet
-    taggeditem_model = TaggedItem
-    tag_model = Tag
-
-    def test_add_tag(self):
-        apple = self.food_model.objects.create(name="apple")
-        self.assertEqual(list(apple.tags.all()), [])
-        self.assertEqual(list(self.food_model.tags.all()),  [])
-
-        apple.tags.add('green')
-        self.assert_tags_equal(apple.tags.all(), ['green'])
-        self.assert_tags_equal(self.food_model.tags.all(), ['green'])
-
-        pear = self.food_model.objects.create(name="pear")
-        pear.tags.add('green')
-        self.assert_tags_equal(pear.tags.all(), ['green'])
-        self.assert_tags_equal(self.food_model.tags.all(), ['green'])
-
-        apple.tags.add('red')
-        self.assert_tags_equal(apple.tags.all(), ['green', 'red'])
-        self.assert_tags_equal(self.food_model.tags.all(), ['green', 'red'])
-
-        self.assert_tags_equal(
-            self.food_model.tags.most_common(),
-            ['green', 'red'],
-            sort=False
-        )
-
-        apple.tags.remove('green')
-        self.assert_tags_equal(apple.tags.all(), ['red'])
-        self.assert_tags_equal(self.food_model.tags.all(), ['green', 'red'])
-        tag = self.tag_model.objects.create(name="delicious")
-        apple.tags.add(tag)
-        self.assert_tags_equal(apple.tags.all(), ["red", "delicious"])
-
-        apple.delete()
-        self.assert_tags_equal(self.food_model.tags.all(), ["green"])
-
-    def test_add_queries(self):
-        apple = self.food_model.objects.create(name="apple")
-        #   1 query to see which tags exist
-        # + 3 queries to create the tags.
-        # + 6 queries to create the intermediary things (including SELECTs, to
-        #     make sure we don't double create.
-        self.assert_num_queries(10, apple.tags.add, "red", "delicious", "green")
-
-        pear = self.food_model.objects.create(name="pear")
-        #   1 query to see which tags exist
-        # + 4 queries to create the intermeidary things (including SELECTs, to
-        #   make sure we dont't double create.
-        self.assert_num_queries(5, pear.tags.add, "green", "delicious")
-
-        self.assert_num_queries(0, pear.tags.add)
-
-    def test_require_pk(self):
-        food_instance = self.food_model()
-        self.assertRaises(ValueError, lambda: food_instance.tags.all())
-
-    def test_delete_obj(self):
-        apple = self.food_model.objects.create(name="apple")
-        apple.tags.add("red")
-        self.assert_tags_equal(apple.tags.all(), ["red"])
-        strawberry = self.food_model.objects.create(name="strawberry")
-        strawberry.tags.add("red")
-        apple.delete()
-        self.assert_tags_equal(strawberry.tags.all(), ["red"])
-
-    def test_delete_bulk(self):
-        apple = self.food_model.objects.create(name="apple")
-        kitty = self.pet_model.objects.create(pk=apple.pk,  name="kitty")
-
-        apple.tags.add("red", "delicious", "fruit")
-        kitty.tags.add("feline")
-
-        self.food_model.objects.all().delete()
-
-        self.assert_tags_equal(kitty.tags.all(), ["feline"])
-
-    def test_lookup_by_tag(self):
-        apple = self.food_model.objects.create(name="apple")
-        apple.tags.add("red", "green")
-        pear = self.food_model.objects.create(name="pear")
-        pear.tags.add("green")
-
-        self.assertEqual(
-            list(self.food_model.objects.filter(tags__name__in=["red"])),
-            [apple]
-        )
-        self.assertEqual(
-            list(self.food_model.objects.filter(tags__name__in=["green"])),
-            [apple, pear]
-        )
-
-        kitty = self.pet_model.objects.create(name="kitty")
-        kitty.tags.add("fuzzy", "red")
-        dog = self.pet_model.objects.create(name="dog")
-        dog.tags.add("woof", "red")
-        self.assertEqual(
-            list(self.food_model.objects.filter(tags__name__in=["red"]).distinct()),
-            [apple]
-        )
-
-        tag = self.tag_model.objects.get(name="woof")
-        self.assertEqual(list(self.pet_model.objects.filter(tags__in=[tag])), [dog])
-
-        cat = self.housepet_model.objects.create(name="cat", trained=True)
-        cat.tags.add("fuzzy")
-
-        self.assertEqual(
-            map(lambda o: o.pk, self.pet_model.objects.filter(tags__name__in=["fuzzy"])),
-            [kitty.pk, cat.pk]
-        )
-
-    def test_exclude(self):
-        apple = self.food_model.objects.create(name="apple")
-        apple.tags.add("red", "green", "delicious")
-
-        pear = self.food_model.objects.create(name="pear")
-        pear.tags.add("green", "delicious")
-
-        guava = self.food_model.objects.create(name="guava")
-
-        self.assertEqual(
-            map(lambda o: o.pk, self.food_model.objects.exclude(tags__name__in=["red"])),
-            [pear.pk, guava.pk],
-        )
-
-    def test_similarity_by_tag(self):
-        """Test that pears are more similar to apples than watermelons"""
-        apple = self.food_model.objects.create(name="apple")
-        apple.tags.add("green", "juicy", "small", "sour")
-
-        pear = self.food_model.objects.create(name="pear")
-        pear.tags.add("green", "juicy", "small", "sweet")
-
-        watermelon = self.food_model.objects.create(name="watermelon")
-        watermelon.tags.add("green", "juicy", "large", "sweet")
-
-        similar_objs = apple.tags.similar_objects()
-        self.assertEqual(similar_objs, [pear, watermelon])
-        self.assertEqual(map(lambda x: x.similar_tags, similar_objs), [3, 2])
-
-    def test_tag_reuse(self):
-        apple = self.food_model.objects.create(name="apple")
-        apple.tags.add("juicy", "juicy")
-        self.assert_tags_equal(apple.tags.all(), ['juicy'])
-
-    def test_query_traverse(self):
-        spot = self.pet_model.objects.create(name='Spot')
-        spike = self.pet_model.objects.create(name='Spike')
-        spot.tags.add('scary')
-        spike.tags.add('fluffy')
-        lookup_kwargs = {
-            '%s__name' % self.pet_model._meta.module_name: 'Spot'
-        }
-        self.assert_tags_equal(
-           self.tag_model.objects.filter(**lookup_kwargs),
-           ['scary']
-        )
-
-    def test_taggeditem_unicode(self):
-        ross = self.pet_model.objects.create(name="ross")
-        # I keep Ross Perot for a pet, what's it to you?
-        ross.tags.add("president")
-
-        self.assertEqual(
-            unicode(self.taggeditem_model.objects.all()[0]),
-            "ross tagged with president"
-        )
-
-    def test_abstract_subclasses(self):
-        p = Photo.objects.create()
-        p.tags.add("outdoors", "pretty")
-        self.assert_tags_equal(
-            p.tags.all(),
-            ["outdoors", "pretty"]
-        )
-
-        m = Movie.objects.create()
-        m.tags.add("hd")
-        self.assert_tags_equal(
-            m.tags.all(),
-            ["hd"],
-        )
-
-
-class TaggableManagerDirectTestCase(TaggableManagerTestCase):
-    food_model = DirectFood
-    pet_model = DirectPet
-    housepet_model = DirectHousePet
-    taggeditem_model = TaggedPet
-
-class TaggableManagerCustomPKTestCase(TaggableManagerTestCase):
-    food_model = CustomPKFood
-    pet_model = CustomPKPet
-    housepet_model = CustomPKHousePet
-    taggeditem_model = TaggedCustomPKPet
-
-    def test_require_pk(self):
-        # TODO with a charfield pk, pk is never None, so taggit has no way to
-        # tell if the instance is saved or not
-        pass
-
-class TaggableManagerOfficialTestCase(TaggableManagerTestCase):
-    food_model = OfficialFood
-    pet_model = OfficialPet
-    housepet_model = OfficialHousePet
-    taggeditem_model = OfficialThroughModel
-    tag_model = OfficialTag
-
-    def test_extra_fields(self):
-        self.tag_model.objects.create(name="red")
-        self.tag_model.objects.create(name="delicious", official=True)
-        apple = self.food_model.objects.create(name="apple")
-        apple.tags.add("delicious", "red")
-
-        pear = self.food_model.objects.create(name="Pear")
-        pear.tags.add("delicious")
-
-        self.assertEqual(
-            map(lambda o: o.pk, self.food_model.objects.filter(tags__official=False)),
-            [apple.pk],
-        )
-
-
-class TaggableFormTestCase(BaseTaggingTestCase):
-    form_class = FoodForm
-    food_model = Food
-
-    def test_form(self):
-        self.assertEqual(self.form_class.base_fields.keys(), ['name', 'tags'])
-
-        f = self.form_class({'name': 'apple', 'tags': 'green, red, yummy'})
-        self.assert_form_renders(f, """<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" value="apple" maxlength="50" /></td></tr>
-<tr><th><label for="id_tags">Tags:</label></th><td><input type="text" name="tags" value="green, red, yummy" id="id_tags" /><br />%(help_start)sA comma-separated list of tags.%(help_stop)s</td></tr>""")
-        f.save()
-        apple = self.food_model.objects.get(name='apple')
-        self.assert_tags_equal(apple.tags.all(), ['green', 'red', 'yummy'])
-
-        f = self.form_class({'name': 'apple', 'tags': 'green, red, yummy, delicious'}, instance=apple)
-        f.save()
-        apple = self.food_model.objects.get(name='apple')
-        self.assert_tags_equal(apple.tags.all(), ['green', 'red', 'yummy', 'delicious'])
-        self.assertEqual(self.food_model.objects.count(), 1)
-
-        f = self.form_class({"name": "raspberry"})
-        self.assertFalse(f.is_valid())
-
-        f = self.form_class(instance=apple)
-        self.assert_form_renders(f, """<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" value="apple" maxlength="50" /></td></tr>
-<tr><th><label for="id_tags">Tags:</label></th><td><input type="text" name="tags" value="delicious, green, red, yummy" id="id_tags" /><br />%(help_start)sA comma-separated list of tags.%(help_stop)s</td></tr>""")
-
-        apple.tags.add('has,comma')
-        f = self.form_class(instance=apple)
-        self.assert_form_renders(f, """<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" value="apple" maxlength="50" /></td></tr>
-<tr><th><label for="id_tags">Tags:</label></th><td><input type="text" name="tags" value="&quot;has,comma&quot;, delicious, green, red, yummy" id="id_tags" /><br />%(help_start)sA comma-separated list of tags.%(help_stop)s</td></tr>""")
-
-        apple.tags.add('has space')
-        f = self.form_class(instance=apple)
-        self.assert_form_renders(f, """<tr><th><label for="id_name">Name:</label></th><td><input id="id_name" type="text" name="name" value="apple" maxlength="50" /></td></tr>
-<tr><th><label for="id_tags">Tags:</label></th><td><input type="text" name="tags" value="&quot;has space&quot;, &quot;has,comma&quot;, delicious, green, red, yummy" id="id_tags" /><br />%(help_start)sA comma-separated list of tags.%(help_stop)s</td></tr>""")
-
-    def test_formfield(self):
-        tm = TaggableManager(verbose_name='categories', help_text='Add some categories', blank=True)
-        ff = tm.formfield()
-        self.assertEqual(ff.label, 'Categories')
-        self.assertEqual(ff.help_text, u'Add some categories')
-        self.assertEqual(ff.required, False)
-
-        self.assertEqual(ff.clean(""), [])
-
-        tm = TaggableManager()
-        ff = tm.formfield()
-        self.assertRaises(ValidationError, ff.clean, "")
-
-class TaggableFormDirectTestCase(TaggableFormTestCase):
-    form_class = DirectFoodForm
-    food_model = DirectFood
-
-class TaggableFormCustomPKTestCase(TaggableFormTestCase):
-    form_class = CustomPKFoodForm
-    food_model = CustomPKFood
-
-class TaggableFormOfficialTestCase(TaggableFormTestCase):
-    form_class = OfficialFoodForm
-    food_model = OfficialFood
-
-
-class TagStringParseTestCase(UnitTestCase):
-    """
-    Ported from Jonathan Buchanan's `django-tagging
-    <http://django-tagging.googlecode.com/>`_
-    """
-
-    def test_with_simple_space_delimited_tags(self):
-        """
-        Test with simple space-delimited tags.
-        """
-        self.assertEqual(parse_tags('one'), [u'one'])
-        self.assertEqual(parse_tags('one two'), [u'one', u'two'])
-        self.assertEqual(parse_tags('one two three'), [u'one', u'three', u'two'])
-        self.assertEqual(parse_tags('one one two two'), [u'one', u'two'])
-
-    def test_with_comma_delimited_multiple_words(self):
-        """
-        Test with comma-delimited multiple words.
-        An unquoted comma in the input will trigger this.
-        """
-        self.assertEqual(parse_tags(',one'), [u'one'])
-        self.assertEqual(parse_tags(',one two'), [u'one two'])
-        self.assertEqual(parse_tags(',one two three'), [u'one two three'])
-        self.assertEqual(parse_tags('a-one, a-two and a-three'),
-            [u'a-one', u'a-two and a-three'])
-
-    def test_with_double_quoted_multiple_words(self):
-        """
-        Test with double-quoted multiple words.
-        A completed quote will trigger this.  Unclosed quotes are ignored.
-        """
-        self.assertEqual(parse_tags('"one'), [u'one'])
-        self.assertEqual(parse_tags('"one two'), [u'one', u'two'])
-        self.assertEqual(parse_tags('"one two three'), [u'one', u'three', u'two'])
-        self.assertEqual(parse_tags('"one two"'), [u'one two'])
-        self.assertEqual(parse_tags('a-one "a-two and a-three"'),
-            [u'a-one', u'a-two and a-three'])
-
-    def test_with_no_loose_commas(self):
-        """
-        Test with no loose commas -- split on spaces.
-        """
-        self.assertEqual(parse_tags('one two "thr,ee"'), [u'one', u'thr,ee', u'two'])
-
-    def test_with_loose_commas(self):
-        """
-        Loose commas - split on commas
-        """
-        self.assertEqual(parse_tags('"one", two three'), [u'one', u'two three'])
-
-    def test_tags_with_double_quotes_can_contain_commas(self):
-        """
-        Double quotes can contain commas
-        """
-        self.assertEqual(parse_tags('a-one "a-two, and a-three"'),
-            [u'a-one', u'a-two, and a-three'])
-        self.assertEqual(parse_tags('"two", one, one, two, "one"'),
-            [u'one', u'two'])
-
-    def test_with_naughty_input(self):
-        """
-        Test with naughty input.
-        """
-        # Bad users! Naughty users!
-        self.assertEqual(parse_tags(None), [])
-        self.assertEqual(parse_tags(''), [])
-        self.assertEqual(parse_tags('"'), [])
-        self.assertEqual(parse_tags('""'), [])
-        self.assertEqual(parse_tags('"' * 7), [])
-        self.assertEqual(parse_tags(',,,,,,'), [])
-        self.assertEqual(parse_tags('",",",",",",","'), [u','])
-        self.assertEqual(parse_tags('a-one "a-two" and "a-three'),
-            [u'a-one', u'a-three', u'a-two', u'and'])
-
-    def test_recreation_of_tag_list_string_representations(self):
-        plain = Tag.objects.create(name='plain')
-        spaces = Tag.objects.create(name='spa ces')
-        comma = Tag.objects.create(name='com,ma')
-        self.assertEqual(edit_string_for_tags([plain]), u'plain')
-        self.assertEqual(edit_string_for_tags([plain, spaces]), u'"spa ces", plain')
-        self.assertEqual(edit_string_for_tags([plain, spaces, comma]), u'"com,ma", "spa ces", plain')
-        self.assertEqual(edit_string_for_tags([plain, comma]), u'"com,ma", plain')
-        self.assertEqual(edit_string_for_tags([comma, spaces]), u'"com,ma", "spa ces"')
diff --git a/lib/taggit/utils.py b/lib/taggit/utils.py
deleted file mode 100644
index 1b5e5a7..0000000
--- a/lib/taggit/utils.py
+++ /dev/null
@@ -1,126 +0,0 @@
-from django.utils.encoding import force_unicode
-from django.utils.functional import wraps
-
-
-def parse_tags(tagstring):
-    """
-    Parses tag input, with multiple word input being activated and
-    delineated by commas and double quotes. Quotes take precedence, so
-    they may contain commas.
-
-    Returns a sorted list of unique tag names.
-
-    Ported from Jonathan Buchanan's `django-tagging
-    <http://django-tagging.googlecode.com/>`_
-    """
-    if not tagstring:
-        return []
-
-    tagstring = force_unicode(tagstring)
-
-    # Special case - if there are no commas or double quotes in the
-    # input, we don't *do* a recall... I mean, we know we only need to
-    # split on spaces.
-    if u',' not in tagstring and u'"' not in tagstring:
-        words = list(set(split_strip(tagstring, u' ')))
-        words.sort()
-        return words
-
-    words = []
-    buffer = []
-    # Defer splitting of non-quoted sections until we know if there are
-    # any unquoted commas.
-    to_be_split = []
-    saw_loose_comma = False
-    open_quote = False
-    i = iter(tagstring)
-    try:
-        while True:
-            c = i.next()
-            if c == u'"':
-                if buffer:
-                    to_be_split.append(u''.join(buffer))
-                    buffer = []
-                # Find the matching quote
-                open_quote = True
-                c = i.next()
-                while c != u'"':
-                    buffer.append(c)
-                    c = i.next()
-                if buffer:
-                    word = u''.join(buffer).strip()
-                    if word:
-                        words.append(word)
-                    buffer = []
-                open_quote = False
-            else:
-                if not saw_loose_comma and c == u',':
-                    saw_loose_comma = True
-                buffer.append(c)
-    except StopIteration:
-        # If we were parsing an open quote which was never closed treat
-        # the buffer as unquoted.
-        if buffer:
-            if open_quote and u',' in buffer:
-                saw_loose_comma = True
-            to_be_split.append(u''.join(buffer))
-    if to_be_split:
-        if saw_loose_comma:
-            delimiter = u','
-        else:
-            delimiter = u' '
-        for chunk in to_be_split:
-            words.extend(split_strip(chunk, delimiter))
-    words = list(set(words))
-    words.sort()
-    return words
-
-
-def split_strip(string, delimiter=u','):
-    """
-    Splits ``string`` on ``delimiter``, stripping each resulting string
-    and returning a list of non-empty strings.
-
-    Ported from Jonathan Buchanan's `django-tagging
-    <http://django-tagging.googlecode.com/>`_
-    """
-    if not string:
-        return []
-
-    words = [w.strip() for w in string.split(delimiter)]
-    return [w for w in words if w]
-
-
-def edit_string_for_tags(tags):
-    """
-    Given list of ``Tag`` instances, creates a string representation of
-    the list suitable for editing by the user, such that submitting the
-    given string representation back without changing it will give the
-    same list of tags.
-
-    Tag names which contain commas will be double quoted.
-
-    If any tag name which isn't being quoted contains whitespace, the
-    resulting string of tag names will be comma-delimited, otherwise
-    it will be space-delimited.
-
-    Ported from Jonathan Buchanan's `django-tagging
-    <http://django-tagging.googlecode.com/>`_
-    """
-    names = []
-    for tag in tags:
-        name = tag.name
-        if u',' in name or u' ' in name:
-            names.append('"%s"' % name)
-        else:
-            names.append(name)
-    return u', '.join(sorted(names))
-
-
-def require_instance_manager(func):
-    @wraps(func)
-    def inner(self, *args, **kwargs):
-        if self.instance is None:
-            raise TypeError("Can't call %s with a non-instance manager" % func.__name__)
-        return func(self, *args, **kwargs)
-    return inner
diff --git a/lib/taggit/views.py b/lib/taggit/views.py
deleted file mode 100644
index 68e955b..0000000
--- a/lib/taggit/views.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from django.contrib.contenttypes.models import ContentType
-from django.shortcuts import get_object_or_404
-from django.views.generic.list_detail import object_list
-
-from taggit.models import TaggedItem, Tag
-
-
-def tagged_object_list(request, slug, queryset, **kwargs):
-    if callable(queryset):
-        queryset = queryset()
-    tag = get_object_or_404(Tag, slug=slug)
-    qs = queryset.filter(pk__in=TaggedItem.objects.filter(
-        tag=tag, content_type=ContentType.objects.get_for_model(queryset.model)
-    ).values_list("object_id", flat=True))
-    if "extra_context" not in kwargs:
-        kwargs["extra_context"] = {}
-    kwargs["extra_context"]["tag"] = tag
-    return object_list(request, qs, **kwargs)