Added the possibility to transform normal methods into lambda-friendly methods

 * Added `make_lambda_friendly` (fixes #1)
 * Separated goodies from main and added in goodies auto-generation of common methods (all the ones from the math.py module)
 * Added corresponding tests
 * minor display fix in add_unbound_method_to_stack

Author: smarie

mini_lambda/__init__.py

@@ -4,9 +4,10 @@
 from mini_lambda.generated import *
 from mini_lambda.main import *
 from mini_lambda.main import _
+from mini_lambda.goodies import *
 # more user-friendly: provide a mapping to numbers package ? No, it might confuse users..
 # from numbers import *
 
 # allow users to do
 #     import mini_lambda as v
-__all__ = ['base', 'generated', 'main']
+__all__ = ['base', 'generated', 'main', 'goodies']

mini_lambda/base.py

@@ -125,7 +125,7 @@ def evaluate_inner_function_and_apply_method(input):
 
         # return a new InputEvaluator of the same type than self, with the new function as inner function
         # Note: we use precedence=None for coma-separated items inside the parenthesis
-        string_expr = method.__name__ + '(' + get_repr(self, None) + ', ' \
+        string_expr = method.__name__ + '(' + get_repr(self, None) + (', ' if len(m_args) > 0 else '') \
                       + ', '.join([get_repr(arg, None) for arg in m_args]) + ')'
         return type(self)(fun=evaluate_inner_function_and_apply_method,
                           precedence_level=PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,

mini_lambda/goodies.py

@@ -0,0 +1,22 @@
+import math
+
+from mini_lambda.main import InputVar, make_lambda_friendly
+from inspect import getmembers
+
+# Useful input variables
+s = InputVar('s', str)
+x = InputVar('x', int)
+l = InputVar('l', list)
+
+
+# Useful functions
+for package in [math]:
+    # import pprint
+    # pprint(getmembers(math, callable))
+    for method_name, method in getmembers(package, callable):
+        if not method_name.startswith('_'):
+            # TODO maybe further filter only on methods with a single argument using signature ?
+
+            # create an equivalent method compliant with lambda expressions
+            print('Creating method ' + method_name.capitalize())
+            globals()[method_name.capitalize()] = make_lambda_friendly(method)

mini_lambda/main.py

@@ -1,4 +1,5 @@
-from typing import Type, TypeVar, Union, Tuple
+from copy import copy
+from typing import Type, TypeVar, Union, Tuple, Callable
 from warnings import warn
 import sys
 
@@ -543,6 +544,43 @@ def _(*evaluators: _LambdaExpression) -> Union[_LambdaExpression.LambdaFunction,
 """ Alias for '_' """
 
 
+def make_lambda_friendly(method: Callable, name: str = None):
+    """
+    Utility method to transform any standard method, for example math.log, into a method usable inside lambda
+    expressions. For example
+
+    ```python
+    from mini_lambda import x, _
+    from math import log, e
+
+    Log = make_lambda_friendly(log)
+
+    # now you can use Log in your expressions
+    complex_identity = _(Log(e ** x))
+    ```
+
+    :param method:
+    :param name: an optional name for the method when used to display the expressions.
+    :return:
+    """
+
+    # If the provided method does not have a name then name is mandatory
+    if not hasattr(method, '__name__') and name is None:
+            raise ValueError('This method does not have a name (it is either a partial or a lambda) so you have to '
+                             'provide one: the \'name\' argument is mandatory')
+
+    # create a named method if a new name is provided
+    if name is not None:
+        method = copy(method)  # work on a copy just in case
+        method.__name__ = name
+
+    def lambda_friendly_method(evaluator: _LambdaExpression):
+        """ This is a replacement method for your method """
+        return evaluator.add_unbound_method_to_stack(method)
+
+    return lambda_friendly_method
+
+
 def InputVar(symbol: str = None, typ: Type[T] = None) -> Union[T, _LambdaExpression]:
     """
     Creates a variable to use in validator expression. The optional `typ` argument may be used to get a variable with
@@ -557,9 +595,3 @@ def InputVar(symbol: str = None, typ: Type[T] = None) -> Union[T, _LambdaExpress
         raise TypeError("symbol should be a string. It is recommended to use a very small string that is identical "
                         "to the python variable name, for example  s = InputVar('s')")
     return _LambdaExpression(symbol)
-
-
-# Useful input variables
-s = InputVar('s', str)
-x = InputVar('x', int)
-l = InputVar('l', list)

mini_lambda/tests/test_mini_lambda.py

@@ -5,7 +5,7 @@
 import sys
 
 from mini_lambda import InputVar, Len, Str, Int, Repr, Bytes, Sizeof, Hash, Bool, Complex, Float, Oct, Iter, \
-    Any, All, _, Slice, Get, Not, FunctionDefinitionError
+    Any, All, _, Slice, Get, Not, FunctionDefinitionError, make_lambda_friendly
 from math import sin, pi, cos
 from numbers import Real
 
@@ -641,3 +641,68 @@ def test_evaluator_different_vars():
     with pytest.raises(FunctionDefinitionError):
         # getattr(a, b)  # getattr(): attribute name must be string
         a.__getattr__(b)
+
+
+def test_add_new_simple():
+    """ Tests that the mechanism provided to support additional functions works, by testing that log2 can be
+    converted """
+
+    from mini_lambda import x, _
+    from math import log, e
+
+    with pytest.raises(FunctionDefinitionError):
+        log(x)
+
+    Log = make_lambda_friendly(log)
+    complex_identity = _(Log(e ** x))
+
+    assert abs(complex_identity(3.5) - 3.5) < 10e-5
+    print(complex_identity)
+    # this is the remaining issue: the value of math.e is displayed instead of 'e'. We have to define 'constants'
+    assert str(complex_identity) == "log(" + str(e) + " ** x)"
+
+
+def test_add_new_complex_partial():
+    """ Tests that the mechanism provided to support additional functions works with partial functions. """
+
+    from functools import partial
+
+    from mini_lambda import x, _
+    from math import log
+
+    with pytest.raises(FunctionDefinitionError):
+        log(x, 10)
+
+    # option 1
+    def log10(x):
+        return log(x, 10)
+    LogBase10 = make_lambda_friendly(log10)
+    complex_identity = _(LogBase10(10 ** x))
+    assert complex_identity(3.5) == 3.5
+    assert str(complex_identity) == 'log10(10 ** x)'
+
+    # option 2: partial (only to fix keyword arguments or to leftmost positional arguments)
+    Log15BaseX = make_lambda_friendly(partial(log, 15), name='log15baseX')
+    complex_identity = _(1 / Log15BaseX(15 ** x))
+    assert complex_identity(3.5) == 3.5
+    assert str(complex_identity) == '1 / log15baseX(15 ** x)'
+
+    # option 3: lambda !  :)
+    LogBase10 = make_lambda_friendly(lambda x: log(x, 10), name='log10')
+    complex_identity = _(LogBase10(10 ** x))
+    assert complex_identity(3.5) == 3.5
+    assert str(complex_identity) == 'log10(10 ** x)'
+
+
+def test_generated_methods():
+    """ Tests that equivalent methods generated by the package from various packages (currently, only math) work"""
+
+    from mini_lambda import x, _, Sin
+    from math import sin
+
+    sine = _(Sin(x))
+
+    assert sine(3.5) == sin(3.5)
+    print(sine)
+
+    assert str(sine) == "sin(x)"