Fixed bug with repr_on not correctly propagated. Added corresponding test and readme

Author: Sylvain MARIE

code_generation/tpl_magic_methods.mako

@@ -49,7 +49,7 @@ class _LambdaExpressionGenerated(_LambdaExpressionBase):
 
         # return a new LambdaExpression of the same type than self, with the new function as inner function
         string_expr = '${o.uni_operator}' + get_repr(self, ${o.precedence_level})
-        return type(self)(fun=_${o.method_name}, precedence_level=${o.precedence_level}, str_expr=string_expr, root_var=self._root_var)
+        return type(self)(fun=_${o.method_name}, precedence_level=${o.precedence_level}, str_expr=string_expr, root_var=self._root_var, repr_on=self.repr_on)
 
     ## -----------------------------
         % elif o.pair_operator:

docs/index.md

@@ -4,6 +4,8 @@
 
 [![Build Status](https://travis-ci.org/smarie/python-mini-lambda.svg?branch=master)](https://travis-ci.org/smarie/python-mini-lambda) [![Tests Status](https://smarie.github.io/python-mini-lambda/junit/junit-badge.svg?dummy=8484744)](https://smarie.github.io/python-mini-lambda/junit/report.html) [![codecov](https://codecov.io/gh/smarie/python-mini-lambda/branch/master/graph/badge.svg)](https://codecov.io/gh/smarie/python-mini-lambda) [![Documentation](https://img.shields.io/badge/docs-latest-blue.svg)](https://smarie.github.io/python-mini-lambda/) [![PyPI](https://img.shields.io/badge/PyPI-mini_lambda-blue.svg)](https://pypi.python.org/pypi/mini_lambda/)[![downloads](https://img.shields.io/badge/downloads%2008%2F18-18k-brightgreen.svg)](https://kirankoduru.github.io/python/pypi-stats.html)
 
+!!! success "`repr` is now enabled by default for expressions! More details [here](#new-repr-now-enabled-by-default)"
+
 This idea initially comes from the [valid8](https://smarie.github.io/python-valid8/) validation library. I ended up understanding that there were two complementary ways to provide users with easy-to-use validation functions:
 
  * either to provide a very exhaustive catalog of functions to cover most use cases (is greater than, is between, etc.). *Drawback*: we need to reinvent all functions that exist already.
@@ -45,7 +47,8 @@ print(say_hello_function)       # "'Hello, ' + s + ' !'"
 Most of python syntax can be used in an expression:
 
 ```python
-from mini_lambda import x, s, _, Log
+from mini_lambda import x, s, _
+from mini_lambda.symbols.math_ import Log
 
 # various lambda functions
 is_lowercase             = _( s.islower() )
@@ -72,7 +75,7 @@ print(complex_identity)         # log(10 ** x, 10)
 If you know python you should feel at home here, except for two things:
 
  * `or` and `and` should be replaced with their bitwise equivalents `|` and `&`
- * additional constants, methods and classes need to be made lambda-friendly before use. For convenience all of the [built-in functions](https://docs.python.org/3/library/functions.html) as well as constants, methods and classes from the `math.py` and `decimal.py` modules are provided in a lambda-friendly way by this package, hence the `from mini_lambda import Log` above.
+ * additional constants, methods and classes need to be made lambda-friendly before use. For convenience all of the [built-in functions](https://docs.python.org/3/library/functions.html) as well as constants, methods and classes from the `math.py` and `decimal.py` modules are provided in a lambda-friendly way by this package, hence the `from mini_lambda.symbols.math_ import Log` above.
 
 Note that the printed version provides the minimal equivalent representation taking into account operator precedence. Hence `numeric_test_2` got rid of the useless parenthesis. This is **not** a mathematical simplification like in [SymPy](http://www.sympy.org/fr/), i.e. `x - x` will **not** be simplified to `0`.
 
@@ -84,11 +87,32 @@ There are of course a few limitations to `mini_lambda` as compared to full-flavo
 
 Check the [Usage](./usage/) page for more details.
 
+## New: `repr` now enabled by default
+
+Starting in version 2.0.0, the representation of lambda expressions does not raise exceptions anymore by default. This behaviour was a pain for developers, and was only like this for the very rare occasions where `repr` was used in the expression.
+
+So now
+
+```python
+>>> from mini_lambda import x
+>>> x ** 2
+<_LambdaExpression: x ** 2>
+```
+
+If you wish to bring back the old exception-raising behaviour, simply set the `repr_on` attribute of your expressions to `False`:
+
+```python
+>>> from mini_lambda import x
+>>> x.repr_on = False
+>>> x ** 2
+(...)
+mini_lambda.base.FunctionDefinitionError: __repr__ is not supported by this Lambda Expression. (...)
+```
 
 ## Main features
 
  * More compact lambda expressions for single-variable functions
- * As close to python syntax as technically possible: the base type for lambda expressions in `mini_lambda`, `_LambdaExpression`, overrides all operators that can be overriden as of today in [python 3.6](https://docs.python.org/3/reference/datamodel.html). The remaining limits come from the language itself, for example chained comparisons and `and/or` are not supported as python casts the partial results to boolean to enable short-circuits. Details [here](./usage#lambda-expression-syntax).
+ * As close to python syntax as technically possible: the base type for lambda expressions in `mini_lambda`, `_LambdaExpression`, overrides all operators that can be overriden as of today in [python](https://docs.python.org/3/reference/datamodel.html). The remaining limits come from the language itself, for example chained comparisons and `and/or` are not supported as python casts the partial results to boolean to enable short-circuits. Details [here](./usage#lambda-expression-syntax).
  * Printability: expressions can be turned to string representation in order to (hopefully) get interpretable messages more easily, for example when the expression is used in a [validation context](https://github.com/smarie/python-valid8)
 
 

mini_lambda/base.py

@@ -219,8 +219,7 @@ def evaluate_inner_function_and_apply_object_method(raw_input):
                       + ', '.join([arg_name + '=' + get_repr(arg, None) for arg_name, arg in m_kwargs.items()]) + ')'
         return type(self)(fun=evaluate_inner_function_and_apply_object_method,
                           precedence_level=_PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,
-                          str_expr=string_expr,
-                          root_var=root_var)
+                          str_expr=string_expr, root_var=root_var, repr_on=self.repr_on)
 
     @classmethod
     def constant(cls,
@@ -303,7 +302,7 @@ def evaluate_all_and_apply_method(input):
 
             return cls(fun=evaluate_all_and_apply_method,
                        precedence_level=_PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,
-                       str_expr=string_expr, root_var=root_var)
+                       str_expr=string_expr, root_var=root_var, repr_on=first_expression.repr_on)
 
 
 def _get_root_var(*args, **kwargs):

mini_lambda/main.py

@@ -151,7 +151,7 @@ def evaluate_both_inner_functions_and_combine(input):
             return _LambdaExpression(fun=evaluate_both_inner_functions_and_combine,
                                      precedence_level=_PRECEDENCE_BITWISE_AND,
                                      str_expr=string_expr,
-                                     root_var=root_var)
+                                     root_var=root_var, repr_on=self.repr_on)
 
     def __or__(self, other):
         """
@@ -201,7 +201,7 @@ def evaluate_both_inner_functions_and_combine(input):
             return _LambdaExpression(fun=evaluate_both_inner_functions_and_combine,
                                      precedence_level=_PRECEDENCE_BITWISE_OR,
                                      str_expr=string_expr,
-                                     root_var=root_var)
+                                     root_var=root_var, repr_on=self.repr_on)
 
     def __xor__(self, other):
         """
@@ -242,7 +242,7 @@ def evaluate_both_inner_functions_and_combine(input):
             return _LambdaExpression(fun=evaluate_both_inner_functions_and_combine,
                                      precedence_level=_PRECEDENCE_BITWISE_XOR,
                                      str_expr=string_expr,
-                                     root_var=root_var)
+                                     root_var=root_var, repr_on=self.repr_on)
 
     def not_(self):
         """ Returns a new _LambdaExpression performing 'not x' on the result of this expression's evaluation """
@@ -299,7 +299,7 @@ def ___getattr__(input):
         # return a new LambdaExpression of the same type than self, with the new function as inner function
         string_expr = get_repr(self, _PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF) + '.' + name
         return type(self)(fun=___getattr__, precedence_level=_PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,
-                          str_expr=string_expr, root_var=root_var)
+                          str_expr=string_expr, root_var=root_var, repr_on=self.repr_on)
 
     # Special case for the string representation
     def __call__(self, *args, **kwargs):
@@ -320,7 +320,7 @@ def ___call__(input):
                       + (', ' if (len(args) > 0 and len(kwargs) > 0) else '')\
                       + ', '.join([arg_name + '=' + get_repr(arg, None) for arg_name, arg in kwargs.items()]) + ')'
         return type(self)(fun=___call__, precedence_level=_PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,
-                          str_expr=string_expr, root_var=root_var)
+                          str_expr=string_expr, root_var=root_var, repr_on=self.repr_on)
 
     # Special case for the string representation
     def __getitem__(self, key):
@@ -338,7 +338,7 @@ def ___getitem__(input):
         string_expr = get_repr(self, _PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF) \
                       + '[' + get_repr(key, None) + ']'
         return type(self)(fun=___getitem__, precedence_level=_PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,
-                          str_expr=string_expr, root_var=root_var)
+                          str_expr=string_expr, root_var=root_var, repr_on=self.repr_on)
 
     # Special case for string representation because pow is asymetric in precedence
     def __pow__(self, other):
@@ -353,7 +353,8 @@ def ___pow__(input):
         # return a new LambdaExpression of the same type than self, with the new function as inner function
         string_expr = get_repr(self, _PRECEDENCE_EXPONENTIATION) + ' ** ' \
                       + get_repr(other, _PRECEDENCE_POS_NEG_BITWISE_NOT)
-        return type(self)(fun=___pow__, precedence_level=13, str_expr=string_expr, root_var=root_var)
+        return type(self)(fun=___pow__, precedence_level=13, str_expr=string_expr, root_var=root_var,
+                          repr_on=self.repr_on)
 
     # Special case for string representation because pow is asymetric in precedence
     def __rpow__(self, other):
@@ -368,7 +369,8 @@ def ___rpow__(input):
         # return a new LambdaExpression of the same type than self, with the new function as inner function
         string_expr = get_repr(other, _PRECEDENCE_EXPONENTIATION) + ' ** ' \
                       + get_repr(self, _PRECEDENCE_POS_NEG_BITWISE_NOT)
-        return type(self)(fun=___rpow__, precedence_level=13, str_expr=string_expr, root_var=root_var)
+        return type(self)(fun=___rpow__, precedence_level=13, str_expr=string_expr, root_var=root_var,
+                          repr_on=self.repr_on)
 
     # Special case : unbound function call but with left/right
     def __divmod__(self, other):
@@ -385,7 +387,7 @@ def ___divmod__(input):
         # Note: we use precedence=None for coma-separated items inside the parenthesis
         string_expr = 'divmod(' + get_repr(self, None) + ', ' + get_repr(other, None) + ')'
         return type(self)(fun=___divmod__, precedence_level=_PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,
-                          str_expr=string_expr, root_var=root_var)
+                          str_expr=string_expr, root_var=root_var, repr_on=self.repr_on)
 
     # Special case : unbound function call but with left/right
     def __rdivmod__(self, other):
@@ -402,7 +404,7 @@ def ___rdivmod__(input):
         # Note: we use precedence=None for coma-separated items inside the parenthesis
         string_expr = 'divmod(' + get_repr(other, None) + ', ' + get_repr(self, None) + ')'
         return type(self)(fun=___rdivmod__, precedence_level=_PRECEDENCE_SUBSCRIPTION_SLICING_CALL_ATTRREF,
-                          str_expr=string_expr, root_var=root_var)
+                          str_expr=string_expr, root_var=root_var, repr_on=self.repr_on)
 
     # special case: format(x, args) does not work but x.format() works
     def __format__(self, *args):

mini_lambda/tests/test_readme.py

@@ -177,11 +177,15 @@ def test_doc_usage_syntax_2():
         expr = 'hello'[0:i]                   # fails
     expr = Get('hello', Slice(0, i))      # OK
     # representing: Repr/Str/Bytes/Sizeof/Hash
-    assert repr(l) == '<_LambdaExpression: l>'
-    l.repr_on = False
+    assert repr(x) == '<_LambdaExpression: x>'
+    x.repr_on = False
     with pytest.raises(FunctionDefinitionError):
-        expr = repr(l)                        # fails
-    expr = Repr(l)                        # OK
+        expr = repr(x)                        # fails
+    expr = Repr(x)                        # OK
+    # propagation
+    with pytest.raises(FunctionDefinitionError):
+        expr = repr(x ** 2)                        # fails
+    expr = Repr(x ** 2)                        # OK
     # formatting with the variable in the args
     with pytest.raises(FunctionDefinitionError):
         expr = '{} {}'.format(s, s)           # fails