Merge pull request #115 from CitrineInformatics/bugfix/cake-errors

Bugfixes for cake demo

Author: kroenlein

gemd/demo/cake.py

@@ -222,7 +222,7 @@ def make_cake_templates():
     )
 
     for key in tmpl:
-        tmpl[key].add_uid(TEMPLATE_SCOPE, key)
+        tmpl[key].add_uid(TEMPLATE_SCOPE, key.lower().replace(' ', '-'))
     return tmpl
 
 
@@ -233,21 +233,30 @@ def make_cake_spec(tmpl=None):
     if tmpl is None:
         tmpl = make_cake_templates()
 
-    def _make_ingredient(material, **kwargs):
+    def _make_ingredient(*, material, process, **kwargs):
         """Convenience method to utilize material fields in creating an ingredient's arguments."""
         return IngredientSpec(
             name=material.name.lower(),
             tags=list(material.tags),
             material=material,
+            process=process,
+            uids={DEMO_SCOPE: "{}--{}".format(material.uids[DEMO_SCOPE],
+                                              process.uids[DEMO_SCOPE]
+                                              )},
             **kwargs
         )
 
-    def _make_material(material_name, process_tmpl_name, process_kwargs, **material_kwargs):
+    def _make_material(*, material_name, template, process_tmpl_name, process_kwargs,
+                       **material_kwargs):
         """Convenience method to reuse material name in creating a material's arguments."""
+        process_name = "{} {}".format(process_tmpl_name, material_name)
         return MaterialSpec(
             name=material_name,
+            uids={DEMO_SCOPE: material_name.lower().replace(' ', '-')},
+            template=template,
             process=ProcessSpec(
-                name="{} {}".format(process_tmpl_name, material_name),
+                name=process_name,
+                uids={DEMO_SCOPE: process_name.lower().replace(' ', '-')},
                 template=tmpl[process_tmpl_name],
                 **process_kwargs
             ),
@@ -624,6 +633,7 @@ def _make_material(material_name, process_tmpl_name, process_kwargs, **material_
     _make_ingredient(
         material=eggs,
         labels=['wet'],
+        process=wetmix.process,
         absolute_quantity=NominalReal(nominal=4, units='')
     )
 
@@ -741,25 +751,6 @@ def _make_material(material_name, process_tmpl_name, process_kwargs, **material_
         mass_fraction=NominalReal(nominal=0.6387, units='')  # 4 c @ 30 g/ 0.25 cups
     )
 
-    # Crawl tree and annotate with uids; only add ids if there's nothing there
-    def _make_fuzzer():
-        """Generate closure that knows if it's seen a given name."""
-        seen = set()
-
-        def _fuzz_func(obj):
-            """Add fuzz to name in ID as necessary."""
-            name = 'ing-' if isinstance(obj, IngredientSpec) else ''
-            name += obj.name
-            while name.lower() in seen:
-                name += '-again'
-            seen.add(name.lower())
-            return name
-
-        return _fuzz_func
-
-    _name_fuzz = _make_fuzzer()
-    recursive_foreach(cake, lambda obj: obj.uids or obj.add_uid(DEMO_SCOPE, _name_fuzz(obj)))
-
     return cake
 
 
@@ -770,6 +761,13 @@ def make_cake(seed=None, tmpl=None, cake_spec=None, toothpick_img=None):
 
     if seed is not None:
         random.seed(seed)
+    # Code to generate quasi-repeatable run annotations
+    # Note there are potential machine dependencies
+    md5 = hashlib.md5()
+    for x in random.getstate()[1]:
+        md5.update(struct.pack(">I", x))
+    run_key = md5.hexdigest()
+
     ######################################################################
     # Parent Objects
     if tmpl is None:
@@ -785,10 +783,13 @@ def make_cake(seed=None, tmpl=None, cake_spec=None, toothpick_img=None):
     drygoods = ['Acme', 'A1', 'Reliable', "Big Box"]
     cake.process.source = PerformedSource(performed_by=random.choice(operators),
                                           performed_date='2015-03-14')
-    # Replace Abstract/In General
-    queue = [cake]
-    while queue:
-        item = queue.pop(0)
+
+    def _randomize_object(item):
+        # Add in the randomized particular values
+        if not isinstance(item, (MaterialRun, ProcessRun, IngredientRun)):
+            return
+
+        item.add_uid(DEMO_SCOPE, '{}-{}'.format(item.spec.uids[DEMO_SCOPE], run_key))
         if item.spec.tags is not None:
             item.tags = list(item.spec.tags)
         if item.spec.notes:  # Neither None or empty string
@@ -800,17 +801,14 @@ def make_cake(seed=None, tmpl=None, cake_spec=None, toothpick_img=None):
                 else:
                     supplier = random.choice(drygoods)
                 item.name = "{} {}".format(supplier, item.spec.name)
-            queue.append(item.process)
-        elif isinstance(item, ProcessRun):
-            queue.extend(item.ingredients)
+        if isinstance(item, ProcessRun):
             if item.template.name == "Procuring":
                 item.source = PerformedSource(performed_by='hamilton',
                                               performed_date='2015-02-17')
                 item.name = "{} {}".format(item.template.name, item.output_material.name)
             else:
                 item.source = cake.process.source
-        elif isinstance(item, IngredientRun):
-            queue.append(item.material)
+        if isinstance(item, IngredientRun):
             fuzz = 0.95 + 0.1 * random.random()
             if item.spec.absolute_quantity is not None:
                 item.absolute_quantity = \
@@ -833,9 +831,7 @@ def make_cake(seed=None, tmpl=None, cake_spec=None, toothpick_img=None):
                     NormalReal(mean=fuzz * item.spec.number_fraction.nominal,
                                std=0.05 * item.spec.number_fraction.nominal,
                                units=item.spec.number_fraction.units)
-
-        else:
-            raise TypeError("Unexpected object in the queue")
+    recursive_foreach(cake, _randomize_object)
 
     frosting = \
         next(x.material for x in cake.process.ingredients if 'rosting' in x.name)
@@ -882,9 +878,14 @@ def _find_name(name, material):
                                         )
     sugar_content.spec = salt_content.spec
 
+    # Note that while specs are regenerated each make_cake invocation, they are all identical
     for msr in (cake_taste, cake_appearance, frosting_taste, frosting_sweetness,
                 baked_doneness, flour_content, salt_content, sugar_content):
-        msr.spec.add_uid(DEMO_SCOPE, msr.spec.name)
+        msr.spec.add_uid(DEMO_SCOPE, msr.spec.name.lower())
+        msr.add_uid(DEMO_SCOPE, '{}--{}-{}'.format(msr.spec.uids[DEMO_SCOPE],
+                                                   msr.material.spec.uids[DEMO_SCOPE],
+                                                   run_key
+                                                   ))
 
     ######################################################################
     # Let's add some attributes
@@ -1029,35 +1030,6 @@ def _find_name(name, material):
         origin="specified"
     ))
 
