--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/.settings/org.eclipse.wst.html.core.prefs Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,36 @@
+#Wed Jan 20 11:20:27 CET 2010
+attrDuplicate=2
+attrInvalidName=2
+attrInvalidValue=2
+attrNameMismatch=2
+attrUndefName=2
+attrUndefValue=2
+attrValueMismatch=1
+attrValueUnclosed=2
+cdataInvalidContent=2
+cdataUnclosed=1
+commentInvalidContent=2
+commentUnclosed=1
+docDoctypeUnclosed=1
+docDuplicateTag=1
+docInvalidChar=2
+docInvalidContent=2
+eclipse.preferences.version=1
+elemCoexistence=2
+elemDuplicate=2
+elemEndInvalidCase=1
+elemInvalidContent=2
+elemInvalidDirective=1
+elemInvalidEmptyTag=2
+elemInvalidName=1
+elemMissingEnd=2
+elemMissingStart=1
+elemStartInvalidCase=2
+elemUnclosedEndTag=1
+elemUnclosedStartTag=1
+elemUnknownName=2
+elemUnnecessaryEnd=2
+piInvalidContent=2
+piUnclosed=1
+piUndefined=2
+refInvalidContent=2
--- a/web/blinkster/__init__.py Fri Jan 22 04:16:06 2010 +0100
+++ b/web/blinkster/__init__.py Fri Jan 22 18:23:34 2010 +0100
@@ -1,3 +1,3 @@
-VERSION = (0,3)
+VERSION = (0,4)
VERSION_STR = unicode(".".join(map(lambda i:"%02d" % (i,), VERSION)))
--- a/web/blinkster/models.py Fri Jan 22 04:16:06 2010 +0100
+++ b/web/blinkster/models.py Fri Jan 22 18:23:34 2010 +0100
@@ -6,34 +6,47 @@
import photologue.models
from django.conf import settings
from modeltranslation.utils import build_localized_fieldname
+from modeltranslation.translator import translator
+import tagging
+
def get_sid():
return unicode(uuid.uuid1())
-class Roi(models.Model):
+class Ioi(models.Model):
+
+ class Meta:
+ abstract = True
sid = models.CharField(max_length=36, unique=True, blank=False, null=False, db_index=True, editable=False, default=get_sid)
+ loc = models.CharField(max_length=512, unique=False, blank=True, null=True)
+ loc_radius = models.FloatField(null=True, blank=True)
title = models.CharField(max_length=1024, unique=True, blank=False, null=False)
short_title = models.CharField(max_length=512, unique=True, blank=False, null=False)
description = models.TextField(blank=True, null=True)
- loc = models.CharField(max_length=512, unique=False, blank=True, null=True)
- loc_radius = models.FloatField(null=True)
+
photos = models.ForeignKey(photologue.models.Gallery, null=True)
-
def serialize_to_dict(self):
res = {
"sid": self.sid,
}
- for fieldname in ["title","short_title","description"]:
- lang_dict = {}
- for l in settings.LANGUAGES:
- lang = l[0]
- lfieldname = build_localized_fieldname(fieldname, lang)
- lang_dict[lang] = self.__dict__[lfieldname]
- res[fieldname] = lang_dict
-
+ # serialize translated fields
+ trans_options = None
+ try:
+ trans_options = translator.get_options_for_model(self.__class__)
+ except:
+ trans_options = None
+ if trans_options:
+ for fieldname in trans_options.localized_fieldnames:
+ lang_dict = {}
+ for l in settings.LANGUAGES:
+ lang = l[0]
+ lfieldname = build_localized_fieldname(fieldname, lang)
+ lang_dict[lang] = self.__dict__[lfieldname]
+ res[fieldname] = lang_dict
+
res["loc"] = {}
if self.loc:
loc_array = self.loc.split(",")
@@ -49,4 +62,33 @@
return res
-admin.site.register(Roi)
+
+
+class Roi(Ioi):
+
+ def __unicode__(self):
+ return "%s : %s" % (unicode(self.pk),unicode(self.title))
+
+
+class Poi(Ioi):
+
+ roi = models.ForeignKey(Roi, null=False, related_name="region")
+ base_tag = models.CharField(max_length=512, unique=True, blank=False, null=False, db_index=True)
+ tags = tagging.fields.TagField(max_length=2048, blank=True, null=True)
+
+ def serialize_to_dict(self):
+ res = super(Poi, self).serialize_to_dict()
+ res["roi"] = self.roi.sid
+ res["base_tag"] = self.base_tag
+ res["tags"] = self.tags
+ return res
+
+ def __unicode__(self):
+ return "%s : %s" % (unicode(self.pk),unicode(self.title))
+
+
+
+admin.site.register(Roi)
+admin.site.register(Poi)
+#tagging.register(Poi)
+
--- a/web/blinkster/settings.py Fri Jan 22 04:16:06 2010 +0100
+++ b/web/blinkster/settings.py Fri Jan 22 18:23:34 2010 +0100
@@ -85,6 +85,7 @@
'django.contrib.sites',
'django.contrib.admin',
'modeltranslation',
+ 'tagging',
'photologue',
'blinkster.ldt',
'blinkster',
@@ -117,5 +118,7 @@
TRANSLATION_REGISTRY = "blinkster.translation"
+FORCE_LOWERCASE_TAGS = True
+
from config import *
--- a/web/blinkster/translation.py Fri Jan 22 04:16:06 2010 +0100
+++ b/web/blinkster/translation.py Fri Jan 22 18:23:34 2010 +0100
@@ -1,7 +1,12 @@
from modeltranslation.translator import translator, TranslationOptions
-from blinkster.models import Roi
+from blinkster.models import Roi,Poi
class RoiTranslationOption(TranslationOptions):
fields = ('title', 'short_title', 'description',)
+class PoiTranslationOption(TranslationOptions):
+ fields = ('title', 'short_title', 'description',)
+
+
translator.register(Roi, RoiTranslationOption)
+translator.register(Poi, PoiTranslationOption)
--- a/web/blinkster/urls.py Fri Jan 22 04:16:06 2010 +0100
+++ b/web/blinkster/urls.py Fri Jan 22 18:23:34 2010 +0100
@@ -38,7 +38,8 @@
(r'^ldt/project/(?P<id>.*)$', 'blinkster.ldt.views.ldtProject'),
(r'^ldt/projectslist/(?P<content_id>.*)$', 'blinkster.ldt.views.getProjectFromContentId'),
#(r'^.*(?P<content>flvplayer|mp3player|ClearExternalAllBlue)\.swf$','django.views.generic.simple.redirect_to', {'url':blinkster.settings.BASE_URL+'/static/swf/ldt/pkg/%(content)s.swf'}),
- (r'^roi/list/$', 'blinkster.views.roi'),
+ (r'^roi/list/$', 'blinkster.views.roi_list'),
+ (r'^poi/list/(?P<roi_sid>.*)$', 'blinkster.views.poi_list'),
(r'^photologue/', include('photologue.urls')),
)
--- a/web/blinkster/views.py Fri Jan 22 04:16:06 2010 +0100
+++ b/web/blinkster/views.py Fri Jan 22 18:23:34 2010 +0100
@@ -8,14 +8,22 @@
from django.core.serializers.json import DjangoJSONEncoder
from django.utils import simplejson
-from blinkster.models import Roi
+from blinkster.models import Roi, Poi
import blinkster
-def roi(request):
- response = HttpResponse(content_type="application/json; charset=utf-8")
+def serialize_queryset_to_json(response, objects):
objs = {
"version" : blinkster.VERSION,
- "rois" : [roi.serialize_to_dict() for roi in Roi.objects.all()]
+ "rois" : objects
}
simplejson.dump(objs, response, cls=DjangoJSONEncoder,ensure_ascii=False, indent=4)
return response
+
+def roi_list(request):
+ response = HttpResponse(content_type="application/json; charset=utf-8")
+ return serialize_queryset_to_json(response, [roi.serialize_to_dict() for roi in Roi.objects.all()])
+
+def poi_list(request, roi_sid):
+ response = HttpResponse(content_type="application/json; charset=utf-8")
+ return serialize_queryset_to_json(response, [poi.serialize_to_dict() for poi in Poi.objects.filter(roi__sid=roi_sid)])
+ return response
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/__init__.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,62 @@
+VERSION = (0, 3, 1, "final", 0)
+
+
+
+def get_version():
+ if VERSION[3] == "final":
+ return "%s.%s.%s" % (VERSION[0], VERSION[1], VERSION[2])
+ elif VERSION[3] == "dev":
+ if VERSION[2] == 0:
+ return "%s.%s.%s%s" % (VERSION[0], VERSION[1], VERSION[3], VERSION[4])
+ return "%s.%s.%s.%s%s" % (VERSION[0], VERSION[1], VERSION[2], VERSION[3], VERSION[4])
+ else:
+ return "%s.%s.%s%s" % (VERSION[0], VERSION[1], VERSION[2], VERSION[3])
+
+
+__version__ = get_version()
+
+
+class AlreadyRegistered(Exception):
+ """
+ An attempt was made to register a model more than once.
+ """
+ pass
+
+
+registry = []
+
+
+def register(model, tag_descriptor_attr='tags',
+ tagged_item_manager_attr='tagged'):
+ """
+ Sets the given model class up for working with tags.
+ """
+
+ from tagging.managers import ModelTaggedItemManager, TagDescriptor
+
+ if model in registry:
+ raise AlreadyRegistered("The model '%s' has already been "
+ "registered." % model._meta.object_name)
+ if hasattr(model, tag_descriptor_attr):
+ raise AttributeError("'%s' already has an attribute '%s'. You must "
+ "provide a custom tag_descriptor_attr to register." % (
+ model._meta.object_name,
+ tag_descriptor_attr,
+ )
+ )
+ if hasattr(model, tagged_item_manager_attr):
+ raise AttributeError("'%s' already has an attribute '%s'. You must "
+ "provide a custom tagged_item_manager_attr to register." % (
+ model._meta.object_name,
+ tagged_item_manager_attr,
+ )
+ )
+
+ # Add tag descriptor
+ setattr(model, tag_descriptor_attr, TagDescriptor())
+
+ # Add custom manager
+ ModelTaggedItemManager().contribute_to_class(model, tagged_item_manager_attr)
+
+ # Finally register in registry
+ registry.append(model)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/admin.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,13 @@
+from django.contrib import admin
+from tagging.models import Tag, TaggedItem
+from tagging.forms import TagAdminForm
+
+class TagAdmin(admin.ModelAdmin):
+ form = TagAdminForm
+
+admin.site.register(TaggedItem)
+admin.site.register(Tag, TagAdmin)
+
+
+
+
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/fields.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,107 @@
+"""
+A custom Model Field for tagging.
+"""
+from django.db.models import signals
+from django.db.models.fields import CharField
+from django.utils.translation import ugettext_lazy as _
+
+from tagging import settings
+from tagging.models import Tag
+from tagging.utils import edit_string_for_tags
+
+class TagField(CharField):
+ """
+ A "special" character field that actually works as a relationship to tags
+ "under the hood". This exposes a space-separated string of tags, but does
+ the splitting/reordering/etc. under the hood.
+ """
+ def __init__(self, *args, **kwargs):
+ kwargs['max_length'] = kwargs.get('max_length', 255)
+ kwargs['blank'] = kwargs.get('blank', True)
+ super(TagField, self).__init__(*args, **kwargs)
+
+ def contribute_to_class(self, cls, name):
+ super(TagField, self).contribute_to_class(cls, name)
+
+ # Make this object the descriptor for field access.
+ setattr(cls, self.name, self)
+
+ # Save tags back to the database post-save
+ signals.post_save.connect(self._save, cls, True)
+
+ def __get__(self, instance, owner=None):
+ """
+ Tag getter. Returns an instance's tags if accessed on an instance, and
+ all of a model's tags if called on a class. That is, this model::
+
+ class Link(models.Model):
+ ...
+ tags = TagField()
+
+ Lets you do both of these::
+
+ >>> l = Link.objects.get(...)
+ >>> l.tags
+ 'tag1 tag2 tag3'
+
+ >>> Link.tags
+ 'tag1 tag2 tag3 tag4'
+
+ """
+ # Handle access on the model (i.e. Link.tags)
+ if instance is None:
+ return edit_string_for_tags(Tag.objects.usage_for_model(owner))
+
+ tags = self._get_instance_tag_cache(instance)
+ if tags is None:
+ if instance.pk is None:
+ self._set_instance_tag_cache(instance, '')
+ else:
+ self._set_instance_tag_cache(
+ instance, edit_string_for_tags(Tag.objects.get_for_object(instance)))
+ return self._get_instance_tag_cache(instance)
+
+ def __set__(self, instance, value):
+ """
+ Set an object's tags.
+ """
+ if instance is None:
+ raise AttributeError(_('%s can only be set on instances.') % self.name)
+ if settings.FORCE_LOWERCASE_TAGS and value is not None:
+ value = value.lower()
+ self._set_instance_tag_cache(instance, value)
+
+ def _save(self, **kwargs): #signal, sender, instance):
+ """
+ Save tags back to the database
+ """
+ tags = self._get_instance_tag_cache(kwargs['instance'])
+ if tags is not None:
+ Tag.objects.update_tags(kwargs['instance'], tags)
+
+ def __delete__(self, instance):
+ """
+ Clear all of an object's tags.
+ """
+ self._set_instance_tag_cache(instance, '')
+
+ def _get_instance_tag_cache(self, instance):
+ """
+ Helper: get an instance's tag cache.
+ """
+ return getattr(instance, '_%s_cache' % self.attname, None)
+
+ def _set_instance_tag_cache(self, instance, tags):
+ """
+ Helper: set an instance's tag cache.
+ """
+ setattr(instance, '_%s_cache' % self.attname, tags)
+
+ def get_internal_type(self):
+ return 'CharField'
+
+ def formfield(self, **kwargs):
+ from tagging import forms
+ defaults = {'form_class': forms.TagField}
+ defaults.update(kwargs)
+ return super(TagField, self).formfield(**defaults)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/forms.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,40 @@
+"""
+Tagging components for Django's form library.
+"""
+from django import forms
+from django.utils.translation import ugettext as _
+
+from tagging import settings
+from tagging.models import Tag
+from tagging.utils import parse_tag_input
+
+class TagAdminForm(forms.ModelForm):
+ class Meta:
+ model = Tag
+
+ def clean_name(self):
+ value = self.cleaned_data['name']
+ tag_names = parse_tag_input(value)
+ if len(tag_names) > 1:
+ raise forms.ValidationError(_('Multiple tags were given.'))
+ elif len(tag_names[0]) > settings.MAX_TAG_LENGTH:
+ raise forms.ValidationError(
+ _('A tag may be no more than %s characters long.') %
+ settings.MAX_TAG_LENGTH)
+ return value
+
+class TagField(forms.CharField):
+ """
+ A ``CharField`` which validates that its input is a valid list of
+ tag names.
+ """
+ def clean(self, value):
+ value = super(TagField, self).clean(value)
+ if value == u'':
+ return value
+ for tag_name in parse_tag_input(value):
+ if len(tag_name) > settings.MAX_TAG_LENGTH:
+ raise forms.ValidationError(
+ _('Each tag may be no more than %s characters long.') %
+ settings.MAX_TAG_LENGTH)
+ return value
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/generic.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,40 @@
+from django.contrib.contenttypes.models import ContentType
+
+def fetch_content_objects(tagged_items, select_related_for=None):
+ """
+ Retrieves ``ContentType`` and content objects for the given list of
+ ``TaggedItems``, grouping the retrieval of content objects by model
+ type to reduce the number of queries executed.
+
+ This results in ``number_of_content_types + 1`` queries rather than
+ the ``number_of_tagged_items * 2`` queries you'd get by iterating
+ over the list and accessing each item's ``object`` attribute.
+
+ A ``select_related_for`` argument can be used to specify a list of
+ of model names (corresponding to the ``model`` field of a
+ ``ContentType``) for which ``select_related`` should be used when
+ retrieving model instances.
+ """
+ if select_related_for is None: select_related_for = []
+
+ # Group content object pks by their content type pks
+ objects = {}
+ for item in tagged_items:
+ objects.setdefault(item.content_type_id, []).append(item.object_id)
+
+ # Retrieve content types and content objects in bulk
+ content_types = ContentType._default_manager.in_bulk(objects.keys())
+ for content_type_pk, object_pks in objects.iteritems():
+ model = content_types[content_type_pk].model_class()
+ if content_types[content_type_pk].model in select_related_for:
+ objects[content_type_pk] = model._default_manager.select_related().in_bulk(object_pks)
+ else:
+ objects[content_type_pk] = model._default_manager.in_bulk(object_pks)
+
+ # Set content types and content objects in the appropriate cache
+ # attributes, so accessing the 'content_type' and 'object'
+ # attributes on each tagged item won't result in further database
+ # hits.
+ for item in tagged_items:
+ item._object_cache = objects[item.content_type_id][item.object_id]
+ item._content_type_cache = content_types[item.content_type_id]
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/managers.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,68 @@
+"""
+Custom managers for Django models registered with the tagging
+application.
+"""
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+
+from tagging.models import Tag, TaggedItem
+
+class ModelTagManager(models.Manager):
+ """
+ A manager for retrieving tags for a particular model.
+ """
+ def get_query_set(self):
+ ctype = ContentType.objects.get_for_model(self.model)
+ return Tag.objects.filter(
+ items__content_type__pk=ctype.pk).distinct()
+
+ def cloud(self, *args, **kwargs):
+ return Tag.objects.cloud_for_model(self.model, *args, **kwargs)
+
+ def related(self, tags, *args, **kwargs):
+ return Tag.objects.related_for_model(tags, self.model, *args, **kwargs)
+
+ def usage(self, *args, **kwargs):
+ return Tag.objects.usage_for_model(self.model, *args, **kwargs)
+
+class ModelTaggedItemManager(models.Manager):
+ """
+ A manager for retrieving model instances based on their tags.
+ """
+ def related_to(self, obj, queryset=None, num=None):
+ if queryset is None:
+ return TaggedItem.objects.get_related(obj, self.model, num=num)
+ else:
+ return TaggedItem.objects.get_related(obj, queryset, num=num)
+
+ def with_all(self, tags, queryset=None):
+ if queryset is None:
+ return TaggedItem.objects.get_by_model(self.model, tags)
+ else:
+ return TaggedItem.objects.get_by_model(queryset, tags)
+
+ def with_any(self, tags, queryset=None):
+ if queryset is None:
+ return TaggedItem.objects.get_union_by_model(self.model, tags)
+ else:
+ return TaggedItem.objects.get_union_by_model(queryset, tags)
+
+class TagDescriptor(object):
+ """
+ A descriptor which provides access to a ``ModelTagManager`` for
+ model classes and simple retrieval, updating and deletion of tags
+ for model instances.
+ """
+ def __get__(self, instance, owner):
+ if not instance:
+ tag_manager = ModelTagManager()
+ tag_manager.model = owner
+ return tag_manager
+ else:
+ return Tag.objects.get_for_object(instance)
+
+ def __set__(self, instance, value):
+ Tag.objects.update_tags(instance, value)
+
+ def __delete__(self, instance):
+ Tag.objects.update_tags(instance, None)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/models.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,490 @@
+"""
+Models and managers for generic tagging.
+"""
+# Python 2.3 compatibility
+try:
+ set
+except NameError:
+ from sets import Set as set
+
+from django.contrib.contenttypes import generic
+from django.contrib.contenttypes.models import ContentType
+from django.db import connection, models
+from django.db.models.query import QuerySet
+from django.utils.translation import ugettext_lazy as _
+
+from tagging import settings
+from tagging.utils import calculate_cloud, get_tag_list, get_queryset_and_model, parse_tag_input
+from tagging.utils import LOGARITHMIC
+
+qn = connection.ops.quote_name
+
+############
+# Managers #
+############
+
+class TagManager(models.Manager):
+ def update_tags(self, obj, tag_names):
+ """
+ Update tags associated with an object.
+ """
+ ctype = ContentType.objects.get_for_model(obj)
+ current_tags = list(self.filter(items__content_type__pk=ctype.pk,
+ items__object_id=obj.pk))
+ updated_tag_names = parse_tag_input(tag_names)
+ if settings.FORCE_LOWERCASE_TAGS:
+ updated_tag_names = [t.lower() for t in updated_tag_names]
+
+ # Remove tags which no longer apply
+ tags_for_removal = [tag for tag in current_tags \
+ if tag.name not in updated_tag_names]
+ if len(tags_for_removal):
+ TaggedItem._default_manager.filter(content_type__pk=ctype.pk,
+ object_id=obj.pk,
+ tag__in=tags_for_removal).delete()
+ # Add new tags
+ current_tag_names = [tag.name for tag in current_tags]
+ for tag_name in updated_tag_names:
+ if tag_name not in current_tag_names:
+ tag, created = self.get_or_create(name=tag_name)
+ TaggedItem._default_manager.create(tag=tag, object=obj)
+
+ def add_tag(self, obj, tag_name):
+ """
+ Associates the given object with a tag.
+ """
+ tag_names = parse_tag_input(tag_name)
+ if not len(tag_names):
+ raise AttributeError(_('No tags were given: "%s".') % tag_name)
+ if len(tag_names) > 1:
+ raise AttributeError(_('Multiple tags were given: "%s".') % tag_name)
+ tag_name = tag_names[0]
+ if settings.FORCE_LOWERCASE_TAGS:
+ tag_name = tag_name.lower()
+ tag, created = self.get_or_create(name=tag_name)
+ ctype = ContentType.objects.get_for_model(obj)
+ TaggedItem._default_manager.get_or_create(
+ tag=tag, content_type=ctype, object_id=obj.pk)
+
+ def get_for_object(self, obj):
+ """
+ Create a queryset matching all tags associated with the given
+ object.
+ """
+ ctype = ContentType.objects.get_for_model(obj)
+ return self.filter(items__content_type__pk=ctype.pk,
+ items__object_id=obj.pk)
+
+ def _get_usage(self, model, counts=False, min_count=None, extra_joins=None, extra_criteria=None, params=None):
+ """
+ Perform the custom SQL query for ``usage_for_model`` and
+ ``usage_for_queryset``.
+ """
+ if min_count is not None: counts = True
+
+ model_table = qn(model._meta.db_table)
+ model_pk = '%s.%s' % (model_table, qn(model._meta.pk.column))
+ query = """
+ SELECT DISTINCT %(tag)s.id, %(tag)s.name%(count_sql)s
+ FROM
+ %(tag)s
+ INNER JOIN %(tagged_item)s
+ ON %(tag)s.id = %(tagged_item)s.tag_id
+ INNER JOIN %(model)s
+ ON %(tagged_item)s.object_id = %(model_pk)s
+ %%s
+ WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
+ %%s
+ GROUP BY %(tag)s.id, %(tag)s.name
+ %%s
+ ORDER BY %(tag)s.name ASC""" % {
+ 'tag': qn(self.model._meta.db_table),
+ 'count_sql': counts and (', COUNT(%s)' % model_pk) or '',
+ 'tagged_item': qn(TaggedItem._meta.db_table),
+ 'model': model_table,
+ 'model_pk': model_pk,
+ 'content_type_id': ContentType.objects.get_for_model(model).pk,
+ }
+
+ min_count_sql = ''
+ if min_count is not None:
+ min_count_sql = 'HAVING COUNT(%s) >= %%s' % model_pk
+ params.append(min_count)
+
+ cursor = connection.cursor()
+ cursor.execute(query % (extra_joins, extra_criteria, min_count_sql), params)
+ tags = []
+ for row in cursor.fetchall():
+ t = self.model(*row[:2])
+ if counts:
+ t.count = row[2]
+ tags.append(t)
+ return tags
+
+ def usage_for_model(self, model, counts=False, min_count=None, filters=None):
+ """
+ Obtain a list of tags associated with instances of the given
+ Model class.
+
+ If ``counts`` is True, a ``count`` attribute will be added to
+ each tag, indicating how many times it has been used against
+ the Model class in question.
+
+ If ``min_count`` is given, only tags which have a ``count``
+ greater than or equal to ``min_count`` will be returned.
+ Passing a value for ``min_count`` implies ``counts=True``.
+
+ To limit the tags (and counts, if specified) returned to those
+ used by a subset of the Model's instances, pass a dictionary
+ of field lookups to be applied to the given Model as the
+ ``filters`` argument.
+ """
+ if filters is None: filters = {}
+
+ queryset = model._default_manager.filter()
+ for f in filters.items():
+ queryset.query.add_filter(f)
+ usage = self.usage_for_queryset(queryset, counts, min_count)
+
+ return usage
+
+ def usage_for_queryset(self, queryset, counts=False, min_count=None):
+ """
+ Obtain a list of tags associated with instances of a model
+ contained in the given queryset.
+
+ If ``counts`` is True, a ``count`` attribute will be added to
+ each tag, indicating how many times it has been used against
+ the Model class in question.
+
+ If ``min_count`` is given, only tags which have a ``count``
+ greater than or equal to ``min_count`` will be returned.
+ Passing a value for ``min_count`` implies ``counts=True``.
+ """
+
+ if getattr(queryset.query, 'get_compiler', None):
+ # Django 1.2+
+ compiler = queryset.query.get_compiler(using='default')
+ extra_joins = ' '.join(compiler.get_from_clause()[0][1:])
+ where, params = queryset.query.where.as_sql(
+ compiler.quote_name_unless_alias, compiler.connection
+ )
+ else:
+ # Django pre-1.2
+ extra_joins = ' '.join(queryset.query.get_from_clause()[0][1:])
+ where, params = queryset.query.where.as_sql()
+
+ if where:
+ extra_criteria = 'AND %s' % where
+ else:
+ extra_criteria = ''
+ return self._get_usage(queryset.model, counts, min_count, extra_joins, extra_criteria, params)
+
+ def related_for_model(self, tags, model, counts=False, min_count=None):
+ """
+ Obtain a list of tags related to a given list of tags - that
+ is, other tags used by items which have all the given tags.
+
+ If ``counts`` is True, a ``count`` attribute will be added to
+ each tag, indicating the number of items which have it in
+ addition to the given list of tags.
+
+ If ``min_count`` is given, only tags which have a ``count``
+ greater than or equal to ``min_count`` will be returned.
+ Passing a value for ``min_count`` implies ``counts=True``.
+ """
+ if min_count is not None: counts = True
+ tags = get_tag_list(tags)
+ tag_count = len(tags)
+ tagged_item_table = qn(TaggedItem._meta.db_table)
+ query = """
+ SELECT %(tag)s.id, %(tag)s.name%(count_sql)s
+ FROM %(tagged_item)s INNER JOIN %(tag)s ON %(tagged_item)s.tag_id = %(tag)s.id
+ WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
+ AND %(tagged_item)s.object_id IN
+ (
+ SELECT %(tagged_item)s.object_id
+ FROM %(tagged_item)s, %(tag)s
+ WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
+ AND %(tag)s.id = %(tagged_item)s.tag_id
+ AND %(tag)s.id IN (%(tag_id_placeholders)s)
+ GROUP BY %(tagged_item)s.object_id
+ HAVING COUNT(%(tagged_item)s.object_id) = %(tag_count)s
+ )
+ AND %(tag)s.id NOT IN (%(tag_id_placeholders)s)
+ GROUP BY %(tag)s.id, %(tag)s.name
+ %(min_count_sql)s
+ ORDER BY %(tag)s.name ASC""" % {
+ 'tag': qn(self.model._meta.db_table),
+ 'count_sql': counts and ', COUNT(%s.object_id)' % tagged_item_table or '',
+ 'tagged_item': tagged_item_table,
+ 'content_type_id': ContentType.objects.get_for_model(model).pk,
+ 'tag_id_placeholders': ','.join(['%s'] * tag_count),
+ 'tag_count': tag_count,
+ 'min_count_sql': min_count is not None and ('HAVING COUNT(%s.object_id) >= %%s' % tagged_item_table) or '',
+ }
+
+ params = [tag.pk for tag in tags] * 2
+ if min_count is not None:
+ params.append(min_count)
+
+ cursor = connection.cursor()
+ cursor.execute(query, params)
+ related = []
+ for row in cursor.fetchall():
+ tag = self.model(*row[:2])
+ if counts is True:
+ tag.count = row[2]
+ related.append(tag)
+ return related
+
+ def cloud_for_model(self, model, steps=4, distribution=LOGARITHMIC,
+ filters=None, min_count=None):
+ """
+ Obtain a list of tags associated with instances of the given
+ Model, giving each tag a ``count`` attribute indicating how
+ many times it has been used and a ``font_size`` attribute for
+ use in displaying a tag cloud.
+
+ ``steps`` defines the range of font sizes - ``font_size`` will
+ be an integer between 1 and ``steps`` (inclusive).
+
+ ``distribution`` defines the type of font size distribution
+ algorithm which will be used - logarithmic or linear. It must
+ be either ``tagging.utils.LOGARITHMIC`` or
+ ``tagging.utils.LINEAR``.
+
+ To limit the tags displayed in the cloud to those associated
+ with a subset of the Model's instances, pass a dictionary of
+ field lookups to be applied to the given Model as the
+ ``filters`` argument.
+
+ To limit the tags displayed in the cloud to those with a
+ ``count`` greater than or equal to ``min_count``, pass a value
+ for the ``min_count`` argument.
+ """
+ tags = list(self.usage_for_model(model, counts=True, filters=filters,
+ min_count=min_count))
+ return calculate_cloud(tags, steps, distribution)
+
+class TaggedItemManager(models.Manager):
+ """
+ FIXME There's currently no way to get the ``GROUP BY`` and ``HAVING``
+ SQL clauses required by many of this manager's methods into
+ Django's ORM.
+
+ For now, we manually execute a query to retrieve the PKs of
+ objects we're interested in, then use the ORM's ``__in``
+ lookup to return a ``QuerySet``.
+
+ Now that the queryset-refactor branch is in the trunk, this can be
+ tidied up significantly.
+ """
+ def get_by_model(self, queryset_or_model, tags):
+ """
+ Create a ``QuerySet`` containing instances of the specified
+ model associated with a given tag or list of tags.
+ """
+ tags = get_tag_list(tags)
+ tag_count = len(tags)
+ if tag_count == 0:
+ # No existing tags were given
+ queryset, model = get_queryset_and_model(queryset_or_model)
+ return model._default_manager.none()
+ elif tag_count == 1:
+ # Optimisation for single tag - fall through to the simpler
+ # query below.
+ tag = tags[0]
+ else:
+ return self.get_intersection_by_model(queryset_or_model, tags)
+
+ queryset, model = get_queryset_and_model(queryset_or_model)
+ content_type = ContentType.objects.get_for_model(model)
+ opts = self.model._meta
+ tagged_item_table = qn(opts.db_table)
+ return queryset.extra(
+ tables=[opts.db_table],
+ where=[
+ '%s.content_type_id = %%s' % tagged_item_table,
+ '%s.tag_id = %%s' % tagged_item_table,
+ '%s.%s = %s.object_id' % (qn(model._meta.db_table),
+ qn(model._meta.pk.column),
+ tagged_item_table)
+ ],
+ params=[content_type.pk, tag.pk],
+ )
+
+ def get_intersection_by_model(self, queryset_or_model, tags):
+ """
+ Create a ``QuerySet`` containing instances of the specified
+ model associated with *all* of the given list of tags.
+ """
+ tags = get_tag_list(tags)
+ tag_count = len(tags)
+ queryset, model = get_queryset_and_model(queryset_or_model)
+
+ if not tag_count:
+ return model._default_manager.none()
+
+ model_table = qn(model._meta.db_table)
+ # This query selects the ids of all objects which have all the
+ # given tags.
+ query = """
+ SELECT %(model_pk)s
+ FROM %(model)s, %(tagged_item)s
+ WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
+ AND %(tagged_item)s.tag_id IN (%(tag_id_placeholders)s)
+ AND %(model_pk)s = %(tagged_item)s.object_id
+ GROUP BY %(model_pk)s
+ HAVING COUNT(%(model_pk)s) = %(tag_count)s""" % {
+ 'model_pk': '%s.%s' % (model_table, qn(model._meta.pk.column)),
+ 'model': model_table,
+ 'tagged_item': qn(self.model._meta.db_table),
+ 'content_type_id': ContentType.objects.get_for_model(model).pk,
+ 'tag_id_placeholders': ','.join(['%s'] * tag_count),
+ 'tag_count': tag_count,
+ }
+
+ cursor = connection.cursor()
+ cursor.execute(query, [tag.pk for tag in tags])
+ object_ids = [row[0] for row in cursor.fetchall()]
+ if len(object_ids) > 0:
+ return queryset.filter(pk__in=object_ids)
+ else:
+ return model._default_manager.none()
+
+ def get_union_by_model(self, queryset_or_model, tags):
+ """
+ Create a ``QuerySet`` containing instances of the specified
+ model associated with *any* of the given list of tags.
+ """
+ tags = get_tag_list(tags)
+ tag_count = len(tags)
+ queryset, model = get_queryset_and_model(queryset_or_model)
+
+ if not tag_count:
+ return model._default_manager.none()
+
+ model_table = qn(model._meta.db_table)
+ # This query selects the ids of all objects which have any of
+ # the given tags.
+ query = """
+ SELECT %(model_pk)s
+ FROM %(model)s, %(tagged_item)s
+ WHERE %(tagged_item)s.content_type_id = %(content_type_id)s
+ AND %(tagged_item)s.tag_id IN (%(tag_id_placeholders)s)
+ AND %(model_pk)s = %(tagged_item)s.object_id
+ GROUP BY %(model_pk)s""" % {
+ 'model_pk': '%s.%s' % (model_table, qn(model._meta.pk.column)),
+ 'model': model_table,
+ 'tagged_item': qn(self.model._meta.db_table),
+ 'content_type_id': ContentType.objects.get_for_model(model).pk,
+ 'tag_id_placeholders': ','.join(['%s'] * tag_count),
+ }
+
+ cursor = connection.cursor()
+ cursor.execute(query, [tag.pk for tag in tags])
+ object_ids = [row[0] for row in cursor.fetchall()]
+ if len(object_ids) > 0:
+ return queryset.filter(pk__in=object_ids)
+ else:
+ return model._default_manager.none()
+
+ def get_related(self, obj, queryset_or_model, num=None):
+ """
+ Retrieve a list of instances of the specified model which share
+ tags with the model instance ``obj``, ordered by the number of
+ shared tags in descending order.
+
+ If ``num`` is given, a maximum of ``num`` instances will be
+ returned.
+ """
+ queryset, model = get_queryset_and_model(queryset_or_model)
+ model_table = qn(model._meta.db_table)
+ content_type = ContentType.objects.get_for_model(obj)
+ related_content_type = ContentType.objects.get_for_model(model)
+ query = """
+ SELECT %(model_pk)s, COUNT(related_tagged_item.object_id) AS %(count)s
+ FROM %(model)s, %(tagged_item)s, %(tag)s, %(tagged_item)s related_tagged_item
+ WHERE %(tagged_item)s.object_id = %%s
+ AND %(tagged_item)s.content_type_id = %(content_type_id)s
+ AND %(tag)s.id = %(tagged_item)s.tag_id
+ AND related_tagged_item.content_type_id = %(related_content_type_id)s
+ AND related_tagged_item.tag_id = %(tagged_item)s.tag_id
+ AND %(model_pk)s = related_tagged_item.object_id"""
+ if content_type.pk == related_content_type.pk:
+ # Exclude the given instance itself if determining related
+ # instances for the same model.
+ query += """
+ AND related_tagged_item.object_id != %(tagged_item)s.object_id"""
+ query += """
+ GROUP BY %(model_pk)s
+ ORDER BY %(count)s DESC
+ %(limit_offset)s"""
+ query = query % {
+ 'model_pk': '%s.%s' % (model_table, qn(model._meta.pk.column)),
+ 'count': qn('count'),
+ 'model': model_table,
+ 'tagged_item': qn(self.model._meta.db_table),
+ 'tag': qn(self.model._meta.get_field('tag').rel.to._meta.db_table),
+ 'content_type_id': content_type.pk,
+ 'related_content_type_id': related_content_type.pk,
+ # Hardcoding this for now just to get tests working again - this
+ # should now be handled by the query object.
+ 'limit_offset': num is not None and 'LIMIT %s' or '',
+ }
+
+ cursor = connection.cursor()
+ params = [obj.pk]
+ if num is not None:
+ params.append(num)
+ cursor.execute(query, params)
+ object_ids = [row[0] for row in cursor.fetchall()]
+ if len(object_ids) > 0:
+ # Use in_bulk here instead of an id__in lookup, because id__in would
+ # clobber the ordering.
+ object_dict = queryset.in_bulk(object_ids)
+ return [object_dict[object_id] for object_id in object_ids \
+ if object_id in object_dict]
+ else:
+ return []
+
+##########
+# Models #
+##########
+
+class Tag(models.Model):
+ """
+ A tag.
+ """
+ name = models.CharField(_('name'), max_length=50, unique=True, db_index=True)
+
+ objects = TagManager()
+
+ class Meta:
+ ordering = ('name',)
+ verbose_name = _('tag')
+ verbose_name_plural = _('tags')
+
+ def __unicode__(self):
+ return self.name
+
+class TaggedItem(models.Model):
+ """
+ Holds the relationship between a tag and the item being tagged.
+ """
+ tag = models.ForeignKey(Tag, verbose_name=_('tag'), related_name='items')
+ content_type = models.ForeignKey(ContentType, verbose_name=_('content type'))
+ object_id = models.PositiveIntegerField(_('object id'), db_index=True)
+ object = generic.GenericForeignKey('content_type', 'object_id')
+
+ objects = TaggedItemManager()
+
+ class Meta:
+ # Enforce unique tag association per object
+ unique_together = (('tag', 'content_type', 'object_id'),)
+ verbose_name = _('tagged item')
+ verbose_name_plural = _('tagged items')
+
+ def __unicode__(self):
+ return u'%s [%s]' % (self.object, self.tag)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/settings.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,13 @@
+"""
+Convenience module for access of custom tagging application settings,
+which enforces default settings when the main settings module does not
+contain the appropriate settings.
+"""
+from django.conf import settings
+
+# The maximum length of a tag's name.
+MAX_TAG_LENGTH = getattr(settings, 'MAX_TAG_LENGTH', 50)
+
+# Whether to force all tags to lowercase before they are saved to the
+# database.
+FORCE_LOWERCASE_TAGS = getattr(settings, 'FORCE_LOWERCASE_TAGS', False)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/templatetags/tagging_tags.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,231 @@
+from django.db.models import get_model
+from django.template import Library, Node, TemplateSyntaxError, Variable, resolve_variable
+from django.utils.translation import ugettext as _
+
+from tagging.models import Tag, TaggedItem
+from tagging.utils import LINEAR, LOGARITHMIC
+
+register = Library()
+
+class TagsForModelNode(Node):
+ def __init__(self, model, context_var, counts):
+ self.model = model
+ self.context_var = context_var
+ self.counts = counts
+
+ def render(self, context):
+ model = get_model(*self.model.split('.'))
+ if model is None:
+ raise TemplateSyntaxError(_('tags_for_model tag was given an invalid model: %s') % self.model)
+ context[self.context_var] = Tag.objects.usage_for_model(model, counts=self.counts)
+ return ''
+
+class TagCloudForModelNode(Node):
+ def __init__(self, model, context_var, **kwargs):
+ self.model = model
+ self.context_var = context_var
+ self.kwargs = kwargs
+
+ def render(self, context):
+ model = get_model(*self.model.split('.'))
+ if model is None:
+ raise TemplateSyntaxError(_('tag_cloud_for_model tag was given an invalid model: %s') % self.model)
+ context[self.context_var] = \
+ Tag.objects.cloud_for_model(model, **self.kwargs)
+ return ''
+
+class TagsForObjectNode(Node):
+ def __init__(self, obj, context_var):
+ self.obj = Variable(obj)
+ self.context_var = context_var
+
+ def render(self, context):
+ context[self.context_var] = \
+ Tag.objects.get_for_object(self.obj.resolve(context))
+ return ''
+
+class TaggedObjectsNode(Node):
+ def __init__(self, tag, model, context_var):
+ self.tag = Variable(tag)
+ self.context_var = context_var
+ self.model = model
+
+ def render(self, context):
+ model = get_model(*self.model.split('.'))
+ if model is None:
+ raise TemplateSyntaxError(_('tagged_objects tag was given an invalid model: %s') % self.model)
+ context[self.context_var] = \
+ TaggedItem.objects.get_by_model(model, self.tag.resolve(context))
+ return ''
+
+def do_tags_for_model(parser, token):
+ """
+ Retrieves a list of ``Tag`` objects associated with a given model
+ and stores them in a context variable.
+
+ Usage::
+
+ {% tags_for_model [model] as [varname] %}
+
+ The model is specified in ``[appname].[modelname]`` format.
+
+ Extended usage::
+
+ {% tags_for_model [model] as [varname] with counts %}
+
+ If specified - by providing extra ``with counts`` arguments - adds
+ a ``count`` attribute to each tag containing the number of
+ instances of the given model which have been tagged with it.
+
+ Examples::
+
+ {% tags_for_model products.Widget as widget_tags %}
+ {% tags_for_model products.Widget as widget_tags with counts %}
+
+ """
+ bits = token.contents.split()
+ len_bits = len(bits)
+ if len_bits not in (4, 6):
+ raise TemplateSyntaxError(_('%s tag requires either three or five arguments') % bits[0])
+ if bits[2] != 'as':
+ raise TemplateSyntaxError(_("second argument to %s tag must be 'as'") % bits[0])
+ if len_bits == 6:
+ if bits[4] != 'with':
+ raise TemplateSyntaxError(_("if given, fourth argument to %s tag must be 'with'") % bits[0])
+ if bits[5] != 'counts':
+ raise TemplateSyntaxError(_("if given, fifth argument to %s tag must be 'counts'") % bits[0])
+ if len_bits == 4:
+ return TagsForModelNode(bits[1], bits[3], counts=False)
+ else:
+ return TagsForModelNode(bits[1], bits[3], counts=True)
+
+def do_tag_cloud_for_model(parser, token):
+ """
+ Retrieves a list of ``Tag`` objects for a given model, with tag
+ cloud attributes set, and stores them in a context variable.
+
+ Usage::
+
+ {% tag_cloud_for_model [model] as [varname] %}
+
+ The model is specified in ``[appname].[modelname]`` format.
+
+ Extended usage::
+
+ {% tag_cloud_for_model [model] as [varname] with [options] %}
+
+ Extra options can be provided after an optional ``with`` argument,
+ with each option being specified in ``[name]=[value]`` format. Valid
+ extra options are:
+
+ ``steps``
+ Integer. Defines the range of font sizes.
+
+ ``min_count``
+ Integer. Defines the minimum number of times a tag must have
+ been used to appear in the cloud.
+
+ ``distribution``
+ One of ``linear`` or ``log``. Defines the font-size
+ distribution algorithm to use when generating the tag cloud.
+
+ Examples::
+
+ {% tag_cloud_for_model products.Widget as widget_tags %}
+ {% tag_cloud_for_model products.Widget as widget_tags with steps=9 min_count=3 distribution=log %}
+
+ """
+ bits = token.contents.split()
+ len_bits = len(bits)
+ if len_bits != 4 and len_bits not in range(6, 9):
+ raise TemplateSyntaxError(_('%s tag requires either three or between five and seven arguments') % bits[0])
+ if bits[2] != 'as':
+ raise TemplateSyntaxError(_("second argument to %s tag must be 'as'") % bits[0])
+ kwargs = {}
+ if len_bits > 5:
+ if bits[4] != 'with':
+ raise TemplateSyntaxError(_("if given, fourth argument to %s tag must be 'with'") % bits[0])
+ for i in range(5, len_bits):
+ try:
+ name, value = bits[i].split('=')
+ if name == 'steps' or name == 'min_count':
+ try:
+ kwargs[str(name)] = int(value)
+ except ValueError:
+ raise TemplateSyntaxError(_("%(tag)s tag's '%(option)s' option was not a valid integer: '%(value)s'") % {
+ 'tag': bits[0],
+ 'option': name,
+ 'value': value,
+ })
+ elif name == 'distribution':
+ if value in ['linear', 'log']:
+ kwargs[str(name)] = {'linear': LINEAR, 'log': LOGARITHMIC}[value]
+ else:
+ raise TemplateSyntaxError(_("%(tag)s tag's '%(option)s' option was not a valid choice: '%(value)s'") % {
+ 'tag': bits[0],
+ 'option': name,
+ 'value': value,
+ })
+ else:
+ raise TemplateSyntaxError(_("%(tag)s tag was given an invalid option: '%(option)s'") % {
+ 'tag': bits[0],
+ 'option': name,
+ })
+ except ValueError:
+ raise TemplateSyntaxError(_("%(tag)s tag was given a badly formatted option: '%(option)s'") % {
+ 'tag': bits[0],
+ 'option': bits[i],
+ })
+ return TagCloudForModelNode(bits[1], bits[3], **kwargs)
+
+def do_tags_for_object(parser, token):
+ """
+ Retrieves a list of ``Tag`` objects associated with an object and
+ stores them in a context variable.
+
+ Usage::
+
+ {% tags_for_object [object] as [varname] %}
+
+ Example::
+
+ {% tags_for_object foo_object as tag_list %}
+ """
+ bits = token.contents.split()
+ if len(bits) != 4:
+ raise TemplateSyntaxError(_('%s tag requires exactly three arguments') % bits[0])
+ if bits[2] != 'as':
+ raise TemplateSyntaxError(_("second argument to %s tag must be 'as'") % bits[0])
+ return TagsForObjectNode(bits[1], bits[3])
+
+def do_tagged_objects(parser, token):
+ """
+ Retrieves a list of instances of a given model which are tagged with
+ a given ``Tag`` and stores them in a context variable.
+
+ Usage::
+
+ {% tagged_objects [tag] in [model] as [varname] %}
+
+ The model is specified in ``[appname].[modelname]`` format.
+
+ The tag must be an instance of a ``Tag``, not the name of a tag.
+
+ Example::
+
+ {% tagged_objects comedy_tag in tv.Show as comedies %}
+
+ """
+ bits = token.contents.split()
+ if len(bits) != 6:
+ raise TemplateSyntaxError(_('%s tag requires exactly five arguments') % bits[0])
+ if bits[2] != 'in':
+ raise TemplateSyntaxError(_("second argument to %s tag must be 'in'") % bits[0])
+ if bits[4] != 'as':
+ raise TemplateSyntaxError(_("fourth argument to %s tag must be 'as'") % bits[0])
+ return TaggedObjectsNode(bits[1], bits[3], bits[5])
+
+register.tag('tags_for_model', do_tags_for_model)
+register.tag('tag_cloud_for_model', do_tag_cloud_for_model)
+register.tag('tags_for_object', do_tags_for_object)
+register.tag('tagged_objects', do_tagged_objects)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/tests/models.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,38 @@
+from django.db import models
+
+from tagging.fields import TagField
+
+class Perch(models.Model):
+ size = models.IntegerField()
+ smelly = models.BooleanField(default=True)
+
+class Parrot(models.Model):
+ state = models.CharField(max_length=50)
+ perch = models.ForeignKey(Perch, null=True)
+
+ def __unicode__(self):
+ return self.state
+
+ class Meta:
+ ordering = ['state']
+
+class Link(models.Model):
+ name = models.CharField(max_length=50)
+
+ def __unicode__(self):
+ return self.name
+
+ class Meta:
+ ordering = ['name']
+
+class Article(models.Model):
+ name = models.CharField(max_length=50)
+
+ def __unicode__(self):
+ return self.name
+
+ class Meta:
+ ordering = ['name']
+
+class FormTest(models.Model):
+ tags = TagField('Test', help_text='Test')
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/tests/settings.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,27 @@
+import os
+DIRNAME = os.path.dirname(__file__)
+
+DEFAULT_CHARSET = 'utf-8'
+
+test_engine = os.environ.get("TAGGING_TEST_ENGINE", "sqlite3")
+
+DATABASE_ENGINE = test_engine
+DATABASE_NAME = os.environ.get("TAGGING_DATABASE_NAME", "tagging_test")
+DATABASE_USER = os.environ.get("TAGGING_DATABASE_USER", "")
+DATABASE_PASSWORD = os.environ.get("TAGGING_DATABASE_PASSWORD", "")
+DATABASE_HOST = os.environ.get("TAGGING_DATABASE_HOST", "localhost")
+
+if test_engine == "sqlite":
+ DATABASE_NAME = os.path.join(DIRNAME, 'tagging_test.db')
+ DATABASE_HOST = ""
+elif test_engine == "mysql":
+ DATABASE_PORT = os.environ.get("TAGGING_DATABASE_PORT", 3306)
+elif test_engine == "postgresql_psycopg2":
+ DATABASE_PORT = os.environ.get("TAGGING_DATABASE_PORT", 5432)
+
+
+INSTALLED_APPS = (
+ 'django.contrib.contenttypes',
+ 'tagging',
+ 'tagging.tests',
+)
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/tests/tags.txt Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,122 @@
+NewMedia 53
+Website 45
+PR 44
+Status 44
+Collaboration 41
+Drupal 34
+Journalism 31
+Transparency 30
+Theory 29
+Decentralization 25
+EchoChamberProject 24
+OpenSource 23
+Film 22
+Blog 21
+Interview 21
+Political 21
+Worldview 21
+Communications 19
+Conference 19
+Folksonomy 15
+MediaCriticism 15
+Volunteer 15
+Dialogue 13
+InternationalLaw 13
+Rosen 12
+Evolution 11
+KentBye 11
+Objectivity 11
+Plante 11
+ToDo 11
+Advisor 10
+Civics 10
+Roadmap 10
+Wilber 9
+About 8
+CivicSpace 8
+Ecosystem 8
+Choice 7
+Murphy 7
+Sociology 7
+ACH 6
+del.icio.us 6
+IntelligenceAnalysis 6
+Science 6
+Credibility 5
+Distribution 5
+Diversity 5
+Errors 5
+FinalCutPro 5
+Fundraising 5
+Law 5
+PhilosophyofScience 5
+Podcast 5
+PoliticalBias 5
+Activism 4
+Analysis 4
+CBS 4
+DeceptionDetection 4
+Editing 4
+History 4
+RSS 4
+Social 4
+Subjectivity 4
+Vlog 4
+ABC 3
+ALTubes 3
+Economics 3
+FCC 3
+NYT 3
+Sirota 3
+Sundance 3
+Training 3
+Wiki 3
+XML 3
+Borger 2
+Brody 2
+Deliberation 2
+EcoVillage 2
+Identity 2
+LAMP 2
+Lobe 2
+Maine 2
+May 2
+MediaLogic 2
+Metaphor 2
+Mitchell 2
+NBC 2
+OHanlon 2
+Psychology 2
+Queen 2
+Software 2
+SpiralDynamics 2
+Strobel 2
+Sustainability 2
+Transcripts 2
+Brown 1
+Buddhism 1
+Community 1
+DigitalDivide 1
+Donnelly 1
+Education 1
+FairUse 1
+FireANT 1
+Google 1
+HumanRights 1
+KM 1
+Kwiatkowski 1
+Landay 1
+Loiseau 1
+Math 1
+Music 1
+Nature 1
+Schechter 1
+Screencast 1
+Sivaraksa 1
+Skype 1
+SocialCapital 1
+TagCloud 1
+Thielmann 1
+Thomas 1
+Tiger 1
+Wedgwood 1
\ No newline at end of file
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/tests/tests.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,901 @@
+# -*- coding: utf-8 -*-
+
+import os
+from django import forms
+from django.db.models import Q
+from django.test import TestCase
+from tagging.forms import TagField
+from tagging import settings
+from tagging.models import Tag, TaggedItem
+from tagging.tests.models import Article, Link, Perch, Parrot, FormTest
+from tagging.utils import calculate_cloud, edit_string_for_tags, get_tag_list, get_tag, parse_tag_input
+from tagging.utils import LINEAR
+
+#############
+# Utilities #
+#############
+
+class TestParseTagInput(TestCase):
+ def test_with_simple_space_delimited_tags(self):
+ """ Test with simple space-delimited tags. """
+
+ self.assertEquals(parse_tag_input('one'), [u'one'])
+ self.assertEquals(parse_tag_input('one two'), [u'one', u'two'])
+ self.assertEquals(parse_tag_input('one two three'), [u'one', u'three', u'two'])
+ self.assertEquals(parse_tag_input('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.assertEquals(parse_tag_input(',one'), [u'one'])
+ self.assertEquals(parse_tag_input(',one two'), [u'one two'])
+ self.assertEquals(parse_tag_input(',one two three'), [u'one two three'])
+ self.assertEquals(parse_tag_input('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.assertEquals(parse_tag_input('"one'), [u'one'])
+ self.assertEquals(parse_tag_input('"one two'), [u'one', u'two'])
+ self.assertEquals(parse_tag_input('"one two three'), [u'one', u'three', u'two'])
+ self.assertEquals(parse_tag_input('"one two"'), [u'one two'])
+ self.assertEquals(parse_tag_input('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.assertEquals(parse_tag_input('one two "thr,ee"'), [u'one', u'thr,ee', u'two'])
+
+ def test_with_loose_commas(self):
+ """ Loose commas - split on commas """
+ self.assertEquals(parse_tag_input('"one", two three'), [u'one', u'two three'])
+
+ def test_tags_with_double_quotes_can_contain_commas(self):
+ """ Double quotes can contain commas """
+ self.assertEquals(parse_tag_input('a-one "a-two, and a-three"'),
+ [u'a-one', u'a-two, and a-three'])
+ self.assertEquals(parse_tag_input('"two", one, one, two, "one"'),
+ [u'one', u'two'])
+
+ def test_with_naughty_input(self):
+ """ Test with naughty input. """
+
+ # Bad users! Naughty users!
+ self.assertEquals(parse_tag_input(None), [])
+ self.assertEquals(parse_tag_input(''), [])
+ self.assertEquals(parse_tag_input('"'), [])
+ self.assertEquals(parse_tag_input('""'), [])
+ self.assertEquals(parse_tag_input('"' * 7), [])
+ self.assertEquals(parse_tag_input(',,,,,,'), [])
+ self.assertEquals(parse_tag_input('",",",",",",","'), [u','])
+ self.assertEquals(parse_tag_input('a-one "a-two" and "a-three'),
+ [u'a-one', u'a-three', u'a-two', u'and'])
+
+class TestNormalisedTagListInput(TestCase):
+ def setUp(self):
+ self.cheese = Tag.objects.create(name='cheese')
+ self.toast = Tag.objects.create(name='toast')
+
+ def test_single_tag_object_as_input(self):
+ self.assertEquals(get_tag_list(self.cheese), [self.cheese])
+
+ def test_space_delimeted_string_as_input(self):
+ ret = get_tag_list('cheese toast')
+ self.assertEquals(len(ret), 2)
+ self.failUnless(self.cheese in ret)
+ self.failUnless(self.toast in ret)
+
+ def test_comma_delimeted_string_as_input(self):
+ ret = get_tag_list('cheese,toast')
+ self.assertEquals(len(ret), 2)
+ self.failUnless(self.cheese in ret)
+ self.failUnless(self.toast in ret)
+
+ def test_with_empty_list(self):
+ self.assertEquals(get_tag_list([]), [])
+
+ def test_list_of_two_strings(self):
+ ret = get_tag_list(['cheese', 'toast'])
+ self.assertEquals(len(ret), 2)
+ self.failUnless(self.cheese in ret)
+ self.failUnless(self.toast in ret)
+
+ def test_list_of_tag_primary_keys(self):
+ ret = get_tag_list([self.cheese.id, self.toast.id])
+ self.assertEquals(len(ret), 2)
+ self.failUnless(self.cheese in ret)
+ self.failUnless(self.toast in ret)
+
+ def test_list_of_strings_with_strange_nontag_string(self):
+ ret = get_tag_list(['cheese', 'toast', 'ŠĐĆŽćžšđ'])
+ self.assertEquals(len(ret), 2)
+ self.failUnless(self.cheese in ret)
+ self.failUnless(self.toast in ret)
+
+ def test_list_of_tag_instances(self):
+ ret = get_tag_list([self.cheese, self.toast])
+ self.assertEquals(len(ret), 2)
+ self.failUnless(self.cheese in ret)
+ self.failUnless(self.toast in ret)
+
+ def test_tuple_of_instances(self):
+ ret = get_tag_list((self.cheese, self.toast))
+ self.assertEquals(len(ret), 2)
+ self.failUnless(self.cheese in ret)
+ self.failUnless(self.toast in ret)
+
+ def test_with_tag_filter(self):
+ ret = get_tag_list(Tag.objects.filter(name__in=['cheese', 'toast']))
+ self.assertEquals(len(ret), 2)
+ self.failUnless(self.cheese in ret)
+ self.failUnless(self.toast in ret)
+
+ def test_with_invalid_input_mix_of_string_and_instance(self):
+ try:
+ get_tag_list(['cheese', self.toast])
+ except ValueError, ve:
+ self.assertEquals(str(ve),
+ 'If a list or tuple of tags is provided, they must all be tag names, Tag objects or Tag ids.')
+ except Exception, e:
+ raise self.failureException('the wrong type of exception was raised: type [%s] value [%]' %\
+ (str(type(e)), str(e)))
+ else:
+ raise self.failureException('a ValueError exception was supposed to be raised!')
+
+ def test_with_invalid_input(self):
+ try:
+ get_tag_list(29)
+ except ValueError, ve:
+ self.assertEquals(str(ve), 'The tag input given was invalid.')
+ except Exception, e:
+ raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\
+ (str(type(e)), str(e)))
+ else:
+ raise self.failureException('a ValueError exception was supposed to be raised!')
+
+ def test_with_tag_instance(self):
+ self.assertEquals(get_tag(self.cheese), self.cheese)
+
+ def test_with_string(self):
+ self.assertEquals(get_tag('cheese'), self.cheese)
+
+ def test_with_primary_key(self):
+ self.assertEquals(get_tag(self.cheese.id), self.cheese)
+
+ def test_nonexistent_tag(self):
+ self.assertEquals(get_tag('mouse'), None)
+
+class TestCalculateCloud(TestCase):
+ def setUp(self):
+ self.tags = []
+ for line in open(os.path.join(os.path.dirname(__file__), 'tags.txt')).readlines():
+ name, count = line.rstrip().split()
+ tag = Tag(name=name)
+ tag.count = int(count)
+ self.tags.append(tag)
+
+ def test_default_distribution(self):
+ sizes = {}
+ for tag in calculate_cloud(self.tags, steps=5):
+ sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1
+
+ # This isn't a pre-calculated test, just making sure it's consistent
+ self.assertEquals(sizes[1], 48)
+ self.assertEquals(sizes[2], 30)
+ self.assertEquals(sizes[3], 19)
+ self.assertEquals(sizes[4], 15)
+ self.assertEquals(sizes[5], 10)
+
+ def test_linear_distribution(self):
+ sizes = {}
+ for tag in calculate_cloud(self.tags, steps=5, distribution=LINEAR):
+ sizes[tag.font_size] = sizes.get(tag.font_size, 0) + 1
+
+ # This isn't a pre-calculated test, just making sure it's consistent
+ self.assertEquals(sizes[1], 97)
+ self.assertEquals(sizes[2], 12)
+ self.assertEquals(sizes[3], 7)
+ self.assertEquals(sizes[4], 2)
+ self.assertEquals(sizes[5], 4)
+
+ def test_invalid_distribution(self):
+ try:
+ calculate_cloud(self.tags, steps=5, distribution='cheese')
+ except ValueError, ve:
+ self.assertEquals(str(ve), 'Invalid distribution algorithm specified: cheese.')
+ except Exception, e:
+ raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\
+ (str(type(e)), str(e)))
+ else:
+ raise self.failureException('a ValueError exception was supposed to be raised!')
+
+###########
+# Tagging #
+###########
+
+class TestBasicTagging(TestCase):
+ def setUp(self):
+ self.dead_parrot = Parrot.objects.create(state='dead')
+
+ def test_update_tags(self):
+ Tag.objects.update_tags(self.dead_parrot, 'foo,bar,"ter"')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ self.failUnless(get_tag('foo') in tags)
+ self.failUnless(get_tag('bar') in tags)
+ self.failUnless(get_tag('ter') in tags)
+
+ Tag.objects.update_tags(self.dead_parrot, '"foo" bar "baz"')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ self.failUnless(get_tag('bar') in tags)
+ self.failUnless(get_tag('baz') in tags)
+ self.failUnless(get_tag('foo') in tags)
+
+ def test_add_tag(self):
+ # start off in a known, mildly interesting state
+ Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ self.failUnless(get_tag('bar') in tags)
+ self.failUnless(get_tag('baz') in tags)
+ self.failUnless(get_tag('foo') in tags)
+
+ # try to add a tag that already exists
+ Tag.objects.add_tag(self.dead_parrot, 'foo')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ self.failUnless(get_tag('bar') in tags)
+ self.failUnless(get_tag('baz') in tags)
+ self.failUnless(get_tag('foo') in tags)
+
+ # now add a tag that doesn't already exist
+ Tag.objects.add_tag(self.dead_parrot, 'zip')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 4)
+ self.failUnless(get_tag('zip') in tags)
+ self.failUnless(get_tag('bar') in tags)
+ self.failUnless(get_tag('baz') in tags)
+ self.failUnless(get_tag('foo') in tags)
+
+ def test_add_tag_invalid_input_no_tags_specified(self):
+ # start off in a known, mildly interesting state
+ Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ self.failUnless(get_tag('bar') in tags)
+ self.failUnless(get_tag('baz') in tags)
+ self.failUnless(get_tag('foo') in tags)
+
+ try:
+ Tag.objects.add_tag(self.dead_parrot, ' ')
+ except AttributeError, ae:
+ self.assertEquals(str(ae), 'No tags were given: " ".')
+ except Exception, e:
+ raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\
+ (str(type(e)), str(e)))
+ else:
+ raise self.failureException('an AttributeError exception was supposed to be raised!')
+
+ def test_add_tag_invalid_input_multiple_tags_specified(self):
+ # start off in a known, mildly interesting state
+ Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ self.failUnless(get_tag('bar') in tags)
+ self.failUnless(get_tag('baz') in tags)
+ self.failUnless(get_tag('foo') in tags)
+
+ try:
+ Tag.objects.add_tag(self.dead_parrot, 'one two')
+ except AttributeError, ae:
+ self.assertEquals(str(ae), 'Multiple tags were given: "one two".')
+ except Exception, e:
+ raise self.failureException('the wrong type of exception was raised: type [%s] value [%s]' %\
+ (str(type(e)), str(e)))
+ else:
+ raise self.failureException('an AttributeError exception was supposed to be raised!')
+
+ def test_update_tags_exotic_characters(self):
+ # start off in a known, mildly interesting state
+ Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ self.failUnless(get_tag('bar') in tags)
+ self.failUnless(get_tag('baz') in tags)
+ self.failUnless(get_tag('foo') in tags)
+
+ Tag.objects.update_tags(self.dead_parrot, u'ŠĐĆŽćžšđ')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 1)
+ self.assertEquals(tags[0].name, u'ŠĐĆŽćžšđ')
+
+ Tag.objects.update_tags(self.dead_parrot, u'你好')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 1)
+ self.assertEquals(tags[0].name, u'你好')
+
+ def test_update_tags_with_none(self):
+ # start off in a known, mildly interesting state
+ Tag.objects.update_tags(self.dead_parrot, 'foo bar baz')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ self.failUnless(get_tag('bar') in tags)
+ self.failUnless(get_tag('baz') in tags)
+ self.failUnless(get_tag('foo') in tags)
+
+ Tag.objects.update_tags(self.dead_parrot, None)
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 0)
+
+class TestModelTagField(TestCase):
+ """ Test the 'tags' field on models. """
+
+ def test_create_with_tags_specified(self):
+ f1 = FormTest.objects.create(tags=u'test3 test2 test1')
+ tags = Tag.objects.get_for_object(f1)
+ test1_tag = get_tag('test1')
+ test2_tag = get_tag('test2')
+ test3_tag = get_tag('test3')
+ self.failUnless(None not in (test1_tag, test2_tag, test3_tag))
+ self.assertEquals(len(tags), 3)
+ self.failUnless(test1_tag in tags)
+ self.failUnless(test2_tag in tags)
+ self.failUnless(test3_tag in tags)
+
+ def test_update_via_tags_field(self):
+ f1 = FormTest.objects.create(tags=u'test3 test2 test1')
+ tags = Tag.objects.get_for_object(f1)
+ test1_tag = get_tag('test1')
+ test2_tag = get_tag('test2')
+ test3_tag = get_tag('test3')
+ self.failUnless(None not in (test1_tag, test2_tag, test3_tag))
+ self.assertEquals(len(tags), 3)
+ self.failUnless(test1_tag in tags)
+ self.failUnless(test2_tag in tags)
+ self.failUnless(test3_tag in tags)
+
+ f1.tags = u'test4'
+ f1.save()
+ tags = Tag.objects.get_for_object(f1)
+ test4_tag = get_tag('test4')
+ self.assertEquals(len(tags), 1)
+ self.assertEquals(tags[0], test4_tag)
+
+ f1.tags = ''
+ f1.save()
+ tags = Tag.objects.get_for_object(f1)
+ self.assertEquals(len(tags), 0)
+
+class TestSettings(TestCase):
+ def setUp(self):
+ self.original_force_lower_case_tags = settings.FORCE_LOWERCASE_TAGS
+ self.dead_parrot = Parrot.objects.create(state='dead')
+
+ def tearDown(self):
+ settings.FORCE_LOWERCASE_TAGS = self.original_force_lower_case_tags
+
+ def test_force_lowercase_tags(self):
+ """ Test forcing tags to lowercase. """
+
+ settings.FORCE_LOWERCASE_TAGS = True
+
+ Tag.objects.update_tags(self.dead_parrot, 'foO bAr Ter')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ foo_tag = get_tag('foo')
+ bar_tag = get_tag('bar')
+ ter_tag = get_tag('ter')
+ self.failUnless(foo_tag in tags)
+ self.failUnless(bar_tag in tags)
+ self.failUnless(ter_tag in tags)
+
+ Tag.objects.update_tags(self.dead_parrot, 'foO bAr baZ')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ baz_tag = get_tag('baz')
+ self.assertEquals(len(tags), 3)
+ self.failUnless(bar_tag in tags)
+ self.failUnless(baz_tag in tags)
+ self.failUnless(foo_tag in tags)
+
+ Tag.objects.add_tag(self.dead_parrot, 'FOO')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 3)
+ self.failUnless(bar_tag in tags)
+ self.failUnless(baz_tag in tags)
+ self.failUnless(foo_tag in tags)
+
+ Tag.objects.add_tag(self.dead_parrot, 'Zip')
+ tags = Tag.objects.get_for_object(self.dead_parrot)
+ self.assertEquals(len(tags), 4)
+ zip_tag = get_tag('zip')
+ self.failUnless(bar_tag in tags)
+ self.failUnless(baz_tag in tags)
+ self.failUnless(foo_tag in tags)
+ self.failUnless(zip_tag in tags)
+
+ f1 = FormTest.objects.create()
+ f1.tags = u'TEST5'
+ f1.save()
+ tags = Tag.objects.get_for_object(f1)
+ test5_tag = get_tag('test5')
+ self.assertEquals(len(tags), 1)
+ self.failUnless(test5_tag in tags)
+ self.assertEquals(f1.tags, u'test5')
+
+class TestTagUsageForModelBaseCase(TestCase):
+ def test_tag_usage_for_model_empty(self):
+ self.assertEquals(Tag.objects.usage_for_model(Parrot), [])
+
+class TestTagUsageForModel(TestCase):
+ def setUp(self):
+ parrot_details = (
+ ('pining for the fjords', 9, True, 'foo bar'),
+ ('passed on', 6, False, 'bar baz ter'),
+ ('no more', 4, True, 'foo ter'),
+ ('late', 2, False, 'bar ter'),
+ )
+
+ for state, perch_size, perch_smelly, tags in parrot_details:
+ perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
+ parrot = Parrot.objects.create(state=state, perch=perch)
+ Tag.objects.update_tags(parrot, tags)
+
+ def test_tag_usage_for_model(self):
+ tag_usage = Tag.objects.usage_for_model(Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 4)
+ self.failUnless((u'bar', 3) in relevant_attribute_list)
+ self.failUnless((u'baz', 1) in relevant_attribute_list)
+ self.failUnless((u'foo', 2) in relevant_attribute_list)
+ self.failUnless((u'ter', 3) in relevant_attribute_list)
+
+ def test_tag_usage_for_model_with_min_count(self):
+ tag_usage = Tag.objects.usage_for_model(Parrot, min_count = 2)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless((u'bar', 3) in relevant_attribute_list)
+ self.failUnless((u'foo', 2) in relevant_attribute_list)
+ self.failUnless((u'ter', 3) in relevant_attribute_list)
+
+ def test_tag_usage_with_filter_on_model_objects(self):
+ tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(state='no more'))
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 2)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(state__startswith='p'))
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 4)
+ self.failUnless((u'bar', 2) in relevant_attribute_list)
+ self.failUnless((u'baz', 1) in relevant_attribute_list)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(perch__size__gt=4))
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 4)
+ self.failUnless((u'bar', 2) in relevant_attribute_list)
+ self.failUnless((u'baz', 1) in relevant_attribute_list)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(Parrot, counts=True, filters=dict(perch__smelly=True))
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless((u'bar', 1) in relevant_attribute_list)
+ self.failUnless((u'foo', 2) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(Parrot, min_count=2, filters=dict(perch__smelly=True))
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 1)
+ self.failUnless((u'foo', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(Parrot, filters=dict(perch__size__gt=4))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 4)
+ self.failUnless((u'bar', False) in relevant_attribute_list)
+ self.failUnless((u'baz', False) in relevant_attribute_list)
+ self.failUnless((u'foo', False) in relevant_attribute_list)
+ self.failUnless((u'ter', False) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_model(Parrot, filters=dict(perch__size__gt=99))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 0)
+
+class TestTagsRelatedForModel(TestCase):
+ def setUp(self):
+ parrot_details = (
+ ('pining for the fjords', 9, True, 'foo bar'),
+ ('passed on', 6, False, 'bar baz ter'),
+ ('no more', 4, True, 'foo ter'),
+ ('late', 2, False, 'bar ter'),
+ )
+
+ for state, perch_size, perch_smelly, tags in parrot_details:
+ perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
+ parrot = Parrot.objects.create(state=state, perch=perch)
+ Tag.objects.update_tags(parrot, tags)
+
+ def test_related_for_model_with_tag_query_sets_as_input(self):
+ related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar']), Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless((u'baz', 1) in relevant_attribute_list)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 2) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar']), Parrot, min_count=2)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 1)
+ self.failUnless((u'ter', 2) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar']), Parrot, counts=False)
+ relevant_attribute_list = [tag.name for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless(u'baz' in relevant_attribute_list)
+ self.failUnless(u'foo' in relevant_attribute_list)
+ self.failUnless(u'ter' in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar', 'ter']), Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 1)
+ self.failUnless((u'baz', 1) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(Tag.objects.filter(name__in=['bar', 'ter', 'baz']), Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 0)
+
+ def test_related_for_model_with_tag_strings_as_input(self):
+ # Once again, with feeling (strings)
+ related_tags = Tag.objects.related_for_model('bar', Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless((u'baz', 1) in relevant_attribute_list)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 2) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model('bar', Parrot, min_count=2)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 1)
+ self.failUnless((u'ter', 2) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model('bar', Parrot, counts=False)
+ relevant_attribute_list = [tag.name for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless(u'baz' in relevant_attribute_list)
+ self.failUnless(u'foo' in relevant_attribute_list)
+ self.failUnless(u'ter' in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(['bar', 'ter'], Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 1)
+ self.failUnless((u'baz', 1) in relevant_attribute_list)
+
+ related_tags = Tag.objects.related_for_model(['bar', 'ter', 'baz'], Parrot, counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in related_tags]
+ self.assertEquals(len(relevant_attribute_list), 0)
+
+class TestGetTaggedObjectsByModel(TestCase):
+ def setUp(self):
+ parrot_details = (
+ ('pining for the fjords', 9, True, 'foo bar'),
+ ('passed on', 6, False, 'bar baz ter'),
+ ('no more', 4, True, 'foo ter'),
+ ('late', 2, False, 'bar ter'),
+ )
+
+ for state, perch_size, perch_smelly, tags in parrot_details:
+ perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
+ parrot = Parrot.objects.create(state=state, perch=perch)
+ Tag.objects.update_tags(parrot, tags)
+
+ self.foo = Tag.objects.get(name='foo')
+ self.bar = Tag.objects.get(name='bar')
+ self.baz = Tag.objects.get(name='baz')
+ self.ter = Tag.objects.get(name='ter')
+
+ self.pining_for_the_fjords_parrot = Parrot.objects.get(state='pining for the fjords')
+ self.passed_on_parrot = Parrot.objects.get(state='passed on')
+ self.no_more_parrot = Parrot.objects.get(state='no more')
+ self.late_parrot = Parrot.objects.get(state='late')
+
+ def test_get_by_model_simple(self):
+ parrots = TaggedItem.objects.get_by_model(Parrot, self.foo)
+ self.assertEquals(len(parrots), 2)
+ self.failUnless(self.no_more_parrot in parrots)
+ self.failUnless(self.pining_for_the_fjords_parrot in parrots)
+
+ parrots = TaggedItem.objects.get_by_model(Parrot, self.bar)
+ self.assertEquals(len(parrots), 3)
+ self.failUnless(self.late_parrot in parrots)
+ self.failUnless(self.passed_on_parrot in parrots)
+ self.failUnless(self.pining_for_the_fjords_parrot in parrots)
+
+ def test_get_by_model_intersection(self):
+ parrots = TaggedItem.objects.get_by_model(Parrot, [self.foo, self.baz])
+ self.assertEquals(len(parrots), 0)
+
+ parrots = TaggedItem.objects.get_by_model(Parrot, [self.foo, self.bar])
+ self.assertEquals(len(parrots), 1)
+ self.failUnless(self.pining_for_the_fjords_parrot in parrots)
+
+ parrots = TaggedItem.objects.get_by_model(Parrot, [self.bar, self.ter])
+ self.assertEquals(len(parrots), 2)
+ self.failUnless(self.late_parrot in parrots)
+ self.failUnless(self.passed_on_parrot in parrots)
+
+ # Issue 114 - Intersection with non-existant tags
+ parrots = TaggedItem.objects.get_intersection_by_model(Parrot, [])
+ self.assertEquals(len(parrots), 0)
+
+ def test_get_by_model_with_tag_querysets_as_input(self):
+ parrots = TaggedItem.objects.get_by_model(Parrot, Tag.objects.filter(name__in=['foo', 'baz']))
+ self.assertEquals(len(parrots), 0)
+
+ parrots = TaggedItem.objects.get_by_model(Parrot, Tag.objects.filter(name__in=['foo', 'bar']))
+ self.assertEquals(len(parrots), 1)
+ self.failUnless(self.pining_for_the_fjords_parrot in parrots)
+
+ parrots = TaggedItem.objects.get_by_model(Parrot, Tag.objects.filter(name__in=['bar', 'ter']))
+ self.assertEquals(len(parrots), 2)
+ self.failUnless(self.late_parrot in parrots)
+ self.failUnless(self.passed_on_parrot in parrots)
+
+ def test_get_by_model_with_strings_as_input(self):
+ parrots = TaggedItem.objects.get_by_model(Parrot, 'foo baz')
+ self.assertEquals(len(parrots), 0)
+
+ parrots = TaggedItem.objects.get_by_model(Parrot, 'foo bar')
+ self.assertEquals(len(parrots), 1)
+ self.failUnless(self.pining_for_the_fjords_parrot in parrots)
+
+ parrots = TaggedItem.objects.get_by_model(Parrot, 'bar ter')
+ self.assertEquals(len(parrots), 2)
+ self.failUnless(self.late_parrot in parrots)
+ self.failUnless(self.passed_on_parrot in parrots)
+
+ def test_get_by_model_with_lists_of_strings_as_input(self):
+ parrots = TaggedItem.objects.get_by_model(Parrot, ['foo', 'baz'])
+ self.assertEquals(len(parrots), 0)
+
+ parrots = TaggedItem.objects.get_by_model(Parrot, ['foo', 'bar'])
+ self.assertEquals(len(parrots), 1)
+ self.failUnless(self.pining_for_the_fjords_parrot in parrots)
+
+ parrots = TaggedItem.objects.get_by_model(Parrot, ['bar', 'ter'])
+ self.assertEquals(len(parrots), 2)
+ self.failUnless(self.late_parrot in parrots)
+ self.failUnless(self.passed_on_parrot in parrots)
+
+ def test_get_by_nonexistent_tag(self):
+ # Issue 50 - Get by non-existent tag
+ parrots = TaggedItem.objects.get_by_model(Parrot, 'argatrons')
+ self.assertEquals(len(parrots), 0)
+
+ def test_get_union_by_model(self):
+ parrots = TaggedItem.objects.get_union_by_model(Parrot, ['foo', 'ter'])
+ self.assertEquals(len(parrots), 4)
+ self.failUnless(self.late_parrot in parrots)
+ self.failUnless(self.no_more_parrot in parrots)
+ self.failUnless(self.passed_on_parrot in parrots)
+ self.failUnless(self.pining_for_the_fjords_parrot in parrots)
+
+ parrots = TaggedItem.objects.get_union_by_model(Parrot, ['bar', 'baz'])
+ self.assertEquals(len(parrots), 3)
+ self.failUnless(self.late_parrot in parrots)
+ self.failUnless(self.passed_on_parrot in parrots)
+ self.failUnless(self.pining_for_the_fjords_parrot in parrots)
+
+ # Issue 114 - Union with non-existant tags
+ parrots = TaggedItem.objects.get_union_by_model(Parrot, [])
+ self.assertEquals(len(parrots), 0)
+
+class TestGetRelatedTaggedItems(TestCase):
+ def setUp(self):
+ parrot_details = (
+ ('pining for the fjords', 9, True, 'foo bar'),
+ ('passed on', 6, False, 'bar baz ter'),
+ ('no more', 4, True, 'foo ter'),
+ ('late', 2, False, 'bar ter'),
+ )
+
+ for state, perch_size, perch_smelly, tags in parrot_details:
+ perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
+ parrot = Parrot.objects.create(state=state, perch=perch)
+ Tag.objects.update_tags(parrot, tags)
+
+ self.l1 = Link.objects.create(name='link 1')
+ Tag.objects.update_tags(self.l1, 'tag1 tag2 tag3 tag4 tag5')
+ self.l2 = Link.objects.create(name='link 2')
+ Tag.objects.update_tags(self.l2, 'tag1 tag2 tag3')
+ self.l3 = Link.objects.create(name='link 3')
+ Tag.objects.update_tags(self.l3, 'tag1')
+ self.l4 = Link.objects.create(name='link 4')
+
+ self.a1 = Article.objects.create(name='article 1')
+ Tag.objects.update_tags(self.a1, 'tag1 tag2 tag3 tag4')
+
+ def test_get_related_objects_of_same_model(self):
+ related_objects = TaggedItem.objects.get_related(self.l1, Link)
+ self.assertEquals(len(related_objects), 2)
+ self.failUnless(self.l2 in related_objects)
+ self.failUnless(self.l3 in related_objects)
+
+ related_objects = TaggedItem.objects.get_related(self.l4, Link)
+ self.assertEquals(len(related_objects), 0)
+
+ def test_get_related_objects_of_same_model_limited_number_of_results(self):
+ # This fails on Oracle because it has no support for a 'LIMIT' clause.
+ # See http://asktom.oracle.com/pls/asktom/f?p=100:11:0::::P11_QUESTION_ID:127412348064
+
+ # ask for no more than 1 result
+ related_objects = TaggedItem.objects.get_related(self.l1, Link, num=1)
+ self.assertEquals(len(related_objects), 1)
+ self.failUnless(self.l2 in related_objects)
+
+ def test_get_related_objects_of_same_model_limit_related_items(self):
+ related_objects = TaggedItem.objects.get_related(self.l1, Link.objects.exclude(name='link 3'))
+ self.assertEquals(len(related_objects), 1)
+ self.failUnless(self.l2 in related_objects)
+
+ def test_get_related_objects_of_different_model(self):
+ related_objects = TaggedItem.objects.get_related(self.a1, Link)
+ self.assertEquals(len(related_objects), 3)
+ self.failUnless(self.l1 in related_objects)
+ self.failUnless(self.l2 in related_objects)
+ self.failUnless(self.l3 in related_objects)
+
+ Tag.objects.update_tags(self.a1, 'tag6')
+ related_objects = TaggedItem.objects.get_related(self.a1, Link)
+ self.assertEquals(len(related_objects), 0)
+
+class TestTagUsageForQuerySet(TestCase):
+ def setUp(self):
+ parrot_details = (
+ ('pining for the fjords', 9, True, 'foo bar'),
+ ('passed on', 6, False, 'bar baz ter'),
+ ('no more', 4, True, 'foo ter'),
+ ('late', 2, False, 'bar ter'),
+ )
+
+ for state, perch_size, perch_smelly, tags in parrot_details:
+ perch = Perch.objects.create(size=perch_size, smelly=perch_smelly)
+ parrot = Parrot.objects.create(state=state, perch=perch)
+ Tag.objects.update_tags(parrot, tags)
+
+ def test_tag_usage_for_queryset(self):
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(state='no more'), counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 2)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(state__startswith='p'), counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 4)
+ self.failUnless((u'bar', 2) in relevant_attribute_list)
+ self.failUnless((u'baz', 1) in relevant_attribute_list)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__size__gt=4), counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 4)
+ self.failUnless((u'bar', 2) in relevant_attribute_list)
+ self.failUnless((u'baz', 1) in relevant_attribute_list)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__smelly=True), counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless((u'bar', 1) in relevant_attribute_list)
+ self.failUnless((u'foo', 2) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__smelly=True), min_count=2)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 1)
+ self.failUnless((u'foo', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__size__gt=4))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 4)
+ self.failUnless((u'bar', False) in relevant_attribute_list)
+ self.failUnless((u'baz', False) in relevant_attribute_list)
+ self.failUnless((u'foo', False) in relevant_attribute_list)
+ self.failUnless((u'ter', False) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(perch__size__gt=99))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 0)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(Q(perch__size__gt=6) | Q(state__startswith='l')), counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless((u'bar', 2) in relevant_attribute_list)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(Q(perch__size__gt=6) | Q(state__startswith='l')), min_count=2)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 1)
+ self.failUnless((u'bar', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.filter(Q(perch__size__gt=6) | Q(state__startswith='l')))
+ relevant_attribute_list = [(tag.name, hasattr(tag, 'counts')) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless((u'bar', False) in relevant_attribute_list)
+ self.failUnless((u'foo', False) in relevant_attribute_list)
+ self.failUnless((u'ter', False) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(state='passed on'), counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 3)
+ self.failUnless((u'bar', 2) in relevant_attribute_list)
+ self.failUnless((u'foo', 2) in relevant_attribute_list)
+ self.failUnless((u'ter', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(state__startswith='p'), min_count=2)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 1)
+ self.failUnless((u'ter', 2) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(Q(perch__size__gt=6) | Q(perch__smelly=False)), counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 2)
+ self.failUnless((u'foo', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+ tag_usage = Tag.objects.usage_for_queryset(Parrot.objects.exclude(perch__smelly=True).filter(state__startswith='l'), counts=True)
+ relevant_attribute_list = [(tag.name, tag.count) for tag in tag_usage]
+ self.assertEquals(len(relevant_attribute_list), 2)
+ self.failUnless((u'bar', 1) in relevant_attribute_list)
+ self.failUnless((u'ter', 1) in relevant_attribute_list)
+
+################
+# Model Fields #
+################
+
+class TestTagFieldInForms(TestCase):
+ def test_tag_field_in_modelform(self):
+ # Ensure that automatically created forms use TagField
+ class TestForm(forms.ModelForm):
+ class Meta:
+ model = FormTest
+
+ form = TestForm()
+ self.assertEquals(form.fields['tags'].__class__.__name__, 'TagField')
+
+ 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.assertEquals(edit_string_for_tags([plain]), u'plain')
+ self.assertEquals(edit_string_for_tags([plain, spaces]), u'plain, spa ces')
+ self.assertEquals(edit_string_for_tags([plain, spaces, comma]), u'plain, spa ces, "com,ma"')
+ self.assertEquals(edit_string_for_tags([plain, comma]), u'plain "com,ma"')
+ self.assertEquals(edit_string_for_tags([comma, spaces]), u'"com,ma", spa ces')
+
+ def test_tag_d_validation(self):
+ t = TagField()
+ self.assertEquals(t.clean('foo'), u'foo')
+ self.assertEquals(t.clean('foo bar baz'), u'foo bar baz')
+ self.assertEquals(t.clean('foo,bar,baz'), u'foo,bar,baz')
+ self.assertEquals(t.clean('foo, bar, baz'), u'foo, bar, baz')
+ self.assertEquals(t.clean('foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvb bar'),
+ u'foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvb bar')
+ try:
+ t.clean('foo qwertyuiopasdfghjklzxcvbnmqwertyuiopasdfghjklzxcvbn bar')
+ except forms.ValidationError, ve:
+ self.assertEquals(str(ve), "[u'Each tag may be no more than 50 characters long.']")
+ except Exception, e:
+ raise e
+ else:
+ raise self.failureException('a ValidationError exception was supposed to have been raised.')
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/utils.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,263 @@
+"""
+Tagging utilities - from user tag input parsing to tag cloud
+calculation.
+"""
+import math
+import types
+
+from django.db.models.query import QuerySet
+from django.utils.encoding import force_unicode
+from django.utils.translation import ugettext as _
+
+# Python 2.3 compatibility
+try:
+ set
+except NameError:
+ from sets import Set as set
+
+def parse_tag_input(input):
+ """
+ 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.
+ """
+ if not input:
+ return []
+
+ input = force_unicode(input)
+
+ # 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 input and u'"' not in input:
+ words = list(set(split_strip(input, 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(input)
+ try:
+ while 1:
+ 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(input, delimiter=u','):
+ """
+ Splits ``input`` on ``delimiter``, stripping each resulting string
+ and returning a list of non-empty strings.
+ """
+ if not input:
+ return []
+
+ words = [w.strip() for w in input.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.
+ """
+ names = []
+ use_commas = False
+ for tag in tags:
+ name = tag.name
+ if u',' in name:
+ names.append('"%s"' % name)
+ continue
+ elif u' ' in name:
+ if not use_commas:
+ use_commas = True
+ names.append(name)
+ if use_commas:
+ glue = u', '
+ else:
+ glue = u' '
+ return glue.join(names)
+
+def get_queryset_and_model(queryset_or_model):
+ """
+ Given a ``QuerySet`` or a ``Model``, returns a two-tuple of
+ (queryset, model).
+
+ If a ``Model`` is given, the ``QuerySet`` returned will be created
+ using its default manager.
+ """
+ try:
+ return queryset_or_model, queryset_or_model.model
+ except AttributeError:
+ return queryset_or_model._default_manager.all(), queryset_or_model
+
+def get_tag_list(tags):
+ """
+ Utility function for accepting tag input in a flexible manner.
+
+ If a ``Tag`` object is given, it will be returned in a list as
+ its single occupant.
+
+ If given, the tag names in the following will be used to create a
+ ``Tag`` ``QuerySet``:
+
+ * A string, which may contain multiple tag names.
+ * A list or tuple of strings corresponding to tag names.
+ * A list or tuple of integers corresponding to tag ids.
+
+ If given, the following will be returned as-is:
+
+ * A list or tuple of ``Tag`` objects.
+ * A ``Tag`` ``QuerySet``.
+
+ """
+ from tagging.models import Tag
+ if isinstance(tags, Tag):
+ return [tags]
+ elif isinstance(tags, QuerySet) and tags.model is Tag:
+ return tags
+ elif isinstance(tags, types.StringTypes):
+ return Tag.objects.filter(name__in=parse_tag_input(tags))
+ elif isinstance(tags, (types.ListType, types.TupleType)):
+ if len(tags) == 0:
+ return tags
+ contents = set()
+ for item in tags:
+ if isinstance(item, types.StringTypes):
+ contents.add('string')
+ elif isinstance(item, Tag):
+ contents.add('tag')
+ elif isinstance(item, (types.IntType, types.LongType)):
+ contents.add('int')
+ if len(contents) == 1:
+ if 'string' in contents:
+ return Tag.objects.filter(name__in=[force_unicode(tag) \
+ for tag in tags])
+ elif 'tag' in contents:
+ return tags
+ elif 'int' in contents:
+ return Tag.objects.filter(id__in=tags)
+ else:
+ raise ValueError(_('If a list or tuple of tags is provided, they must all be tag names, Tag objects or Tag ids.'))
+ else:
+ raise ValueError(_('The tag input given was invalid.'))
+
+def get_tag(tag):
+ """
+ Utility function for accepting single tag input in a flexible
+ manner.
+
+ If a ``Tag`` object is given it will be returned as-is; if a
+ string or integer are given, they will be used to lookup the
+ appropriate ``Tag``.
+
+ If no matching tag can be found, ``None`` will be returned.
+ """
+ from tagging.models import Tag
+ if isinstance(tag, Tag):
+ return tag
+
+ try:
+ if isinstance(tag, types.StringTypes):
+ return Tag.objects.get(name=tag)
+ elif isinstance(tag, (types.IntType, types.LongType)):
+ return Tag.objects.get(id=tag)
+ except Tag.DoesNotExist:
+ pass
+
+ return None
+
+# Font size distribution algorithms
+LOGARITHMIC, LINEAR = 1, 2
+
+def _calculate_thresholds(min_weight, max_weight, steps):
+ delta = (max_weight - min_weight) / float(steps)
+ return [min_weight + i * delta for i in range(1, steps + 1)]
+
+def _calculate_tag_weight(weight, max_weight, distribution):
+ """
+ Logarithmic tag weight calculation is based on code from the
+ `Tag Cloud`_ plugin for Mephisto, by Sven Fuchs.
+
+ .. _`Tag Cloud`: http://www.artweb-design.de/projects/mephisto-plugin-tag-cloud
+ """
+ if distribution == LINEAR or max_weight == 1:
+ return weight
+ elif distribution == LOGARITHMIC:
+ return math.log(weight) * max_weight / math.log(max_weight)
+ raise ValueError(_('Invalid distribution algorithm specified: %s.') % distribution)
+
+def calculate_cloud(tags, steps=4, distribution=LOGARITHMIC):
+ """
+ Add a ``font_size`` attribute to each tag according to the
+ frequency of its use, as indicated by its ``count``
+ attribute.
+
+ ``steps`` defines the range of font sizes - ``font_size`` will
+ be an integer between 1 and ``steps`` (inclusive).
+
+ ``distribution`` defines the type of font size distribution
+ algorithm which will be used - logarithmic or linear. It must be
+ one of ``tagging.utils.LOGARITHMIC`` or ``tagging.utils.LINEAR``.
+ """
+ if len(tags) > 0:
+ counts = [tag.count for tag in tags]
+ min_weight = float(min(counts))
+ max_weight = float(max(counts))
+ thresholds = _calculate_thresholds(min_weight, max_weight, steps)
+ for tag in tags:
+ font_set = False
+ tag_weight = _calculate_tag_weight(tag.count, max_weight, distribution)
+ for i in range(steps):
+ if not font_set and tag_weight <= thresholds[i]:
+ tag.font_size = i + 1
+ font_set = True
+ return tags
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/web/lib/tagging/views.py Fri Jan 22 18:23:34 2010 +0100
@@ -0,0 +1,52 @@
+"""
+Tagging related views.
+"""
+from django.http import Http404
+from django.utils.translation import ugettext as _
+from django.views.generic.list_detail import object_list
+
+from tagging.models import Tag, TaggedItem
+from tagging.utils import get_tag, get_queryset_and_model
+
+def tagged_object_list(request, queryset_or_model=None, tag=None,
+ related_tags=False, related_tag_counts=True, **kwargs):
+ """
+ A thin wrapper around
+ ``django.views.generic.list_detail.object_list`` which creates a
+ ``QuerySet`` containing instances of the given queryset or model
+ tagged with the given tag.
+
+ In addition to the context variables set up by ``object_list``, a
+ ``tag`` context variable will contain the ``Tag`` instance for the
+ tag.
+
+ If ``related_tags`` is ``True``, a ``related_tags`` context variable
+ will contain tags related to the given tag for the given model.
+ Additionally, if ``related_tag_counts`` is ``True``, each related
+ tag will have a ``count`` attribute indicating the number of items
+ which have it in addition to the given tag.
+ """
+ if queryset_or_model is None:
+ try:
+ queryset_or_model = kwargs.pop('queryset_or_model')
+ except KeyError:
+ raise AttributeError(_('tagged_object_list must be called with a queryset or a model.'))
+
+ if tag is None:
+ try:
+ tag = kwargs.pop('tag')
+ except KeyError:
+ raise AttributeError(_('tagged_object_list must be called with a tag.'))
+
+ tag_instance = get_tag(tag)
+ if tag_instance is None:
+ raise Http404(_('No Tag found matching "%s".') % tag)
+ queryset = TaggedItem.objects.get_by_model(queryset_or_model, tag_instance)
+ if not kwargs.has_key('extra_context'):
+ kwargs['extra_context'] = {}
+ kwargs['extra_context']['tag'] = tag_instance
+ if related_tags:
+ kwargs['extra_context']['related_tags'] = \
+ Tag.objects.related_for_model(tag_instance, queryset_or_model,
+ counts=related_tag_counts)
+ return object_list(request, queryset, **kwargs)