Disable casting of floats in evaluate() to ints unless cast_to_int set

Author: pgleeson

.github/workflows/ci.yml

@@ -2,9 +2,9 @@ name: Continuous builds
 
 on:
   push:
-    branches: [ main, development, experimental ]
+    branches: [ main, development, experimental, test* ]
   pull_request:
-    branches: [ main, development, experimental ]
+    branches: [ main, development, experimental, test* ]
 
 jobs:
 

src/modelspec/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.2.8"
+__version__ = "0.2.9"
 
 from .base_types import Base, define, has, field, fields, optional, instance_of, in_
 

src/modelspec/utils.py

@@ -9,12 +9,18 @@
 from modelspec.base_types import print_
 from modelspec.base_types import EvaluableExpression
 
+from random import Random
+from typing import Union
+
 verbose = False
 
 
-def load_json(filename):
+def load_json(filename: str):
     """
     Load a generic JSON file
+
+    Args:
+        filename: The name of the JSON file to load
     """
 
     with open(filename) as f:
@@ -23,19 +29,25 @@ def load_json(filename):
     return data
 
 
-def load_yaml(filename):
+def load_yaml(filename: str):
     """
     Load a generic YAML file
+
+    Args:
+        filename: The name of the YAML file to load
     """
     with open(filename) as f:
         data = yaml.load(f, Loader=yaml.SafeLoader)
 
     return data
 
 
-def load_bson(filename):
+def load_bson(filename: str):
     """
     Load a generic BSON file
+
+    Args:
+        filename: The name of the BSON file to load
     """
     with open(filename, "rb") as infile:
         data_encoded = infile.read()
@@ -211,11 +223,26 @@ def _params_info(parameters, multiline=False):
 FORMAT_TENSORFLOW = "tensorflow"
 
 
-def evaluate(expr, parameters={}, rng=None, array_format=FORMAT_NUMPY, verbose=False):
+def evaluate(
+    expr: Union[int, float, str, list, dict],
+    parameters: dict = {},
+    rng: Random = None,
+    array_format: str = FORMAT_NUMPY,
+    verbose: bool = False,
+    cast_to_int: bool = False,
+):
     """
     Evaluate a general string like expression (e.g. "2 * weight") using a dict
     of parameters (e.g. {'weight':10}). Returns floats, ints, etc. if that's what's
     given in expr
+
+    Args:
+        expr: The expression to convert
+        parameters: A dict of the parameters which can be substituted in to the expression
+        rng: The random number generator to use
+        array_format: numpy or tensorflow
+        verbose: Print the calculations
+        cast_to_int: return an int for float/string values if castable
     """
 
     if array_format == FORMAT_TENSORFLOW:
@@ -233,35 +260,39 @@ def evaluate(expr, parameters={}, rng=None, array_format=FORMAT_NUMPY, verbose=F
                 expr
             ]  # replace with the value in parameters & check whether it's float/int...
             if verbose:
-                print_("Using for that param: %s" % _val_info(expr), verbose)
+                print_("   Using for that param: %s" % _val_info(expr), verbose)
 
         if type(expr) == str:
             try:
+                print(1)
                 if array_format == FORMAT_TENSORFLOW:
                     expr = tf.constant(int(expr))
                 else:
                     expr = int(expr)
+                    print(2)
             except:
-                pass
-            try:
-                if array_format == FORMAT_TENSORFLOW:
-                    expr = tf.constant(float(expr))
-                else:
-                    expr = float(expr)
-            except:
-                pass
+
+                try:
+                    if array_format == FORMAT_TENSORFLOW:
+                        expr = tf.constant(float(expr))
+                    else:
+                        expr = float(expr)
+                except:
+                    pass
 
         if type(expr) == list:
             if verbose:
-                print_("Returning a list in format: %s" % array_format, verbose)
+                print_("   Returning a list in format: %s" % array_format, verbose)
             if array_format == FORMAT_TENSORFLOW:
                 return tf.constant(expr, dtype=tf.float64)
             else:
                 return np.array(expr)
 
         if type(expr) == np.ndarray:
             if verbose:
-                print_("Returning a numpy array in format: %s" % array_format, verbose)
+                print_(
+                    "   Returning a numpy array in format: %s" % array_format, verbose
+                )
             if array_format == FORMAT_TENSORFLOW:
                 return tf.convert_to_tensor(expr, dtype=tf.float64)
             else:
