finish builder code

cgarciae · cgarciae · commit be7487fe4023 · 2016-11-09T14:00:03.000-05:00
diff --git a/tensorbuilder/builder.py b/tensorbuilder/builder.py
@@ -21,9 +21,13 @@ def __init__(self, ref=None):
         super(Ref, self).__init__()
         self.ref = ref
 
-    def __call__(self):
+    def __call__(self, *optional):
         return self.ref
 
+    def set(self, x):
+        self.ref = x
+        return x
+
 
 class Builder(object):
     """
@@ -98,6 +102,54 @@ def _(builder, g, *args, **kwargs):
         g = _compile(g)
         return builder._unit(lambda x: g(builder.f(x), *args, **kwargs))
 
+    def _2(builder, g, arg1, *args, **kwargs):
+        """
+        """
+        g = _compile(g)
+
+        def _lambda(x):
+            arg2 = builder.f(x)
+            new_args = tuple([arg1, arg2] + list(args))
+            return g(*new_args, **kwargs)
+
+        return builder._unit(_lambda)
+
+    def _3(builder, g, arg1, arg2, *args, **kwargs):
+        """
+        """
+        g = _compile(g)
+
+        def _lambda(x):
+            arg3 = builder.f(x)
+            new_args = tuple([arg1, arg2, arg3] + list(args))
+            return g(*new_args, **kwargs)
+
+        return builder._unit(_lambda)
+
+    def _4(builder, g, arg1, arg2, arg3, *args, **kwargs):
+        """
+        """
+        g = _compile(g)
+
+        def _lambda(x):
+            arg4 = builder.f(x)
+            new_args = tuple([arg1, arg2, arg3, arg4] + list(args))
+            return g(*new_args, **kwargs)
+
+        return builder._unit(_lambda)
+
+    def _5(builder, g, arg1, arg2, arg3, arg4, *args, **kwargs):
+        """
+        """
+        g = _compile(g)
+
+        def _lambda(x):
+            arg5 = builder.f(x)
+            new_args = tuple([arg1, arg2, arg3, arg4, arg5] + list(args))
+            return g(*new_args, **kwargs)
+
+        return builder._unit(_lambda)
+
 
     def using(builder, x):
         """
@@ -107,15 +159,15 @@ def using(builder, x):
     def run(builder):
         return builder(None)
 
-    def store_on(builder, reference):
-        def store_ref(x):
-            reference.ref = x
-            return x
-        return builder._(store_ref)
+    def store(builder, ref):
+        return builder._(ref.set)
 
     def ref(self):
         return Ref()
 
+    def identity(self, x):
+        return x
+
     def pipe(self, x, *ast):
         """
         `pipe` takes in a `builder` of type `Builder`, `BuilderTree` or `Object` preferably and an object `ast` which must be part of the domain of the DSL, and compiles `ast` to a function of type `Builder -> Builder` and applies it to the input `builder`. All \*args after `builder` are taken as a tuple, therefore, it makes it easier to define an initial tuple `()` element to define a sequential operation.
@@ -203,7 +255,7 @@ def compile(self, *ast):
         return _compile(ast)
 
     @classmethod
-    def register_method(cls, fn, library_path, alias=None, doc=None):
+    def register_as_method(cls, fn, library_path, alias=None, doc=None):
         """
         This method enables you to register any function `fn` that takes an Applicative as its first argument as a method of the Builder class.
 
@@ -239,8 +291,16 @@ def register_method(cls, fn, library_path, alias=None, doc=None):
 
         setattr(cls, name, fn)
 
+    def register_method(self, library_path, alias=None, doc=None):
+        def register_decorator(fn):
+
+            self.register_as_method(fn, library_path, alias=alias, doc=doc)
+
+            return fn
+        return register_decorator
+
     @classmethod
-    def register_function_as_method(cls, fn, library_path, alias=None, doc=None):
+    def register_function(cls, fn, library_path, alias=None, doc=None):
         """
         This method enables you to register any function `fn` that takes an object as its first argument as a method of the Builder and Applicative class.
 
@@ -259,16 +319,107 @@ def register_function_as_method(cls, fn, library_path, alias=None, doc=None):
 
         """
         alias = alias if alias else fn.__name__
-        method = get_method(fn)
+
+        def method(builder, *args, **kwargs):
+            return builder._(fn, *args, **kwargs)
+
         method.__doc__ = inspect.getdoc(fn)
         method.__name__ = alias
 
-        cls.register_method(method, library_path, alias=alias, doc=doc)
+        cls.register_as_method(method, library_path, alias=alias, doc=doc)
+
+    @classmethod
+    def register_function2(cls, fn, library_path, alias=None, doc=None):
+        """
+        """
+        alias = alias if alias else fn.__name__
+
+        def method(builder, *args, **kwargs):
+            return builder._2(fn, *args, **kwargs)
+
+        method.__doc__ = inspect.getdoc(fn)
+        method.__name__ = alias
+
+        cls.register_as_method(method, library_path, alias=alias, doc=doc)
+
+    @classmethod
+    def register_function3(cls, fn, library_path, alias=None, doc=None):
+        """
+        """
+        alias = alias if alias else fn.__name__
+
+        def method(builder, *args, **kwargs):
+            return builder._3(fn, *args, **kwargs)
+
+        method.__doc__ = inspect.getdoc(fn)
+        method.__name__ = alias
+
+        cls.register_as_method(method, library_path, alias=alias, doc=doc)
+
+    @classmethod
+    def register_function4(cls, fn, library_path, alias=None, doc=None):
+        """
+        """
+        alias = alias if alias else fn.__name__
+
+        def method(builder, *args, **kwargs):
+            return builder._4(fn, *args, **kwargs)
+
+        method.__doc__ = inspect.getdoc(fn)
+        method.__name__ = alias
+
+        cls.register_as_method(method, library_path, alias=alias, doc=doc)
+
+    @classmethod
+    def register_function5(cls, fn, library_path, alias=None, doc=None):
+        """
+        """
+        alias = alias if alias else fn.__name__
+
+        def method(builder, *args, **kwargs):
+            return builder._5(fn, *args, **kwargs)
+
+        method.__doc__ = inspect.getdoc(fn)
+        method.__name__ = alias
+
+        cls.register_as_method(method, library_path, alias=alias, doc=doc)
 
     def register(self, library_path, alias=None, doc=None):
         def register_decorator(fn):
 
