Merge pull request #8 from semiversus/master

remove numpy and pandas to be imported by default

Author: smarie

docs/usage.md

@@ -25,8 +25,8 @@ For convenience, `mini_lambda` comes bundled with the following predefined input
  * boolean/int/float numbers: `b` / `i`, `j`, `n` / `x`, `y`
  * lists/mappings: `l` / `d`
  * callables: `f`
- * numpy arrays (if numpy is present): `X`, `Y`, `M`
- * pandas dataframes (if pandas is present): `df`
+ * numpy arrays (if numpy is present): `X`, `Y`, `M` (from `mini_lambda.numpy`)
+ * pandas dataframes (if pandas is present): `df` (from `mini_lambda.pandas`)
 
 
 ## Lambda Expressions vs Lambda Functions
@@ -148,14 +148,15 @@ or through provided workarounds :
 
 ```python
 from mini_lambda import b, i, s, l, x
-from mini_lambda import Slice, Get, Not, In
+from mini_lambda import Slice, Get, Not, In, And
 from mini_lambda import Iter, Repr, Format, Len, Int, Any, Log, DDecimal
 from math import log
 from decimal import Decimal
 
 # boolean logic
 expr = (x > 1) and (x < 5)            # fails
 expr = (x > 1) & (x < 5)              # OK
+expr = And(x > 1, x < 5)              # OK
 # iterating
 expr = next(iter(s))                  # fails
 expr = next(Iter(s))                  # OK
@@ -207,7 +208,7 @@ As seen above, there are several types of defective behaviours:
 
  * built-in behaviours with special syntax (`not b`, `{'a': 1}[s]`, `x in y`, `any_(x)`). In which case an equivalent explicit method is provided: `Not`, `Get`, `Slice`, `In`, `Any`, `All`. In addition, equivalent methods `<expr>.contains()`, `<expr>.is_in()`, `<expr>.not_()`, `<expr>.any_()`, and `<expr>.all_()` are provided.
 
- * the shortcircuit boolean operators `and/or` can not be overriden and check the return type, so you should use `&` or `|` instead
+ * the shortcircuit boolean operators `and/or` can not be overridden and check the return type, so you should use either bitwise combination (`&` or `|`) or logical (`And` or `Or`) instead.
 
  * any other 'standard' methods, whether they are object constructors `Decimal()` or functions such as `log()`. We will see in the next section how you can convert any existing class or method to a lambda-friendly one. `mini_lambda` comes bundled with a few of them, namely all constants, functions and classes defined in `math` and `decimal` modules.
 
@@ -344,7 +345,8 @@ Note: although the above is valid, it is much more recommended to convert the wh
 Classes can be entirely made lambda-friendly at once. This will convert the constructor, as well as any other method that would be available.
 
 ```python
-from mini_lambda import X, _, make_lambda_friendly_class
+from mini_lambda import _, make_lambda_friendly_class
+from mini_lambda.numpy import X
 import numpy as np
 import pandas as pd
 
@@ -360,7 +362,8 @@ str(expr)               # 'DataFrame(X).max().values[0]'
 Actually the `Constant()` (alias `C()` or `make_lambda_friendly()`) function that we saw above to convert constants, is also able to convert methods ans classes. So if there is only a single conversion operator to remember, remember this one.
 
 ```python
-from mini_lambda import _, C, X
+from mini_lambda import _, C
+from mini_lambda.numpy import X
 import numpy as np
 import pandas as pd
 

mini_lambda/goodies.py

@@ -20,19 +20,3 @@
 
 # callables
 f = InputVar('f', Callable)
-
-try:
-    import numpy as np
-    # matrices/arrays
-    X = InputVar('X', np.ndarray)
-    Y = InputVar('Y', np.ndarray)
-    M = InputVar('M', np.ndarray)
-except:
-    pass
-
-try:
-    # data frames
-    import pandas as pd
-    df = InputVar('df', pd.DataFrame)
-except:
-    pass

mini_lambda/main.py

@@ -428,6 +428,37 @@ def Not(expression: _LambdaExpression):
     return expression.not_()
 
 
+# Logical combinations 'and' and 'or'
+def _and(a, b):
+    return a and b
+
+
+def And(a, b):
+    """
+    Equivalent of 'a and b'.
+
+    :param a: left operand
+    :param b: right operand
+    :return: expression evaluating the and combination
+    """
+    return _LambdaExpression._get_expression_for_method_with_args(_and, a, b)
+
+
+def _or(a, b):
+    return a or b
+
+
+def Or(a, b):
+    """
+    Equivalent of 'a or b'.
+
+    :param a: left operand
+    :param b: right operand
+    :return: expression evaluating the or combination
+    """
+    return _LambdaExpression._get_expression_for_method_with_args(_or, a, b)
+
+
 # Special case: we do not want to use format() but type(value).format. So we override the generated method
 def Format(value, *args, **kwargs):
     """

mini_lambda/numpy.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+from mini_lambda.main import InputVar
+
+
+# matrices/arrays
+X = InputVar('X', np.ndarray)
+Y = InputVar('Y', np.ndarray)
+M = InputVar('M', np.ndarray)

mini_lambda/pandas.py

@@ -0,0 +1,7 @@
+import pandas as pd
+
+from mini_lambda.main import InputVar
+
+
+# data frames
+df = InputVar('df', pd.DataFrame)

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, Format, C
+    Any, All, _, Slice, Get, Not, FunctionDefinitionError, Format, C, And, Or
 from math import cos, isfinite
 from numbers import Real
 
@@ -305,6 +305,41 @@ def test_evaluator_truth_testable_not():
     assert h(0)
     assert not h(5.2)
 
+
+def test_evaluator_logical_and():
+    """ Object: Tests that And function works """
+
+    x = InputVar('x', int)
+
+    with pytest.raises(FunctionDefinitionError):
+        x > 5 and x < 10
+    
+    r = And(x > 5, x < 10)
+    r = r.as_function()
+
+    assert not r(5)
+    assert r(6)
+    assert r(9)
+    assert not r(10)
+
+
+def test_evaluator_logical_or():
+    """ Object: Tests that Or function works """
+
+    x = InputVar('x', int)
+
+    with pytest.raises(FunctionDefinitionError):
+        x < 5 or x > 10
+    
+    r = Or(x < 5, x > 10)
+    r = r.as_function()
+
+    assert r(4)
+    assert not r(5)
+    assert not r(10)
+    assert r(11)
+
+
 # Object: .__getattr__
 def test_evaluator_attribute():
     """ Object: Tests that obj.foo_field works """

mini_lambda/tests/test_readme.py

@@ -303,7 +303,8 @@ def bar2(cls, times, num, den):
 
 def test_doc_usage_other_classes():
     """ Tests that the example in doc/usage in the others/classes section works """
-    from mini_lambda import X, _, make_lambda_friendly_class
+    from mini_lambda import _, make_lambda_friendly_class
+    from mini_lambda.numpy import X
     import numpy as np
     import pandas as pd
 
@@ -316,7 +317,8 @@ def test_doc_usage_other_classes():
 
 def test_doc_usage_all_at_once():
     """ Tests that the example in doc/usage in the others/anything section works """
-    from mini_lambda import _, C, X
+    from mini_lambda import _, C
+    from mini_lambda.numpy import X
     import numpy as np
     import pandas as pd