1.1.0 - Compatibility with standard functions

 * It is now possible to use any function in a lambda expression, through use of the `make_lambda_friendly_...` methods
 * All `built-in` methods as well as all constants, methods and classes from the `math.py` and `decimal.py` modules are provided in a lambda-friendly way by the package for convenience
 * Updated documentation accordingly, and made main page clearer
 * Renamed class `_InputEvaluator` into `_LambdaExpression`
 * A few bugfixes in particular support for keyword arguments when a function call is made in a lambda expression
 * `<expr>.nnot()`, `<expr>.any()` and `<expr>.all()` renamed `<expr>.not_()`, `<expr>.any_()` and `<expr>.all_()` for consistency and to avoid conflicts with any()/all() methods that would already be defined in the class, for example NumPy.

base.py:
- StackableFunctionEvaluator renamed _LambdaExpressionBase.
- Added the notion of constant expression
- Added support of keyword arguments in all 'add_.._methods'
- Added make_lambda_friendly_method and utility method _get_expr_or_result_for_method which becomes the single conversion method for all non-class methods

code generation:
- Support for constant expressions in all generated methods
- Added support of keyword arguments
- _get_expr_or_result_for_method is used everywhere as possible
- added missing method __round__
- New template for pre-converted constants/functions/classes, generating goodies_generated.py

main.py
- Support for constant expressions
- Added support of keyword arguments in __call__
- Added __format__ as a special methods
- Added .is_in()
- Added make_lambda_friendly_class and Constant() (alias C())
- Added another alias for _() : F()
- Get and Slice are simplified now that they use _get_expr_or_result_for_method
- Any/All removed as they are now directly part of the generated methods in goodies_generated.py
-  * `<expr>.nnot()`, `<expr>.any()` and `<expr>.all()` renamed `<expr>.not_()`, `<expr>.any_()` and `<expr>.all_()` for consistency and to avoid conflicts with any()/all() methods that would already be defined in the class, for example NumPy.

goodies.py
- Added a few precreated variables

Author: smarie

code_generation/goodies_template.mako

@@ -0,0 +1,22 @@
+# ----
+# This file is generated by mini_lambda_methods_generation.py - do not modify it !
+# ----
+from mini_lambda.base import make_lambda_friendly_method
+from mini_lambda.main import C, make_lambda_friendly_class
+
+% for o in import_lines:
+${o}
+% endfor
+
+% for o in to_create:
+    % if o.constant_name:
+${o.item_name} = C(${o.constant_name}, '${o.constant_name}')
+    % elif o.function_name:
+${o.item_name} = make_lambda_friendly_method(${o.function_name}, '${o.function_name}')
+    % else:
+## CLASS
+${o.item_name} = make_lambda_friendly_class(${o.class_name})
+    % endif
+
+
+% endfor

code_generation/mini_lambda_methods_generation.py

@@ -1,16 +1,19 @@
+from inspect import isclass
 from sys import getsizeof
-from typing import Tuple, Set, Optional, Any
+from typing import Tuple, Set, Optional, Any, List
 
 import os
+import math
 
 # from quik import Template
+import decimal
 from mako import exceptions
 from mako.template import Template
 
 # from sortedcontainers import SortedSet
 from ordered_set import OrderedSet
 
-from autoclass import autoclass
+from autoclass import autoclass, getmembers
 from enforce import runtime_validation
 
 
