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 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 testRecreatingStringRepresentaionsOfTagLists(self):
        plain = Tag.objects.create(name='plain')
        spaces = Tag.objects.create(name='spa ces')
        comma = Tag.objects.create(name='com,ma')

        from tagging.utils import edit_string_for_tags
        self.assertEqual(u'plain', edit_string_for_tags([plain]))
        self.assertEqual(u'plain, spa ces', edit_string_for_tags([plain, spaces]))
        self.assertEqual(u'plain, spa ces, "com,ma"', edit_string_for_tags([plain, spaces, comma]))
        self.assertEqual(u'plain "com,ma"', edit_string_for_tags([plain, comma]))
        self.assertEqual(u'"com,ma", spa ces', edit_string_for_tags([comma, spaces]))

    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:
            try:
                return edit_string_for_tags(Tag.objects.usage_for_model(owner))
            except DatabaseError:
                # handle error when this is accessed before database schema exists
                return ''

        return self._get_instance_tag_cache(instance)

    def __init__(self, cache_for_form_optimization=None,  *args, **kwargs):
        # The cache_for_form_optimization is an object that is
        # optionally created by the request that calls
        # BulkEditForm. One difficulty with BulkEditForms is that the
        # forms generate similar data over and over again; we can
        # avoid some database hits by running some queries just once
        # (at BulkEditForm instantiation time), rather than once per
        # sub-form.
        #
        # However, it is unsafe to cache data in the BulkEditForm
        # class because that persists for as long as the Python
        # process does (meaning that subsequent requests will use the
        # same cache).
        EditVideoForm.__init__(self, *args, **kwargs)

        # We have to initialize tags manually because the model form
        # (django.forms.models.model_to_dict) only collects fields and
        # relations, and not descriptors like Video.tags
        self.initial['tags'] = edit_string_for_tags(self.instance.tags)

        # cache the querysets so that we don't hit the DB for each form
        cache_for_form_optimization = self.fill_cache(cache_for_form_optimization)

        self.fields['categories'].queryset = cache_for_form_optimization[
            'categories_qs']
        self.fields['authors'].queryset = cache_for_form_optimization[
            'authors_qs']

def edit_post(request, idee):
    entry = get_object_or_404(BlogEntry, pk=idee)
    form = BlogEntryForm(
        dict(entry_id=entry.id, title=entry.title, content=entry.content, 
             tags=edit_string_for_tags(Tag.objects.get_for_object(entry)))
    )
    return render_to_response('edit_post.html', {'form': form, 'entry': entry})

 def _update_instance_tag_cache(self, instance):
     """
     Helper: update an instance's tag cache from actual Tags.
     """
     # for an unsaved object, leave the default value alone
     if instance.pk is not None:
         tags = edit_string_for_tags(Tag.objects.get_for_object(instance))
         self._set_instance_tag_cache(instance, tags)

    def test_delete_skill(self):
        """
        test deleting skills
        """
        url_edit_skills = reverse("edit_skills", args=["daveb"])

        p = DjangoPerson.objects.get(user__username="daveb")
        self.assertEqual(len(p.skilltags), 3)
        self.assertTrue("jazz" in edit_string_for_tags(p.skilltags))
        self.assertTrue("linux" in edit_string_for_tags(p.skilltags))
        self.assertTrue("python" in edit_string_for_tags(p.skilltags))

        # delete jazz skill
        skills = "linux python"
        self.client.post(url_edit_skills, {"skills": skills})
        p = DjangoPerson.objects.get(user__username="daveb")
        self.assertEqual(len(p.skilltags), 2)
        self.assertTrue("linux" in edit_string_for_tags(p.skilltags))
        self.assertTrue("python" in edit_string_for_tags(p.skilltags))
        self.assertFalse("jazz" in edit_string_for_tags(p.skilltags))

        # delete all skills
        self.client.post(url_edit_skills, {"skills": ""})
        p = DjangoPerson.objects.get(user__username="daveb")

        self.assertEqual(len(p.skilltags), 0)
        self.assertEqual(edit_string_for_tags(p.skilltags), "")

    def test_delete_skill(self):
        '''
        test deleting skills
        '''
        url_edit_skills = reverse('edit_skills', args=['daveb'])

        p = DjangoPerson.objects.get(user__username='daveb')
        self.assertEqual(len(p.skilltags), 3)
        self.assertTrue('jazz' in edit_string_for_tags(p.skilltags))
        self.assertTrue('linux' in edit_string_for_tags(p.skilltags))
        self.assertTrue('python' in edit_string_for_tags(p.skilltags))

        # delete jazz skill
        skills = 'linux python'
        self.client.post(url_edit_skills, {'skills': skills})
        p = DjangoPerson.objects.get(user__username='daveb')
        self.assertEqual(len(p.skilltags), 2)
        self.assertTrue('linux' in edit_string_for_tags(p.skilltags))
        self.assertTrue('python' in edit_string_for_tags(p.skilltags))
        self.assertFalse('jazz' in edit_string_for_tags(p.skilltags))

        # delete all skills
        self.client.post(url_edit_skills, {'skills': ''})
        p = DjangoPerson.objects.get(user__username='daveb')

        self.assertEqual(len(p.skilltags), 0)
        self.assertEqual(edit_string_for_tags(p.skilltags), '')

 def __set__(self, instance, value):
     kwargs = {'default_namespace': self.namespace}
     q = None
     if  self.namespace is not None:
         q = models.Q(namespace=self.namespace)
         kwargs['filter_namespaces'] = (self.namespace,)
     value = edit_string_for_tags(value or (), **kwargs)
     Tag.objects.update_tags(instance, value, q=q,
         default_namespace=self.namespace)

