Added buildout stuff and made changes accordingly

--HG--
rename : profile/management/__init__.py => eggs/djangorecipe-0.20-py2.6.egg/EGG-INFO/dependency_links.txt
rename : profile/management/__init__.py => eggs/djangorecipe-0.20-py2.6.egg/EGG-INFO/not-zip-safe
rename : profile/management/__init__.py => eggs/infrae.subversion-1.4.5-py2.6.egg/EGG-INFO/dependency_links.txt
rename : profile/management/__init__.py => eggs/infrae.subversion-1.4.5-py2.6.egg/EGG-INFO/not-zip-safe
rename : profile/management/__init__.py => eggs/mercurial-1.7.3-py2.6-linux-x86_64.egg/EGG-INFO/dependency_links.txt
rename : profile/management/__init__.py => eggs/mercurial-1.7.3-py2.6-linux-x86_64.egg/EGG-INFO/not-zip-safe
rename : profile/management/__init__.py => eggs/py-1.4.0-py2.6.egg/EGG-INFO/dependency_links.txt
rename : profile/management/__init__.py => eggs/py-1.4.0-py2.6.egg/EGG-INFO/not-zip-safe
rename : profile/management/__init__.py => eggs/zc.buildout-1.5.2-py2.6.egg/EGG-INFO/dependency_links.txt
rename : profile/management/__init__.py => eggs/zc.buildout-1.5.2-py2.6.egg/EGG-INFO/not-zip-safe
rename : profile/management/__init__.py => eggs/zc.recipe.egg-1.3.2-py2.6.egg/EGG-INFO/dependency_links.txt
rename : profile/management/__init__.py => eggs/zc.recipe.egg-1.3.2-py2.6.egg/EGG-INFO/not-zip-safe
rename : profile/management/__init__.py => parts/django/Django.egg-info/dependency_links.txt
rename : taskapp/models.py => parts/django/django/conf/app_template/models.py
rename : taskapp/tests.py => parts/django/django/conf/app_template/tests.py
rename : taskapp/views.py => parts/django/django/conf/app_template/views.py
rename : taskapp/views.py => parts/django/django/contrib/gis/tests/geo3d/views.py
rename : profile/management/__init__.py => parts/django/tests/modeltests/delete/__init__.py
rename : profile/management/__init__.py => parts/django/tests/modeltests/files/__init__.py
rename : profile/management/__init__.py => parts/django/tests/modeltests/invalid_models/__init__.py
rename : profile/management/__init__.py => parts/django/tests/modeltests/m2m_signals/__init__.py
rename : profile/management/__init__.py => parts/django/tests/modeltests/model_package/__init__.py
rename : profile/management/__init__.py => parts/django/tests/regressiontests/bash_completion/__init__.py
rename : profile/management/__init__.py => parts/django/tests/regressiontests/bash_completion/management/__init__.py
rename : profile/management/__init__.py => parts/django/tests/regressiontests/bash_completion/management/commands/__init__.py
rename : profile/management/__init__.py => parts/django/tests/regressiontests/bash_completion/models.py
rename : profile/management/__init__.py => parts/django/tests/regressiontests/delete_regress/__init__.py
rename : profile/management/__init__.py => parts/django/tests/regressiontests/file_storage/__init__.py
rename : profile/management/__init__.py => parts/django/tests/regressiontests/max_lengths/__init__.py
rename : profile/forms.py => pytask/profile/forms.py
rename : profile/management/__init__.py => pytask/profile/management/__init__.py
rename : profile/management/commands/seed_db.py => pytask/profile/management/commands/seed_db.py
rename : profile/models.py => pytask/profile/models.py
rename : profile/templatetags/user_tags.py => pytask/profile/templatetags/user_tags.py
rename : taskapp/tests.py => pytask/profile/tests.py
rename : profile/urls.py => pytask/profile/urls.py
rename : profile/utils.py => pytask/profile/utils.py
rename : profile/views.py => pytask/profile/views.py
rename : static/css/base.css => pytask/static/css/base.css
rename : taskapp/tests.py => pytask/taskapp/tests.py
rename : taskapp/views.py => pytask/taskapp/views.py
rename : templates/base.html => pytask/templates/base.html
rename : templates/profile/browse_notifications.html => pytask/templates/profile/browse_notifications.html
rename : templates/profile/edit.html => pytask/templates/profile/edit.html
rename : templates/profile/view.html => pytask/templates/profile/view.html
rename : templates/profile/view_notification.html => pytask/templates/profile/view_notification.html
rename : templates/registration/activate.html => pytask/templates/registration/activate.html
rename : templates/registration/activation_email.txt => pytask/templates/registration/activation_email.txt
rename : templates/registration/activation_email_subject.txt => pytask/templates/registration/activation_email_subject.txt
rename : templates/registration/logged_out.html => pytask/templates/registration/logged_out.html
rename : templates/registration/login.html => pytask/templates/registration/login.html
rename : templates/registration/logout.html => pytask/templates/registration/logout.html
rename : templates/registration/password_change_done.html => pytask/templates/registration/password_change_done.html
rename : templates/registration/password_change_form.html => pytask/templates/registration/password_change_form.html
rename : templates/registration/password_reset_complete.html => pytask/templates/registration/password_reset_complete.html
rename : templates/registration/password_reset_confirm.html => pytask/templates/registration/password_reset_confirm.html
rename : templates/registration/password_reset_done.html => pytask/templates/registration/password_reset_done.html
rename : templates/registration/password_reset_email.html => pytask/templates/registration/password_reset_email.html
rename : templates/registration/password_reset_form.html => pytask/templates/registration/password_reset_form.html
rename : templates/registration/registration_complete.html => pytask/templates/registration/registration_complete.html
rename : templates/registration/registration_form.html => pytask/templates/registration/registration_form.html
rename : utils.py => pytask/utils.py

