Reverting handling of queries through QueryManagers, instead of simply using…

Reverting handling of queries through QueryManagers, instead of simply using Querysets. Added a the _fetch method on QueryManager to eliminate the dependency of querysets on model_class. Added a  method to Queryset. Installation objects now are able to be imported. (Still need test cases, though.)

parse_rest/__init__.py

@@ -21,7 +21,7 @@ import re
 import logging
 
 
-from query import Queryset
+from query import QueryManager
 
 API_ROOT = 'https://api.parse.com/1'
 
@@ -294,7 +294,7 @@ class ObjectMetaclass(type):
     def __new__(cls, name, bases, dct):
         cls = super(ObjectMetaclass, cls).__new__(cls, name, bases, dct)
         cls.set_endpoint_root()
-        cls.Query = Queryset(cls)
+        cls.Query = QueryManager(cls)
         return cls
 
 
@@ -398,7 +398,7 @@ class User(ParseResource):
             return False
 
 
-User.Query = Queryset(User)
+User.Query = QueryManager(User)
 
 
 class ParseError(Exception):

parse_rest/installation.py

@@ -13,27 +13,17 @@
 
 import __init__ as parse_rest
 from __init__ import API_ROOT, ParseResource
-from query import QueryManager, Query
+from query import QueryManager
 
 
 class InstallationManager(QueryManager):
     def __init__(self):
         self._model_class = Installation
 
-
-class InstallationQuery(Query):
-    def _fetch(self):
-        opts = dict(self._options)  # make a local copy
-        if self._where:
-            # JSON encode WHERE values
-            where = json.dumps(self._where)
-            opts.update({'where': where})
-
-        extra_headers = {'X-Parse-Master-Key': parse_rest.MASTER_KEY}
-        klass = self._manager.model_class
-        uri = self._manager.model_class.ENDPOINT_ROOT
-        return [klass(**it) for it in klass.GET(uri, **options).get('results')]
-
+    def _fetch(self, **kw):
+        kw['extra_headers'] = {'X-Parse-Master-Key': parse_rest.MASTER_KEY}
+        response = Installation.GET(Installation.ENDPOINT_ROOT, **kw)
+        return [Installation(**it) for it in response.get('results')]
 
 class Installation(ParseResource):
     ENDPOINT_ROOT = '/'.join([API_ROOT, 'installations'])

parse_rest/query.py

@@ -30,6 +30,11 @@ class QueryManager(object):
     def __init__(self, model_class):
         self.model_class = model_class
 
+    def _fetch(self, **kw):
+        klass = self.model_class
+        uri = self.model_class.ENDPOINT_ROOT
+        return [klass(**it) for it in klass.GET(uri, **kw).get('results')]
+
     def all(self):
         return Queryset(self)
 
@@ -66,8 +71,8 @@ class QuerysetMetaclass(type):
 class Queryset(object):
     __metaclass__ = QuerysetMetaclass
 
-    def __init__(self, model_class):
-        self.model_class = model_class
+    def __init__(self, manager):
+        self._manager = manager
         self._where = collections.defaultdict(dict)
         self._options = {}
 
@@ -102,6 +107,10 @@ class Queryset(object):
         self._options['order'] = descending and ('-' + order) or order
         return self
 
+    def count(self):
+        results = self._fetch()
+        return len(results)
+
     def exists(self):
         results = self._fetch()
         return len(results) > 0
@@ -121,6 +130,4 @@ class Queryset(object):
             where = json.dumps(self._where)
             options.update({'where': where})
 
-        klass = self.model_class
-        uri = self.model_class.ENDPOINT_ROOT
-        return [klass(**it) for it in klass.GET(uri, **options).get('results')]
+        return self._manager._fetch(**options)

parse_rest/tests.py

@@ -102,7 +102,7 @@ class TestObject(unittest.TestCase):
         self.sao_paulo.save()
         self.assert_(type(self.sao_paulo.updatedAt) == datetime.datetime)
 
-        city = City.Query.where(name='São Paulo').get()
+        city = City.Query.get(name='São Paulo')
         self.assert_(city.country == 'Brazil', 'Could not update object')
 
     def testCanDeleteExistingObject(self):
@@ -127,7 +127,7 @@ class TestObject(unittest.TestCase):
         self.score.save()
 
         # get the object, see if it has saved
