Manager attaches itself to queries so they can run directly

datastore/objects/collection_manager.py

@@ -11,8 +11,8 @@ class CollectionManager(Manager):
   Collection = Collection
 
 
-  def key(self, key_or_name):
-    '''Overrides Manager.key'''
+  def instance_key(self, key_or_name):
+    '''Overrides Manager.instance_key'''
     if not isinstance(key_or_name, Key):
       return self.collection_key.instance(key_or_name)
 

datastore/objects/manager.py

@@ -15,15 +15,18 @@ def __init__(self, datastore, model=None):
 
     self.datastore = ObjectDatastore(datastore, model=self.model)
 
+  @property
+  def key(self):
+    return Key(self.model.key_type)
 
-  def key(self, key_or_name):
+  def instance_key(self, key_or_name):
     '''Coerces `key_or_name` to be a proper model Key'''
     if not isinstance(key_or_name, Key):
-      return self.model.key.instance(key_or_name)
+      return self.key.instance(key_or_name)
 
-    if key_or_name.type != self.model.key.name:
+    if key_or_name.type != self.key.name:
       err = 'key %s must have key type %s'
-      raise TypeError(err % (key_or_name, self.model.key.name))
+      raise TypeError(err % (key_or_name, self.key.name))
 
     return key_or_name
 
@@ -32,12 +35,12 @@ def key(self, key_or_name):
 
   def contains(self, key):
     '''Returns whether manager contains instance named by `key_or_name`.'''
-    return self.datastore.contains(self.key(key))
+    return self.datastore.contains(self.instance_key(key))
 
 
   def get(self, key):
     '''Retrieves instance named by `key_or_name`.'''
-    return self.datastore.get(self.key(key))
+    return self.datastore.get(self.instance_key(key))
 
 
   def put(self, instance):
@@ -50,22 +53,17 @@ def put(self, instance):
 
   def delete(self, key_or_name):
     '''Deletes instance named by `key_or_name`.'''
-    self.datastore.delete(self.key(key_or_name))
+    self.datastore.delete(self.instance_key(key_or_name))
 
 
-  def init_query(self):
-    '''Initiates a Query object for the model'''
-    if not self.model:
-      raise Exception('Can not query when no model is set on the manager')
-    return Query(Key('/' + self.model.key_type))
-
-
-  def query(self, query):
+  def query(self, query=None):
     '''Execute a query on the underlying datastore'''
-    return self.datastore.query(query)
+    mgr_query = query.copy() if query else Query()
+    mgr_query.key = self.key.child(mgr_query.key)
+    return self.datastore.query(mgr_query)
 
 
   def remove_all_items(self):
     '''Removes all items from the datastore'''
-    for obj in self.query(self.init_query()):
+    for obj in self.query():
       self.delete(obj.key)

datastore/objects/test/test_objects_collection_manager.py

@@ -39,7 +39,7 @@ class Foo(Model): pass
     ds = datastore.DictDatastore()
     mgr = CollectionManager(ds)
     mgr.model = Foo
-    self.assertEqual(mgr.key('bar'), Key('/foo:bar'))
+    self.assertEqual(mgr.instance_key('bar'), Key('/foo:bar'))
 
 
   def test_collection(self):

datastore/objects/test/test_objects_manager.py

@@ -5,6 +5,7 @@
 from ..manager import Manager
 from ..model import Key
 from ..model import Model
+from datastore.core import Query
 from ..object_datastore import ObjectDatastore
 
 
@@ -132,16 +133,16 @@ def __eq__(self, other):
     mgr.put(instance1)
     mgr.put(instance2)
 
-    q = mgr.init_query()
-    self.assertFalse(q is None)
-    results = list(mgr.query(q))
+    # Query all on the manager
+    results = list(mgr.query())
     self.assertEqual(len(results), 2)
 
-    results = list(mgr.query(mgr.init_query().filter('foo','=','bar1')))
+    # Query with filter
+    results = list(mgr.query(Query().filter('foo','=','bar1')))
     self.assertEqual(len(results), 1)
     self.assertEqual(results[0], instance1)
 
-    results = list(mgr.query(mgr.init_query().filter('foo','=','bar2')))
+    results = list(mgr.query(Query().filter('foo','=','bar2')))
     self.assertEqual(len(results), 1)
     self.assertEqual(results[0], instance2)