1 files changed, 343 insertions, 0 deletions

diff --git a/parts/django/tests/modeltests/m2m_through/tests.py b/parts/django/tests/modeltests/m2m_through/tests.py
new file mode 100644
index 0000000..807e952
--- /dev/null
+++ b/parts/django/tests/modeltests/m2m_through/tests.py
@@ -0,0 +1,343 @@
+from datetime import datetime
+from operator import attrgetter
+
+from django.test import TestCase
+
+from models import Person, Group, Membership, CustomMembership, \
+    TestNoDefaultsOrNulls, PersonSelfRefM2M, Friendship
+
+
+class M2mThroughTests(TestCase):
+    def setUp(self):
+        self.bob = Person.objects.create(name='Bob')
+        self.jim = Person.objects.create(name='Jim')
+        self.jane = Person.objects.create(name='Jane')
+        self.rock = Group.objects.create(name='Rock')
+        self.roll = Group.objects.create(name='Roll')
+
+    def test_m2m_through(self):
+        # We start out by making sure that the Group 'rock' has no members.
+        self.assertQuerysetEqual(
+            self.rock.members.all(),
+            []
+        )
+        # To make Jim a member of Group Rock, simply create a Membership object.
+        m1 = Membership.objects.create(person=self.jim, group=self.rock)
+        # We can do the same for Jane and Rock.
+        m2 = Membership.objects.create(person=self.jane, group=self.rock)
+        # Let's check to make sure that it worked.  Jane and Jim should be members of Rock.
+        self.assertQuerysetEqual(
+            self.rock.members.all(), [
+                'Jane',
+                'Jim'
+            ],
+            attrgetter("name")
+        )
+        # Now we can add a bunch more Membership objects to test with.
+        m3 = Membership.objects.create(person=self.bob, group=self.roll)
+        m4 = Membership.objects.create(person=self.jim, group=self.roll)
+        m5 = Membership.objects.create(person=self.jane, group=self.roll)
+        # We can get Jim's Group membership as with any ForeignKey.
+        self.assertQuerysetEqual(
+            self.jim.group_set.all(), [
+                'Rock',
+                'Roll'
+            ],
+            attrgetter("name")
+        )
+        # Querying the intermediary model works like normal.
+        self.assertEqual(
+            repr(Membership.objects.get(person=self.jane, group=self.rock)),
+            '<Membership: Jane is a member of Rock>'
+        )
+        # It's not only get that works. Filter works like normal as well.
+        self.assertQuerysetEqual(
+            Membership.objects.filter(person=self.jim), [
+                '<Membership: Jim is a member of Rock>',
+                '<Membership: Jim is a member of Roll>'
+            ]
+        )
+        self.rock.members.clear()
+        # Now there will be no members of Rock.
+        self.assertQuerysetEqual(
+            self.rock.members.all(),
+            []
+        )
+
+
+
+    def test_forward_descriptors(self):
+        # Due to complications with adding via an intermediary model,
+        # the add method is not provided.
+        self.assertRaises(AttributeError, lambda: self.rock.members.add(self.bob))
+        # Create is also disabled as it suffers from the same problems as add.
+        self.assertRaises(AttributeError, lambda: self.rock.members.create(name='Anne'))
+        # Remove has similar complications, and is not provided either.
+        self.assertRaises(AttributeError, lambda: self.rock.members.remove(self.jim))
+
+        m1 = Membership.objects.create(person=self.jim, group=self.rock)
+        m2 = Membership.objects.create(person=self.jane, group=self.rock)
+
+        # Here we back up the list of all members of Rock.
+        backup = list(self.rock.members.all())
+        # ...and we verify that it has worked.
+        self.assertEqual(
+            [p.name for p in backup],
+            ['Jane', 'Jim']
+        )
+        # The clear function should still work.
+        self.rock.members.clear()
+        # Now there will be no members of Rock.
+        self.assertQuerysetEqual(
+            self.rock.members.all(),
+            []
+        )
+
+        # Assignment should not work with models specifying a through model for many of
+        # the same reasons as adding.
+        self.assertRaises(AttributeError, setattr, self.rock, "members", backup)
+        # Let's re-save those instances that we've cleared.
+        m1.save()
+        m2.save()
+        # Verifying that those instances were re-saved successfully.
+        self.assertQuerysetEqual(
+            self.rock.members.all(),[
+                'Jane',
+                'Jim'
+            ],
+            attrgetter("name")
+        )
+
+    def test_reverse_descriptors(self):
+        # Due to complications with adding via an intermediary model,
+        # the add method is not provided.
+        self.assertRaises(AttributeError, lambda: self.bob.group_set.add(self.rock))
+        # Create is also disabled as it suffers from the same problems as add.
+        self.assertRaises(AttributeError, lambda: self.bob.group_set.create(name="funk"))
+        # Remove has similar complications, and is not provided either.
+        self.assertRaises(AttributeError, lambda: self.jim.group_set.remove(self.rock))
+
+        m1 = Membership.objects.create(person=self.jim, group=self.rock)
+        m2 = Membership.objects.create(person=self.jim, group=self.roll)
+
+        # Here we back up the list of all of Jim's groups.
+        backup = list(self.jim.group_set.all())
+        self.assertEqual(
+            [g.name for g in backup],
+            ['Rock', 'Roll']
+        )
+        # The clear function should still work.
+        self.jim.group_set.clear()
+        # Now Jim will be in no groups.
+        self.assertQuerysetEqual(
+            self.jim.group_set.all(),
+            []
+        )
+        # Assignment should not work with models specifying a through model for many of
+        # the same reasons as adding.
+        self.assertRaises(AttributeError, setattr, self.jim, "group_set", backup)
+        # Let's re-save those instances that we've cleared.
+
+        m1.save()
+        m2.save()
+        # Verifying that those instances were re-saved successfully.
+        self.assertQuerysetEqual(
+            self.jim.group_set.all(),[
+                'Rock',
+                'Roll'
+            ],
+            attrgetter("name")
+        )
+
+    def test_custom_tests(self):
+        # Let's see if we can query through our second relationship.
+        self.assertQuerysetEqual(
+            self.rock.custom_members.all(),
+            []
+        )
+        # We can query in the opposite direction as well.
+        self.assertQuerysetEqual(
+            self.bob.custom.all(),
+            []
+        )
+
+        cm1 = CustomMembership.objects.create(person=self.bob, group=self.rock)
+        cm2 = CustomMembership.objects.create(person=self.jim, group=self.rock)
+
+        # If we get the number of people in Rock, it should be both Bob and Jim.
+        self.assertQuerysetEqual(
+            self.rock.custom_members.all(),[
+                'Bob',
+                'Jim'
+            ],
+            attrgetter("name")
+        )
+        # Bob should only be in one custom group.
+        self.assertQuerysetEqual(
+            self.bob.custom.all(),[
+                'Rock'
+            ],
+            attrgetter("name")
+        )
+        # Let's make sure our new descriptors don't conflict with the FK related_name.
+        self.assertQuerysetEqual(
+            self.bob.custom_person_related_name.all(),[
+                '<CustomMembership: Bob is a member of Rock>'
+            ]
+        )
+
+    def test_self_referential_tests(self):
+        # Let's first create a person who has no friends.
+        tony = PersonSelfRefM2M.objects.create(name="Tony")
+        self.assertQuerysetEqual(
+            tony.friends.all(),
+            []
+        )
+
+        chris = PersonSelfRefM2M.objects.create(name="Chris")
+        f = Friendship.objects.create(first=tony, second=chris, date_friended=datetime.now())
+
+        # Tony should now show that Chris is his friend.
+        self.assertQuerysetEqual(
+            tony.friends.all(),[
+                'Chris'
+            ],
+            attrgetter("name")
+        )
+        # But we haven't established that Chris is Tony's Friend.
+        self.assertQuerysetEqual(
+            chris.friends.all(),
+            []
+        )
+        f2 = Friendship.objects.create(first=chris, second=tony, date_friended=datetime.now())
+
+        # Having added Chris as a friend, let's make sure that his friend set reflects
+        # that addition.
+        self.assertQuerysetEqual(
+            chris.friends.all(),[
+                'Tony'
+            ],
+            attrgetter("name")
+        )
+
+        # Chris gets mad and wants to get rid of all of his friends.
+        chris.friends.clear()
+        # Now he should not have any more friends.
+        self.assertQuerysetEqual(
+            chris.friends.all(),
+            []
+        )
+        # Since this isn't a symmetrical relation, Tony's friend link still exists.
+        self.assertQuerysetEqual(
+            tony.friends.all(),[
+                'Chris'
+            ],
+            attrgetter("name")
+        )
+
+    def test_query_tests(self):
+        m1 = Membership.objects.create(person=self.jim, group=self.rock)
+        m2 = Membership.objects.create(person=self.jane, group=self.rock)
+        m3 = Membership.objects.create(person=self.bob, group=self.roll)
+        m4 = Membership.objects.create(person=self.jim, group=self.roll)
+        m5 = Membership.objects.create(person=self.jane, group=self.roll)
+
+        m2.invite_reason = "She was just awesome."
+        m2.date_joined = datetime(2006, 1, 1)
+        m2.save()
+        m3.date_joined = datetime(2004, 1, 1)
+        m3.save()
+        m5.date_joined = datetime(2004, 1, 1)
+        m5.save()
+
+        # We can query for the related model by using its attribute name (members, in
+        # this case).
+        self.assertQuerysetEqual(
+            Group.objects.filter(members__name='Bob'),[
+                'Roll'
+            ],
+            attrgetter("name")
+        )
+
+        # To query through the intermediary model, we specify its model name.
+        # In this case, membership.
+        self.assertQuerysetEqual(
+            Group.objects.filter(membership__invite_reason="She was just awesome."),[
+                'Rock'
+            ],
+            attrgetter("name")
+        )
+
+        # If we want to query in the reverse direction by the related model, use its
+        # model name (group, in this case).
+        self.assertQuerysetEqual(
+            Person.objects.filter(group__name="Rock"),[
+                'Jane',
+                'Jim'
+            ],
+            attrgetter("name")
+        )
+
+        cm1 = CustomMembership.objects.create(person=self.bob, group=self.rock)
+        cm2 = CustomMembership.objects.create(person=self.jim, group=self.rock)
+        # If the m2m field has specified a related_name, using that will work.
+        self.assertQuerysetEqual(
+            Person.objects.filter(custom__name="Rock"),[
+                'Bob',
+                'Jim'
+            ],
+            attrgetter("name")
+        )
+
+        # To query through the intermediary model in the reverse direction, we again
+        # specify its model name (membership, in this case).
+        self.assertQuerysetEqual(
+            Person.objects.filter(membership__invite_reason="She was just awesome."),[
+                'Jane'
+            ],
+            attrgetter("name")
+        )
+
+        # Let's see all of the groups that Jane joined after 1 Jan 2005:
+        self.assertQuerysetEqual(
+            Group.objects.filter(membership__date_joined__gt=datetime(2005, 1, 1), membership__person=self.jane),[
+                'Rock'
+            ],
+            attrgetter("name")
+        )
+
+        # Queries also work in the reverse direction: Now let's see all of the people
+        # that have joined Rock since 1 Jan 2005:
+        self.assertQuerysetEqual(
+            Person.objects.filter(membership__date_joined__gt=datetime(2005, 1, 1), membership__group=self.rock),[
+                'Jane',
+                'Jim'
+            ],
+            attrgetter("name")
+        )
+
+        # Conceivably, queries through membership could return correct, but non-unique
+        # querysets.  To demonstrate this, we query for all people who have joined a
+        # group after 2004:
+        self.assertQuerysetEqual(
+            Person.objects.filter(membership__date_joined__gt=datetime(2004, 1, 1)),[
+                'Jane',
+                'Jim',
+                'Jim'
+            ],
+            attrgetter("name")
+        )
+
+        # Jim showed up twice, because he joined two groups ('Rock', and 'Roll'):
+        self.assertEqual(
+            [(m.person.name, m.group.name) for m in Membership.objects.filter(date_joined__gt=datetime(2004, 1, 1))],
+            [(u'Jane', u'Rock'), (u'Jim', u'Rock'), (u'Jim', u'Roll')]
+        )
+        # QuerySet's distinct() method can correct this problem.
+        self.assertQuerysetEqual(
+            Person.objects.filter(membership__date_joined__gt=datetime(2004, 1, 1)).distinct(),[
+                'Jane',
+                'Jim'
+            ],
+            attrgetter("name")
+        )