@@ -27,7 +30,7 @@ def __init__(self, method_name: str,
         """
         A descriptor for a method to override in _InputEvaluatorGenerated.
         * If only method_name is provided, the overriden method adds itself to the stack
-        (see StackableFunctionEvaluator)
+        (see _LambdaExpressionBase)
         * If unbound_method is provided, the overriden method adds the provided unbound method to the stack
         * If operator and is_operator_left are provided, the overriden method adds a method performing
         (args <operator> x) if is_operator_left=False or (x <operator> args) if is_operator_left=True.
@@ -70,7 +73,7 @@ def __init__(self, method_name: str,
         replacement method needs to be provided.
 
         The method_name will raise an exception and indicate that module_method_name is the replacement method. The
-        latter will implement by adding method_name to the stack (see StackableFunctionEvaluator). If unbound_method is
+        latter will implement by adding method_name to the stack (see _LambdaExpressionBase). If unbound_method is
         provided, the module method will add unbound_method to the stack instead of method_name.
 
         By default module_method_name is equal to a capitalized, underscores-removed, version of the method name.
@@ -90,36 +93,79 @@ def __str__(self):
         return 'Exception {} replaced by module method {}'.format(self.method_name, self.module_method_name)
 
 
+@runtime_validation
+@autoclass
+class Goodie:
+    def __init__(self, item_name: str, function_name: Optional[str] = None,
+                 constant_name: Optional[str] = None, class_name: Optional[str] = None):
+        pass
+
+    def __str__(self):
+        if self.function_name:
+            return 'Function {} replaced with {}'.format(self.function_name, self.item_name)
+        elif self.constant_name:
+            return 'Constant {} replaced with {}'.format(self.constant_name, self.item_name)
+        else:
+            return 'Class {} replaced with {}'.format(self.class_name, self.item_name)
+
+
 def generate_code():
     """
     This method reads the template file, fills it with the appropriate contents, and writes the result in the
     mini_lambda_generated.py file. All contents of the destination file are overriden by this operation.
     :return:
     """
 
-    # generate the to-do list
+    # (1) generate the to-do list for the first template
     to_override, to_override_with_exception = define_what_needs_to_be_written()
+
     # check outside of the template that it works:
     for o in to_override:
         print(o)
     for o in to_override_with_exception:
         print(o)
 
+    # generate
+    generate_from_template('mini_lambda_template.mako', 'generated.py',
+                           dict(to_override=to_override, to_override_with_exception=to_override_with_exception))
+
+    # (2) to-do list for the second template
+    import_lines, to_create = define_goodies()
+
+    # check outside of the template that it works:
+    for o in import_lines:
+        print(o)
+    for o in to_create:
+        print(o)
+
+    # generate
+    generate_from_template('goodies_template.mako', 'goodies_generated.py',
+                           dict(import_lines=import_lines, to_create=to_create))
+
+
+def generate_from_template(src_file, dst_file, template_vars):
+    """
+    Routine to open a source template file, load the variables inside and dump the result in the destination file
+
+    :param dst_file:
+    :param src_file:
+    :param template_vars:
+    :return:
+    """
     # open the mako template file
     THIS_DIR = os.path.dirname(__file__)
-    template_file = os.path.join(THIS_DIR, 'mini_lambda_template.mako')
+    template_file = os.path.join(THIS_DIR, src_file)
     with open(template_file) as f:
         body = f.read()
-
     try:
         # create the template
         temp = Template(text=body)  # , module_directory=os.path.join(THIS_DIR, 'tmp'))
 
         # fill it with the variables contents
-        res = temp.render(to_override=to_override, to_override_with_exception=to_override_with_exception)
+        res = temp.render(**template_vars)
 
         # write the result to the destination file
-        dest_file = os.path.join(THIS_DIR, os.pardir, 'mini_lambda', 'generated.py')
+        dest_file = os.path.join(THIS_DIR, os.pardir, 'mini_lambda', dst_file)
         with open(dest_file, 'wt') as f:
             f.write(res)
     except:
@@ -177,18 +223,19 @@ def define_what_needs_to_be_written() -> Tuple[Set[Override], Set[OverExc]]:
     to_override_with_exception.add(OverExc('__str__', unbound_method=str))
     to_override_with_exception.add(OverExc('__repr__', unbound_method=repr))
     to_override_with_exception.add(OverExc('__bytes__', unbound_method=bytes))
+    # this is a special case
     to_override_with_exception.add(OverExc('__format__', unbound_method=format))
     to_override_with_exception.add(OverExc('__sizeof__', unbound_method=getsizeof))
 
     # ** Comparable Objects **
     # .__lt__, .__le__, .__eq__, .__ne__, .__gt__, .__ge__
     # to_override.update(__get_all_magic_methods(Set))
-    to_override.add(Override('__lt__', pair_operator='<', precedence_level='PRECEDENCE_COMPARISON'))
-    to_override.add(Override('__le__', pair_operator='<=', precedence_level='PRECEDENCE_COMPARISON'))
-    to_override.add(Override('__eq__', pair_operator='==', precedence_level='PRECEDENCE_COMPARISON'))
-    to_override.add(Override('__ne__', pair_operator='!=', precedence_level='PRECEDENCE_COMPARISON'))
-    to_override.add(Override('__gt__', pair_operator='>', precedence_level='PRECEDENCE_COMPARISON'))
-    to_override.add(Override('__ge__', pair_operator='>=', precedence_level='PRECEDENCE_COMPARISON'))
+    to_override.add(Override('__lt__', pair_operator='<', precedence_level='_PRECEDENCE_COMPARISON'))
+    to_override.add(Override('__le__', pair_operator='<=', precedence_level='_PRECEDENCE_COMPARISON'))
+    to_override.add(Override('__eq__', pair_operator='==', precedence_level='_PRECEDENCE_COMPARISON'))
+    to_override.add(Override('__ne__', pair_operator='!=', precedence_level='_PRECEDENCE_COMPARISON'))
+    to_override.add(Override('__gt__', pair_operator='>', precedence_level='_PRECEDENCE_COMPARISON'))
+    to_override.add(Override('__ge__', pair_operator='>=', precedence_level='_PRECEDENCE_COMPARISON'))
 
     # ** Hashable Object **
     # .__hash__
@@ -255,34 +302,35 @@ def define_what_needs_to_be_written() -> Tuple[Set[Override], Set[OverExc]]:
     # .__lshift__, .__rshift__, __rlshift__, __rrshift__
     # .__neg__, .__pos__, .__abs__, .__invert__
     # to_override.update(__get_all_magic_methods(Integral))
-    to_override.add(Override('__add__', pair_operator='+', precedence_level='PRECEDENCE_ADD_SUB'))
-    to_override.add(Override('__radd__', pair_operator='+', is_operator_left=False, precedence_level='PRECEDENCE_ADD_SUB'))
-    to_override.add(Override('__sub__', pair_operator='-', precedence_level='PRECEDENCE_ADD_SUB'))
-    to_override.add(Override('__rsub__', pair_operator='-', is_operator_left=False, precedence_level='PRECEDENCE_ADD_SUB'))
-    to_override.add(Override('__mul__', pair_operator='*', precedence_level='PRECEDENCE_MUL_DIV_ETC'))
-    to_override.add(Override('__rmul__', pair_operator='*', is_operator_left=False, precedence_level='PRECEDENCE_MUL_DIV_ETC'))
-    to_override.add(Override('__truediv__', pair_operator='/', precedence_level='PRECEDENCE_MUL_DIV_ETC'))
-    to_override.add(Override('__rtruediv__', pair_operator='/', is_operator_left=False, precedence_level='PRECEDENCE_MUL_DIV_ETC'))
-    to_override.add(Override('__mod__', pair_operator='%', precedence_level='PRECEDENCE_MUL_DIV_ETC'))
-    to_override.add(Override('__rmod__', pair_operator='%', is_operator_left=False, precedence_level='PRECEDENCE_MUL_DIV_ETC'))
+    to_override.add(Override('__add__', pair_operator='+', precedence_level='_PRECEDENCE_ADD_SUB'))
+    to_override.add(Override('__radd__', pair_operator='+', is_operator_left=False, precedence_level='_PRECEDENCE_ADD_SUB'))
+    to_override.add(Override('__sub__', pair_operator='-', precedence_level='_PRECEDENCE_ADD_SUB'))
+    to_override.add(Override('__rsub__', pair_operator='-', is_operator_left=False, precedence_level='_PRECEDENCE_ADD_SUB'))
+    to_override.add(Override('__mul__', pair_operator='*', precedence_level='_PRECEDENCE_MUL_DIV_ETC'))
+    to_override.add(Override('__rmul__', pair_operator='*', is_operator_left=False, precedence_level='_PRECEDENCE_MUL_DIV_ETC'))
+    to_override.add(Override('__truediv__', pair_operator='/', precedence_level='_PRECEDENCE_MUL_DIV_ETC'))
+    to_override.add(Override('__rtruediv__', pair_operator='/', is_operator_left=False, precedence_level='_PRECEDENCE_MUL_DIV_ETC'))
+    to_override.add(Override('__mod__', pair_operator='%', precedence_level='_PRECEDENCE_MUL_DIV_ETC'))
+    to_override.add(Override('__rmod__', pair_operator='%', is_operator_left=False, precedence_level='_PRECEDENCE_MUL_DIV_ETC'))
     to_override.add(Override('__divmod__'))
     to_override.add(Override('__rdivmod__'))
-    to_override.add(Override('__pow__', pair_operator='**', precedence_level='PRECEDENCE_EXPONENTIATION'))
-    to_override.add(Override('__rpow__', pair_operator='**', is_operator_left=False, precedence_level='PRECEDENCE_EXPONENTIATION'))
-    to_override.add(Override('__matmul__', pair_operator='@', precedence_level='PRECEDENCE_MUL_DIV_ETC'))
+    to_override.add(Override('__pow__', pair_operator='**', precedence_level='_PRECEDENCE_EXPONENTIATION'))
+    to_override.add(Override('__rpow__', pair_operator='**', is_operator_left=False, precedence_level='_PRECEDENCE_EXPONENTIATION'))
+    to_override.add(Override('__matmul__', pair_operator='@', precedence_level='_PRECEDENCE_MUL_DIV_ETC'))
     # Override('__rmatmul__', operator='@', is_operator_left=False),
-    to_override.add(Override('__floordiv__', pair_operator='//', precedence_level='PRECEDENCE_MUL_DIV_ETC'))
-    to_override.add(Override('__rfloordiv__', pair_operator='//', is_operator_left=False, precedence_level='PRECEDENCE_MUL_DIV_ETC'))
-    to_override.add(Override('__lshift__', pair_operator='<<', precedence_level='PRECEDENCE_SHIFTS'))
-    to_override.add(Override('__rlshift__', pair_operator='<<', is_operator_left=False, precedence_level='PRECEDENCE_SHIFTS'))
-    to_override.add(Override('__rshift__', pair_operator='>>', precedence_level='PRECEDENCE_SHIFTS'))
-    to_override.add(Override('__rrshift__', pair_operator='>>', is_operator_left=False, precedence_level='PRECEDENCE_SHIFTS'))
-    to_override.add(Override('__rshift__', pair_operator='>>', precedence_level='PRECEDENCE_SHIFTS'))
-    to_override.add(Override('__rshift__', pair_operator='>>', precedence_level='PRECEDENCE_SHIFTS'))
-    to_override.add(Override('__neg__', uni_operator='-', precedence_level='PRECEDENCE_POS_NEG_BITWISE_NOT'))
-    to_override.add(Override('__pos__', uni_operator='+', precedence_level='PRECEDENCE_POS_NEG_BITWISE_NOT'))
+    to_override.add(Override('__floordiv__', pair_operator='//', precedence_level='_PRECEDENCE_MUL_DIV_ETC'))
+    to_override.add(Override('__rfloordiv__', pair_operator='//', is_operator_left=False, precedence_level='_PRECEDENCE_MUL_DIV_ETC'))
+    to_override.add(Override('__lshift__', pair_operator='<<', precedence_level='_PRECEDENCE_SHIFTS'))
+    to_override.add(Override('__rlshift__', pair_operator='<<', is_operator_left=False, precedence_level='_PRECEDENCE_SHIFTS'))
+    to_override.add(Override('__rshift__', pair_operator='>>', precedence_level='_PRECEDENCE_SHIFTS'))
+    to_override.add(Override('__rrshift__', pair_operator='>>', is_operator_left=False, precedence_level='_PRECEDENCE_SHIFTS'))
+    to_override.add(Override('__rshift__', pair_operator='>>', precedence_level='_PRECEDENCE_SHIFTS'))
+    to_override.add(Override('__rshift__', pair_operator='>>', precedence_level='_PRECEDENCE_SHIFTS'))
+    to_override.add(Override('__neg__', uni_operator='-', precedence_level='_PRECEDENCE_POS_NEG_BITWISE_NOT'))
+    to_override.add(Override('__pos__', uni_operator='+', precedence_level='_PRECEDENCE_POS_NEG_BITWISE_NOT'))
     to_override.add(Override('__abs__', unbound_method=abs))
-    to_override.add(Override('__invert__', uni_operator='~', precedence_level='PRECEDENCE_POS_NEG_BITWISE_NOT'))
+    to_override.add(Override('__invert__', uni_operator='~', precedence_level='_PRECEDENCE_POS_NEG_BITWISE_NOT'))
+    to_override.add(Override('__round__', unbound_method=round))
 
     # ** Boolean types **
     # .__and__, .__xor__, .__or__, __rand__, __rxor__, __ror__
@@ -321,5 +369,48 @@ def define_what_needs_to_be_written() -> Tuple[Set[Override], Set[OverExc]]:
     return to_override_2, to_override_with_exception_2
 
 
+def define_goodies() -> Tuple[List[str], List[Goodie]]:
+    """
+
+    :return:
+    """
+    packages = [math, decimal]
+    built_in_functions = ['abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr',
+                          'classmethod', 'compile', 'complex', 'delattr', 'dict', 'dir', 'divmod', 'enumerate',
+                          'eval', 'exec', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',
+                          'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len',
+                          'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord',
+                          'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice',
+                          'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
+
+    import_list = list()
+    goodies_list = list()
+
+    for package in packages:
+        # import pprint
+        # pprint(getmembers(math, callable))
+        import_string = "from " + package.__name__ + " import"
+        for item_name, item in getmembers(package):
+            if not item_name.startswith('_'):
+                import_string += ' ' + item_name + ','
+                if isclass(item):
+                    new_class_name = item_name[0].upper() + item_name
+                    goodies_list.append(Goodie(item_name=new_class_name, class_name=item_name))
+                elif callable(item):
+                    goodies_list.append(Goodie(item_name=item_name.capitalize(), function_name=item_name))
+                else:
+                    new_item_name = item_name.capitalize()
+                    if new_item_name == item_name:
+                        new_item_name = new_item_name[0] + new_item_name
+                    goodies_list.append(Goodie(item_name=new_item_name, constant_name=item_name))
+
+        import_list.append(import_string[0:-1])
+
+    for function_name in built_in_functions:
+        goodies_list.append(Goodie(item_name=function_name.capitalize(), function_name=function_name))
+
+    return import_list, goodies_list
+
+
 if __name__ == '__main__':
     generate_code()