def edit_skills(request, username):
    person = get_object_or_404(DjangoPerson, user__username=username)
    if not request.POST.get("skills"):
        return render(
            request,
            "edit_skills.html",
            {"form": SkillsForm(initial={"skills": edit_string_for_tags(person.skilltags)})},
        )
    person.skilltags = request.POST.get("skills", "")
    return HttpResponseRedirect("/%s/" % username)

def edit_skills(request, username):
    person = get_object_or_404(DjangoPerson, user__username = username)
    if not request.POST.get('skills'):
        return render(request, 'edit_skills.html', {
            'form': SkillsForm(initial={
                'skills': edit_string_for_tags(person.skilltags)
            }),
        })
    person.skilltags = request.POST.get('skills', '')
    return redirect(reverse('user_profile', args=[username]))

def edit_skills(request, username):
    person = get_object_or_404(DjangoPerson, user__username = username)
    if not request.POST.get('skills'):
        return render(request, 'edit_skills.html', {
            'form': SkillsForm(initial={
                'skills': edit_string_for_tags(person.skilltags)
            }),
        })
    person.skilltags = request.POST.get('skills', '')
    return HttpResponseRedirect('/%s/' % username)

    def _pre_save(self, **kwargs): #signal, sender, instance):
        """
        Save tags back to the database
        """
        tags = self._get_instance_tag_cache(kwargs['instance'])
        tags = parse_tag_input(tags)

        #print 'Tags before: %s' % tags
        instance = kwargs['instance']
        self._set_instance_tag_cache(
            instance, edit_string_for_tags(tags))

def update_objects_tags(object):
    if object is None:
        return

    object_tags = Tag.objects.get_for_object(object)
    tags_as_string = edit_string_for_tags(object_tags)

    for field in object._meta.fields:
        if isinstance(field, TagField):
            setattr(object, field.attname, tags_as_string)
            object.save()
            break