@@ -270,22 +301,22 @@ def evaluate(expr, parameters={}, rng=None, array_format=FORMAT_NUMPY, verbose=F
         if "Tensor" in type(expr).__name__:
             if verbose:
                 print_(
-                    "Returning a tensorflow Tensor in format: %s" % array_format,
+                    "   Returning a tensorflow Tensor in format: %s" % array_format,
                     verbose,
                 )
             if array_format == FORMAT_NUMPY:
                 return expr.numpy()
             else:
                 return expr
 
-        if int(expr) == expr:
+        if int(expr) == expr and cast_to_int:
             if verbose:
-                print_("Returning int: %s" % int(expr), verbose)
+                print_("   Returning int: %s" % int(expr), verbose)
             return int(expr)
         else:  # will have failed if not number
             if verbose:
-                print_("Returning float: %s" % expr, verbose)
-            return float(expr)
+                print_("   Returning {}: {}".format(type(expr), expr), verbose)
+            return expr
     except:
         try:
             if rng:
@@ -299,7 +330,7 @@ def evaluate(expr, parameters={}, rng=None, array_format=FORMAT_NUMPY, verbose=F
 
             if verbose:
                 print_(
-                    "Trying to eval [%s] with Python using %s..."
+                    "   Trying to eval [%s] with Python using %s..."
                     % (expr, parameters.keys()),
                     verbose,
                 )
@@ -308,13 +339,14 @@ def evaluate(expr, parameters={}, rng=None, array_format=FORMAT_NUMPY, verbose=F
 
             if verbose:
                 print_(
-                    "Evaluated with Python: {} = {}".format(expr, _val_info(v)), verbose
+                    "   Evaluated with Python: {} = {}".format(expr, _val_info(v)),
+                    verbose,
                 )
 
             if (type(v) == float or type(v) == str) and int(v) == v:
 
                 if verbose:
-                    print_("Returning int: %s" % int(v), verbose)
+                    print_("   Returning int: %s" % int(v), verbose)
 
                 if array_format == FORMAT_TENSORFLOW:
                     return tf.constant(int(v))
@@ -323,7 +355,7 @@ def evaluate(expr, parameters={}, rng=None, array_format=FORMAT_NUMPY, verbose=F
             return v
         except Exception as e:
             if verbose:
-                print_(f"Returning without altering: {expr} (error: {e})", verbose)
+                print_(f"   Returning without altering: {expr} (error: {e})", verbose)
             return expr
 
 

tests/test_utils.py

@@ -19,12 +19,16 @@ def test_evaluate(self):
         params = {"p": 33}
         assert evaluate("p+p", params, verbose=True) == 66
 
+        print("======")
         assert type(evaluate("33")) == int
-        assert type(evaluate("33.0")) == int
+        assert type(evaluate("33", cast_to_int=True)) == int
+        assert type(evaluate("33.0")) == float
+        assert type(evaluate("33.0", cast_to_int=True)) == int
+
         assert type(evaluate("33.1")) == float
-        assert type(evaluate("33.1a")) == str
+        assert type(evaluate("33.1a", verbose=True)) == str
 
-        assert type(evaluate("33.1a")) == str
+        assert type(evaluate("a")) == str
 
         import random
 
@@ -41,6 +45,21 @@ def test_evaluate(self):
 
         assert evaluate("a+b", params, verbose=True)[2] == 3
 
+        params = {"a1": np.array([1]), "b": np.array([1, 1, 3])}
+
+        a1_b = evaluate("a1+b", params, verbose=True)
+        assert a1_b[2] == 4
+
+        params = {"A": np.ones([2, 2]), "B": np.ones([2, 2])}
+
+        AplusB = evaluate("A+B", params, verbose=True)
+        assert AplusB[0, 0] == 2
+        assert AplusB.shape == (2, 2)
+
+        AtimesB = evaluate("A*B", params, verbose=True)
+        assert AtimesB[0, 0] == 1
+        assert AtimesB.shape == (2, 2)
+
     def test_val_info_tuple(self):
         print(_val_info((1, 2)))
         print(_val_info((("test", 1), 2)))