-            self.register_function_as_method(fn, library_path, alias=alias, doc=doc)
+            self.register_function(fn, library_path, alias=alias, doc=doc)
+
+            return fn
+        return register_decorator
+
+    def register2(self, library_path, alias=None, doc=None):
+        def register_decorator(fn):
+
+            self.register_function2(fn, library_path, alias=alias, doc=doc)
+
+            return fn
+        return register_decorator
+
+    def register3(self, library_path, alias=None, doc=None):
+        def register_decorator(fn):
+
+            self.register_function3(fn, library_path, alias=alias, doc=doc)
+
+            return fn
+        return register_decorator
+
+    def register4(self, library_path, alias=None, doc=None):
+        def register_decorator(fn):
+
+            self.register_function4(fn, library_path, alias=alias, doc=doc)
+
+            return fn
+        return register_decorator
+
+    def register5(self, library_path, alias=None, doc=None):
+        def register_decorator(fn):
+
+            self.register_function5(fn, library_path, alias=alias, doc=doc)
 
             return fn
         return register_decorator
@@ -279,11 +430,6 @@ def register_decorator(fn):
 ### FUNCTIONS
 #######################
 
-def get_method(fn):
-    def method(builder, *args, **kwargs):
-        return builder._(fn, *args, **kwargs)
-    return method
-
 def _compile(ast):
     #if type(ast) is tuple:
 
diff --git a/tensorbuilder/tests/test_builders.py b/tensorbuilder/tests/test_builders.py
@@ -1,30 +1,45 @@
 import tensorflow as tf
-from tensorbuilder import builder
+from tensorbuilder import builder, Builder
 from fn import _
 # from tensorbuilder import tb
 
 add2 = _ + 2
 mul3 = _ * 3
 get_list = lambda x: [1,2,3]
+a2_plus_b_minus_2c = lambda a, b, c: a ** 2 + b - 2*c
 
 
 @builder.register("test.lib")
 def add(a, b):
     """Some docs"""
     return a + b
 
+@builder.register2("test.lib")
+def pow(a, b):
+    return a ** b
+
+@builder.register_method("test.lib")
+def get_function_name(builder):
+    return builder.f.__name__
+
 
 
 class TestBuilder(object):
     """docstring for TestBuilder"""
 
-    x = tf.placeholder(tf.float32, shape=[None, 5])
+    @classmethod
+    def setup_method(self):
+        self.x = tf.placeholder(tf.float32, shape=[None, 5])
 
     def test_underscore(self):
         assert builder._(add2)(4) == 6
-
         assert builder._(add2)._(mul3)(4) == 18
 
+    def test_underscores(self):
+        assert builder._(a2_plus_b_minus_2c, 2, 4)(3) == 3 # (3)^2 + 2 - 2*4
+        assert builder._2(a2_plus_b_minus_2c, 2, 4)(3) == -1 # (2)^2 + 3 - 2*4
+        assert builder._3(a2_plus_b_minus_2c, 2, 4)(3) == 2 # (2)^2 + 4 - 2*3
+
     def test_pipe(self):
         assert builder.pipe(4, add2, mul3) == 18
 
@@ -113,22 +128,67 @@ def test_pipe(self):
 
         assert a == 18 and b == 18 and c == 14
 
+    def test_scope(self):
+        y = builder.ref()
+
+        z = builder.pipe(
+            self.x,
+            { tf.name_scope('TEST'):
+                (
+                _ * 2,
+                _ + 4,
+                builder.store(y)
+                )
+            },
+            _ ** 3
+        )
+
+        assert "TEST/" in y().name
+        assert "TEST/" not in z.name
+
     def test_register(self):
 
+        #register
         assert 5 == builder.pipe(
             3,
             builder.add(2)
         )
 
+        #register2
+        assert 8 == builder.pipe(
+            3,
+            builder.pow(2)
+        )
+
+        #register_method
+        assert "_identity" == builder.get_function_name()
+
     def test_using_run(self):
         assert 8 == builder.using(3).add(2).add(3).run()
 
     def test_reference(self):
         ref = builder.ref()
 
-        assert 8 == builder.using(3).add(2).store_on(ref).add(3).run()
+        assert 8 == builder.using(3).add(2).store(ref).add(3).run()
         assert 5 == ref()
 
+    def test_ref_props(self):
+
+        a = builder.ref()
+        b = builder.ref()
+
+        assert [7, 3, 5] == builder.pipe(
+            1,
+            add2, a.set,
+            add2, b.set,
+            add2,
+            [
+                builder.identity,
+                a,
+                b
+            ]
+        )
+
 
 
 #
diff --git a/tensorbuilder/tests/test_dsl.py b/tensorbuilder/tests/test_dsl.py