def profile(request, username):
    person = get_object_or_404(DjangoPerson, user__username=username)
    person.profile_views += 1  # Not bothering with transactions; only a stat
    person.save()
    mtags = tagdict(person.machinetags.all())

    # Set up convenient iterables for IM and services
    ims = []
    for key, value in mtags.get("im", {}).items():
        shortname, name, icon = IMPROVIDERS_DICT.get(key, ("", "", ""))
        if not shortname:
            continue  # Bad machinetag
        ims.append({"shortname": shortname, "name": name, "value": value})
    ims.sort(lambda x, y: cmp(x["shortname"], y["shortname"]))

    services = []
    for key, value in mtags.get("services", {}).items():
        shortname, name, icon = SERVICES_DICT.get(key, ("", "", ""))
        if not shortname:
            continue  # Bad machinetag
        services.append({"shortname": shortname, "name": name, "value": value})
    services.sort(lambda x, y: cmp(x["shortname"], y["shortname"]))

    # Set up vars that control privacy stuff
    privacy = {
        "show_im": (mtags["privacy"]["im"] == "public" or not request.user.is_anonymous()),
        "show_email": (
            mtags["privacy"]["email"] == "public"
            or (not request.user.is_anonymous() and mtags["privacy"]["email"] == "private")
        ),
        "hide_from_search": mtags["privacy"]["search"] != "public",
        "show_last_irc_activity": bool(person.last_active_on_irc and person.irc_tracking_allowed()),
    }

    # Should we show the 'Finding X' section at all?
    show_finding = services or privacy["show_email"] or (privacy["show_im"] and ims)

    return render(
        request,
        "profile.html",
        {
            "person": person,
            "api_key": settings.GOOGLE_MAPS_API_KEY,
            "is_owner": request.user.username == username,
            "skills_form": SkillsForm(initial={"skills": edit_string_for_tags(person.skilltags)}),
            "mtags": mtags,
            "ims": ims,
            "services": services,
            "privacy": privacy,
            "show_finding": show_finding,
        },
    )

    def _get_edit_string_for_tags(self, owner=None, instance=None):
        kwargs = {'default_namespace': self.namespace}
        # if there are more than one tag field on this model,
        # skip the tags with namespaces of athor fields.
        # Thats their domain.
        if self.namespace is not None:
            kwargs['filter_namespaces'] = (self.namespace,)
        elif self._has_instance_multiple_tag_fields:
            kwargs['exclude_namespaces'] = self._foreign_namespaces

        # Handle access on the model (i.e. Link.tags)
        if instance is None:
            queryset = Tag.objects.usage_for_model(owner)
        # Handle access on the model instance
        else:
            queryset = Tag.objects.get_for_object(instance)
        return edit_string_for_tags(queryset, **kwargs)

 def _set_instance_tag_cache(self, instance, tags):
     """
     Helper: set an instance's tag cache.
     """
     self._init(instance)
     # If there is a tag field with a namespace, make sure that this field
     # only gets the tags that are allowed.
     if tags and (
             self._has_instance_multiple_tag_fields or
             self.namespace is not None
         ):
         kwargs = {'default_namespace': self.namespace}
         if  self.namespace is None:
             kwargs['exclude_namespaces'] = self._foreign_namespaces
         else:
             kwargs['filter_namespaces'] = (self.namespace,)
         tags = edit_string_for_tags(tags, **kwargs)
     setattr(instance, '_%s_cache' % self.attname, tags)

    def test_add_skills(self):
        """
        test adding skills
        """
        url_edit_skills = reverse("edit_skills", args=["daveb"])

        p = DjangoPerson.objects.get(user__username="daveb")
        self.assertEqual(len(p.skilltags), 3)
        self.assertTrue("jazz" in edit_string_for_tags(p.skilltags))
        self.assertTrue("linux" in edit_string_for_tags(p.skilltags))
        self.assertTrue("python" in edit_string_for_tags(p.skilltags))

        skills = "%s django" % (edit_string_for_tags(p.skilltags))
        self.client.post(url_edit_skills, {"skills": skills})

        p = DjangoPerson.objects.get(user__username="daveb")
        self.assertEqual(len(p.skilltags), 4)
        self.assertTrue("jazz" in edit_string_for_tags(p.skilltags))
        self.assertTrue("linux" in edit_string_for_tags(p.skilltags))
        self.assertTrue("python" in edit_string_for_tags(p.skilltags))
        self.assertTrue("django" in edit_string_for_tags(p.skilltags))

    def test_add_skills(self):
        '''
        test adding skills
        '''
        url_edit_skills = reverse('edit_skills', args=['daveb'])

        p = DjangoPerson.objects.get(user__username='daveb')
        self.assertEqual(len(p.skilltags), 3)
        self.assertTrue('jazz' in edit_string_for_tags(p.skilltags))
        self.assertTrue('linux' in edit_string_for_tags(p.skilltags))
        self.assertTrue('python' in edit_string_for_tags(p.skilltags))

        skills = '%s django' % (edit_string_for_tags(p.skilltags))
        self.client.post(url_edit_skills, {'skills': skills})

        p = DjangoPerson.objects.get(user__username='daveb')
        self.assertEqual(len(p.skilltags), 4)
        self.assertTrue('jazz' in edit_string_for_tags(p.skilltags))
        self.assertTrue('linux' in edit_string_for_tags(p.skilltags))
        self.assertTrue('python' in edit_string_for_tags(p.skilltags))
        self.assertTrue('django' in edit_string_for_tags(p.skilltags))