-        qs = GameScore.Query.where(objectId=self.score.objectId).get()
+        qs = GameScore.Query.get(objectId=self.score.objectId)
         self.assert_(isinstance(qs.item, Object),
                      "Associated CollectedItem is not of correct class")
         self.assert_(qs.item.type == "Sword",
@@ -166,53 +166,53 @@ class TestQuery(unittest.TestCase):
 
         # test the two exceptions get can raise
         self.assertRaises(query.QueryResourceDoesNotExist,
-                          GameScore.Query.gt("score", 20).get)
+                          GameScore.Query.all().gt("score", 20).get)
         self.assertRaises(query.QueryResourceMultipleResultsReturned,
-                          GameScore.Query.gt("score", 3).get)
+                          GameScore.Query.all().gt("score", 3).get)
 
     def testComparisons(self):
         """test comparison operators- gt, gte, lt, lte, ne"""
-        scores_gt_3 = list(GameScore.Query.gt("score", 3))
+        scores_gt_3 = list(GameScore.Query.all().gt("score", 3))
         self.assertEqual(len(scores_gt_3), 2)
         self.assert_(all([s.score > 3 for s in scores_gt_3]))
 
-        scores_gte_3 = list(GameScore.Query.gte("score", 3))
+        scores_gte_3 = list(GameScore.Query.all().gte("score", 3))
         self.assertEqual(len(scores_gte_3), 3)
         self.assert_(all([s.score >= 3 for s in scores_gt_3]))
 
-        scores_lt_4 = list(GameScore.Query.lt("score", 4))
+        scores_lt_4 = list(GameScore.Query.all().lt("score", 4))
         self.assertEqual(len(scores_lt_4), 3)
         self.assert_(all([s.score < 4 for s in scores_lt_4]))
 
-        scores_lte_4 = list(GameScore.Query.lte("score", 4))
+        scores_lte_4 = list(GameScore.Query.all().lte("score", 4))
         self.assertEqual(len(scores_lte_4), 4)
         self.assert_(all([s.score <= 4 for s in scores_lte_4]))
 
-        scores_ne_2 = list(GameScore.Query.ne("score", 2))
+        scores_ne_2 = list(GameScore.Query.all().ne("score", 2))
         self.assertEqual(len(scores_ne_2), 4)
         self.assert_(all([s.score != 2 for s in scores_ne_2]))
 
         # test chaining
-        lt_4_gt_2 = list(GameScore.Query.lt("score", 4).gt("score", 2))
+        lt_4_gt_2 = list(GameScore.Query.all().lt("score", 4).gt("score", 2))
         self.assert_(len(lt_4_gt_2) == 1, "chained lt+gt not working")
         self.assert_(lt_4_gt_2[0].score == 3, "chained lt+gt not working")
-        q = GameScore.Query.gt("score", 3).lt("score", 3)
+        q = GameScore.Query.all().gt("score", 3).lt("score", 3)
         self.assert_(not q.exists(), "chained lt+gt not working")
 
     def testOptions(self):
         """test three options- order, limit, and skip"""
-        scores_ordered = list(GameScore.Query.order("score"))
+        scores_ordered = list(GameScore.Query.all().order("score"))
         self.assertEqual([s.score for s in scores_ordered],
                          [1, 2, 3, 4, 5])
 
-        scores_ordered_desc = list(GameScore.Query.order("score", True))
+        scores_ordered_desc = list(GameScore.Query.all().order("score", True))
         self.assertEqual([s.score for s in scores_ordered_desc],
                          [5, 4, 3, 2, 1])
 
-        scores_limit_3 = list(GameScore.Query.limit(3))
+        scores_limit_3 = list(GameScore.Query.all().limit(3))
         self.assert_(len(scores_limit_3) == 3, "Limit did not return 3 items")
 
-        scores_skip_3 = list(GameScore.Query.skip(3))
+        scores_skip_3 = list(GameScore.Query.all().skip(3))
         self.assert_(len(scores_skip_3) == 2, "Skip did not return 2 items")
 
     def tearDown(self):
@@ -321,8 +321,7 @@ class TestUser(unittest.TestCase):
     def testCanQueryBySession(self):
         parse_rest.User.signup(self.username, self.password)
         logged = parse_rest.User.login(self.username, self.password)
-        queried = parse_rest.User.Query.where(sessionToken=logged.sessionToken
-                                                                    ).get()
+        queried = parse_rest.User.Query.get(sessionToken=logged.sessionToken)
         self.assert_(queried.objectId == logged.objectId,
                      'Could not find user %s by session' % logged.username)