Merge pull request #28 from ModECI/development

To v0.3.0; not casting floats like 2.0 to int in serialization

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:
 

examples/document.md

@@ -13,7 +13,7 @@ A model for documents.
   <tr>
     <td><b>title</b></td>
     <td>str</td>
-    <td><i>Document title</i></td>
+    <td><i>The document title</i></td>
  </tr>
 
 

examples/document.py

@@ -40,7 +40,7 @@ class Document(Base):
 
     Args:
         id: The unique id of the document
-        title: Document title
+        title: The document title
         ISBN: International Standard Book Number
         sections: The sections of the document
     """
@@ -65,24 +65,29 @@ class Document(Base):
 
 print(doc)
 print(doc.sections[0].paragraphs[0].contents)
-print(doc.sections[0].paragraphs[0].__getattribute__("contents"))
+print(doc.sections[0].paragraphs[1].__getattribute__("contents"))
 
 doc.to_json_file("document.json")
 doc.to_yaml_file("document.yaml")
 doc.to_bson_file("document.bson")
 
+print(" >> Full document details in YAML format:\n")
+
+print(doc.to_yaml())
+
 doc_md = doc.generate_documentation(format="markdown")
 
 with open("document.md", "w") as d:
     d.write(doc_md)
 
+
 doc_rst = doc.generate_documentation(format="rst")
 
 with open("document.rst", "w") as d:
     d.write(doc_rst)
 
 
-print("\nGenerating specification in dict form")
+print("\n  >> Generating specification in dict form...")
 doc_dict = doc.generate_documentation(format="dict")
 
 import json
@@ -92,9 +97,12 @@ class Document(Base):
 with open("document.specification.json", "w") as d:
     d.write(json.dumps(doc_dict, indent=4))
 
-print("Generating specification in YAML")
+print("  >> Generating specification in YAML...\n")
+
 with open("document.specification.yaml", "w") as d:
-    d.write(yaml.dump(doc_dict, indent=4, sort_keys=False))
+    yy = yaml.dump(doc_dict, indent=4, sort_keys=False)
+    print(yy)
+    d.write(yy)
 
 with open("document.specification.bson", "wb") as d:
     d.write(bson.encode(doc_dict))

examples/document.rst

@@ -9,7 +9,7 @@ A model for documents.
 Allowed field    Data Type    Description
 ===============  ===========  ==================================
 **id**           str          The unique id of the document
-**title**        str          Document title
+**title**        str          The document title
 **ISBN**         int          International Standard Book Number
 ===============  ===========  ==================================
 

examples/document.specification.json

@@ -8,7 +8,7 @@
             },
             "title": {
                 "type": "str",
-                "description": "Document title"
+                "description": "The document title"
             },
             "ISBN": {
                 "type": "int",

examples/document.specification.yaml

@@ -6,7 +6,7 @@ Document:
             description: The unique id of the document
         title:
             type: str
-            description: Document title
+            description: The document title
         ISBN:
             type: int
             description: International Standard Book Number

src/modelspec/__init__.py

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

src/modelspec/base_types.py

@@ -205,11 +205,13 @@ def to_yaml(self, include_metadata: bool = True) -> str:
             yaml_converter.unstructure(self.to_dict()), sort_keys=False, indent=4
         )
 
-    def to_yaml_file(self, filename: str, include_metadata: bool = True) -> str:
+    def to_yaml_file(
+        self, filename: Optional[str] = None, include_metadata: Optional[bool] = True
+    ) -> str:
         """Convert modelspec format to yaml format
 
         Args:
-            filename: File in modelspec format (Filename extension: .yaml )
+            filename: File in modelspec format (Filename extension: .yaml). If None, use :code:`f"{self.id}.yaml"`
             include_metadata: Contains contact information, citations, acknowledgements, pointers to sample data,
                               benchmark results, and environments in which the specified model was originally implemented
         Returns:
@@ -584,7 +586,7 @@ def _cls_generate_documentation(cls, format: str = MARKDOWN_FORMAT):
         allowed_fields = cls._parse_allowed_fields()
         allowed_children = cls._parse_allowed_children()
 
-        print(f" - {cls.__name__} ({definition})")
+        # print(f" - {cls.__name__} ({definition})")
 
         rst_url_format = "`%s <%s>`__"
 
@@ -693,7 +695,7 @@ def insert_links(text, format=MARKDOWN_FORMAT):
                 type_, can_be_eval_expr=True, can_be_dict=True
             )
             type_str = Base._type_to_str(type_)
-            print("    Allowed parameter: {} {}".format(f, (description, type_str)))
+            # print("    Allowed parameter: {} {}".format(f, (description, type_str)))
 
             if format == DICT_FORMAT:
                 doc_dict[name]["allowed_parameters"][f] = {}
@@ -750,7 +752,7 @@ def insert_links(text, format=MARKDOWN_FORMAT):
 
         for c, (description, type_) in allowed_children.items():
             type_str = Base._type_to_str(type_)
-            print("    Allowed child: {} {}".format(c, (description, type_str)))
+            # print("    Allowed child: {} {}".format(c, (description, type_str)))
 
             referencable = not Base._is_base_type(type_, can_be_dict=True)
 

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,7 +260,7 @@ 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:
@@ -242,26 +269,28 @@ def evaluate(expr, parameters={}, rng=None, array_format=FORMAT_NUMPY, verbose=F
                 else:
                     expr = int(expr)
             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 +299,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 +328,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 +337,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 +353,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)))