DatabaseAlias with filter method

tests_rete/test_db.py

@@ -34,23 +34,23 @@ def test_db(self):
 class TestAlias(unittest.TestCase):
 
 	def test_mapping(self):
-
+		# xyz->abc * pqr->xyz = pqr->xyz
 		m1 = SimpleMapping(zip('xyz','abc'))
 		self.assertEqual(m1,dict(zip('xyz','abc')))
 		self.assertEqual(m1.reverse,dict(zip('abc','xyz')))
 
 		m2 = SimpleMapping(zip('pqr','xyz'))
 		# testing multiply
 		self.assertEqual(m1*m2,dict(zip('pqr','abc')))
-		v = dict(zip('abc',range(3)))
 
-		self.assertEqual(m1.premultiply(v),dict(zip('xyz',range(3))))
-		self.assertEqual(SimpleMapping(m1*m2).premultiply(v),dict(zip('pqr',range(3))))
+		v = dict(zip('abc',range(3)))
+		self.assertEqual(SimpleMapping(v)*m1,dict(zip('xyz',range(3))))
+		self.assertEqual(SimpleMapping(v)*SimpleMapping(m1*m2),dict(zip('pqr',range(3))))
 
 
 	def test_database_alias(self):
 		db = Database(list('abc'))
-		db.insert(dict(a=1,b=2,c=3))
+		db.insert(dict(zip('abc',range(3))))
 
 		alias1 = DatabaseAlias(db, dict(zip('xyz','abc')))
 		alias2 = DatabaseAlias(alias1,dict(zip('pqr','xyz')))
@@ -63,3 +63,14 @@ def test_database_alias(self):
 		self.assertEqual(alias1.mapping, dict(zip('xyz','abc')))
 		self.assertEqual(alias2.mapping, dict(zip('pqr','abc')))
 		self.assertEqual(alias3.mapping, dict(zip('ijk','abc')))
+
+		# checking filtering
+		record = db.filter(dict(a=0))[0]
+		self.assertEqual(record,dict(zip('abc',range(3))))
+		aliased1 = alias1.filter(dict(x=0))[0]
+		aliased2 = alias2.filter(dict(p=0))[0]
+		aliased3 = alias3.filter(dict(i=0))[0]
+		self.assertEqual(aliased1,dict(zip('xyz',range(3))))
+		self.assertEqual(aliased2,dict(zip('pqr',range(3))))
+		self.assertEqual(aliased3,dict(zip('ijk',range(3))))
+

wc_rules/matcher/dbase.py

@@ -45,17 +45,37 @@ def __len__(self):
 
 class DatabaseAlias:
 
-
 	def __init__(self,target,mapping):
 
-		# NOTE: mapping has keys=CURRENT variables, values=variables of cache it is aliasing
+
+		'''
+		Example: Parent database with fields a b c
+		Child Alias with fields x y z
+		Mapping stored in child: x->a, y->b, z->c
+		Sending data downstream (foward)
+		{a:1,b:2,c:3}*{x:a,y:b,z:3} = {x:1,y:2,z:3}
+		Sending data request upstream (reverse)
+		{x:1,y:2,z:3}*{x:a,y:b,z:3}^-1 = {a:1,b:2,c:3}
+		'''
+
 		if isinstance(target,DatabaseAlias):
 			target, mapping = target.target, target.mapping*mapping
 
-		#assert isinstance(target,Database) and set(mapping.values())==target.fields
-
 		self.target = target
 		self.mapping = SimpleMapping(mapping)
-
+
+	def forward_transform(self,match):
+		return SimpleMapping(match)*self.mapping
+
+	def reverse_transform(self,match):
+		return SimpleMapping(match)*self.mapping.reverse
+
+	def filter(self,include_kwargs={},exclude_kwargs={}):
+		includes = self.reverse_transform(include_kwargs)
+		excludes = self.reverse_transform(exclude_kwargs)
+		records = self.target.filter(includes,excludes)
+		rotated = [self.forward_transform(x) for x in records]
+		return rotated
+
 
 

wc_rules/utils/collections.py

@@ -18,16 +18,13 @@ def __init__(self,*args,**kwargs):
     def __mul__(self,other):
         # convention self * other == f o g
         # takes g's keys and f's values
+        # {x:a,y:b,z:c}*{p:x,q:y,r:z} = {p:a,q:b,r:c}
         return {k:self[v] for k,v in other.items() if v in self}
 
     @cached_property
     def reverse(self):
         return SimpleMapping({v:k for k,v in self.items()})
 
-    def premultiply(self,other):
-        return {k:other[v] for k,v in self.items() if v in other}
-
-
 
 
 @dataclass(order=True,frozen=True)