-    # Code to generate quasi-repeatable run annotations
-    # Note there are potential machine dependencies
-    md5 = hashlib.md5()
-    for x in random.getstate()[1]:
-        md5.update(struct.pack(">I", x))
-    run_key = md5.hexdigest()
-
-    # Crawl tree and annotate with uids; only add ids if there's nothing there
-    def _make_disambiguator():
-        """Generate a closure to post-annotate for disambiguation."""
-        count = dict()
-
-        def _disambiguator(name):
-            """Add a number to the name if you've seen it more than once."""
-            if name in count:
-                count[name] = count[name] + 1
-                return "{}-{}".format(name, count[name])
-            else:
-                count[name] = 1
-                return name
-
-        return _disambiguator
-
-    _disambig = _make_disambiguator()
-    recursive_foreach(
-        cake,
-        lambda obj: obj.uids or obj.add_uid(DEMO_SCOPE, _disambig(obj.name) + run_key)
-    )
-
     cake.notes = cake.notes + "; Très délicieux! 😀"
     cake.file_links = [FileLink(
         filename="Photo",

gemd/demo/tests/test_cake.py

@@ -9,30 +9,16 @@
 from gemd.entity.object.ingredient_run import IngredientRun
 from gemd.entity.file_link import FileLink
 
-from gemd.json import dumps, loads
+from gemd.json import dumps
 from gemd.demo.cake import make_cake_templates, make_cake_spec, make_cake, \
     import_toothpick_picture, change_scope
 from gemd.util import recursive_foreach
-from gemd.entity.util import complete_material_history
 
 
 def test_cake():
     """Create cake, serialize, deserialize."""
     cake = make_cake(seed=42)
 
-    def test_for_loss(obj):
-        assert(obj == loads(dumps(obj)))
-    recursive_foreach(cake, test_for_loss)
-
-    # And verify equality was working in the first place
-    cake2 = loads(dumps(cake))
-    cake2.name = "It's a trap!"
-    assert(cake2 != cake)
-    cake2.name = cake.name
-    assert(cake == cake2)
-    cake2.uids['new'] = "It's a trap!"
-    assert(cake2 != cake)
-
     # Check that all the objects show up
     tot_count = 0
 
@@ -41,79 +27,44 @@ def increment(dummy):
         tot_count += 1
 
     recursive_foreach(cake, increment)
-    assert tot_count == 133
-
-    # And make sure nothing was lost
-    tot_count = 0
-    recursive_foreach(loads(dumps(complete_material_history(cake))), increment)
-    assert tot_count == 133
+    assert tot_count == 139
 
     # Check that no UIDs collide
     uid_seen = dict()
 
-    def check_ids(obj):
+    def _check_ids(obj):
         nonlocal uid_seen
         for scope in obj.uids:
-            lbl = '{}::{}'.format(scope, obj.uids[scope])
+            lbl = '{}::{}'.format(scope, obj.uids[scope].lower())
             if lbl in uid_seen:
                 assert uid_seen[lbl] == id(obj), "'{}' seen twice".format(lbl)
             uid_seen[lbl] = id(obj)
-    recursive_foreach(cake, check_ids)
-
-    queue = [cake]
-    seen = set()
-    while queue:
-        obj = queue.pop()
-        if obj in seen:
-            continue
-
-        seen.add(obj)
+    recursive_foreach(cake, _check_ids)
 
+    # Check that all recursive and square links are structured correctly
+    def _check_crosslinks(obj):
         if isinstance(obj, MaterialSpec):
-            if obj.process is not None:
-                queue.append(obj.process)
-                assert obj.process.output_material == obj
+            assert obj.process.output_material == obj
         elif isinstance(obj, MaterialRun):
-            if obj.process is not None:
-                queue.append(obj.process)
-                assert obj.process.output_material == obj
-            if obj.measurements:
-                queue.extend(obj.measurements)
-                for msr in obj.measurements:
-                    assert msr.material == obj
-            if obj.spec is not None:
-                queue.append(obj.spec)
-                if obj.process is not None:
-                    assert obj.spec.process == obj.process.spec
+            assert obj.process.output_material == obj
+            for msr in obj.measurements:
+                assert msr.material == obj
+            assert obj.spec.process == obj.process.spec
         elif isinstance(obj, ProcessRun):
-            if obj.ingredients:
-                queue.extend(obj.ingredients)
-            if obj.output_material is not None:
-                queue.append(obj.output_material)
-                assert obj.output_material.process == obj
-                if obj.spec is not None:
-                    assert obj.spec.output_material == obj.output_material.spec
+            assert obj.output_material.process == obj
+            assert obj.spec.output_material == obj.output_material.spec
         elif isinstance(obj, ProcessSpec):
-            if obj.ingredients:
-                queue.extend(obj.ingredients)
-            if obj.output_material is not None:
-                queue.append(obj.output_material)
-                assert obj.output_material.process == obj
+            assert obj.output_material.process == obj
         elif isinstance(obj, MeasurementSpec):
             pass  # Doesn't link
         elif isinstance(obj, MeasurementRun):
-            if obj.spec:
-                queue.append(obj.spec)
+            assert obj in obj.material.measurements
         elif isinstance(obj, IngredientSpec):
-            if obj.material:
-                queue.append(obj.material)
+            assert obj in obj.process.ingredients
         elif isinstance(obj, IngredientRun):
-            if obj.spec:
-                queue.append(obj.spec)
-                if obj.material and isinstance(obj.material, MaterialRun):
-                    assert obj.spec.material == obj.material.spec
-            if obj.material:
-                queue.append(obj.material)
+            assert obj in obj.process.ingredients
+            assert obj.spec.material == obj.material.spec
+    recursive_foreach(cake, _check_crosslinks)
 
 
 def test_cake_sigs():

gemd/entity/value/nominal_integer.py

@@ -15,7 +15,20 @@ class NominalInteger(IntegerValue):
 
     typ = "nominal_integer"
 
-    def __init__(self, nominal=None):
-        assert isinstance(nominal, int), \
-            "nominal value must be an int"
+    def __init__(self, nominal):
+        self._nominal = None
         self.nominal = nominal
+
+    @property
+    def nominal(self) -> int:
+        """A proscribed integer value without uncertainty."""
+        return int(self._nominal)
+
+    @nominal.setter
+    def nominal(self, nominal: int) -> None:
+        """A proscribed integer value without uncertainty."""
+        # This check/cast is necessary to handle JSON serialization behavior under 3.6
+        if not isinstance(nominal, (int, float)) or int(nominal) != nominal:
+            raise TypeError("nominal must be an int; got an {}({})".format(type(nominal), nominal))
+
+        self._nominal = int(nominal)

gemd/entity/value/tests/test_nomial_integer.py

@@ -0,0 +1,13 @@
+"""Tests of the UniformInteger class."""
+import pytest
+
+from gemd.entity.value.nominal_integer import NominalInteger
+
+
+def test_bounds_are_integers():
+    """Value must be an integer."""
+    NominalInteger(5)
+    with pytest.raises(TypeError):
+        NominalInteger(5.7)
+    with pytest.raises(TypeError):
+        NominalInteger("five")

gemd/entity/value/tests/test_uniform_integer.py

@@ -8,13 +8,17 @@ def test_bounds_order():
     """Lower bound must be <= upper bound."""
     UniformInteger(3, 7)
     UniformInteger(12, 12)
-    with pytest.raises(AssertionError):
+    with pytest.raises(ValueError):
         UniformInteger(22, 18)
+    with pytest.raises(ValueError):
+        UniformInteger(3, 7).lower_bound = 10
+    with pytest.raises(ValueError):
+        UniformInteger(3, 7).upper_bound = 1
 
 
 def test_bounds_are_integers():
     """Lower bound and upper bound must be integers."""
-    with pytest.raises(AssertionError):
+    with pytest.raises(TypeError):
         UniformInteger(5.7, 10)
-    with pytest.raises(AssertionError):
+    with pytest.raises(TypeError):
         UniformInteger(1, "five")