Merge pull request #39 from CitrineInformatics/release/0.2.0

Taurus v0.2.0 is released!

Author: maxhutch

.travis.yml

@@ -7,8 +7,8 @@ install:
 - pip install -U -r test_requirements.txt
 - pip install --no-deps -e .
 script:
-- pytest --flake8 --cov=taurus --cov-report term-missing --cov-report term:skip-covered
-  --cov-fail-under=91 -s -r ./taurus
+- pytest --flake8 --cov=taurus --cov-report term-missing --cov-report term:skip-covered --cov-config=tox.ini
+  --cov-fail-under=100 -s -r ./taurus
 - cd docs; make html; cd ..;
 - touch ./docs/_build/html/.nojekyll
 deploy:

README.md

@@ -2,7 +2,7 @@
 Python binding for Citrine's nextgen data concepts (codename: taurus). 
 
 
-Provides a framework for storing information about the processes that create materials, the materials themselves, and measurements performance on those materials. 
+Provides a framework for storing information about the processes that create materials, the materials themselves, and measurements performed on those materials. 
 Detailed documentation of the next gen format can be found in the language-agnostic documentation.
 
 ## Installation

setup.py

@@ -36,7 +36,7 @@ def run(self):
 
 
 setup(name='taurus-citrine',
-      version='0.1.0',
+      version='0.2.0',
       url='http://github.com/CitrineInformatics/taurus',
       description='Python library for the Citrine Platform',
       author='Max Hutchinson',

taurus/client/json_encoder.py

@@ -152,7 +152,7 @@ def thin_dumps(obj, **kwargs):
 
     """
     if not isinstance(obj, BaseEntity):
-        raise ValueError("Can only dump BaseEntities, but got {}".format(type(obj)))
+        raise TypeError("Can only dump BaseEntities, but got {}".format(type(obj)))
 
     set_uuids(obj)
     res = deepcopy(obj)
@@ -208,7 +208,7 @@ def _loado(d, index):
         obj = LinkByUID.from_dict(d)
         return obj
     else:
-        raise ValueError("Unexpected base object type: {}".format(typ))
+        raise TypeError("Unexpected base object type: {}".format(typ))
 
     if isinstance(obj, BaseEntity):
         for (scope, id) in obj.uids.items():

taurus/client/tests/test_json.py

@@ -1,16 +1,19 @@
 """Test serialization and deserialization of taurus objects."""
-from taurus.client.json_encoder import dumps, loads
+import json
+import pytest
+
+from taurus.client.json_encoder import dumps, loads, copy, thin_dumps
+from taurus.entity.dict_serializable import DictSerializable
 from taurus.entity.case_insensitive_dict import CaseInsensitiveDict
 from taurus.entity.attribute.condition import Condition
 from taurus.entity.attribute.parameter import Parameter
 from taurus.entity.link_by_uid import LinkByUID
-from taurus.entity.object import MeasurementRun, MaterialRun, ProcessRun
+from taurus.entity.object import MeasurementRun, MaterialRun, ProcessRun, MeasurementSpec
 from taurus.entity.object.ingredient_run import IngredientRun
 from taurus.entity.object.ingredient_spec import IngredientSpec
 from taurus.entity.value.nominal_real import NominalReal
 from taurus.entity.value.normal_real import NormalReal
-
-import json
+from taurus.enumeration.origin import Origin
 
 
 def test_serialize():
@@ -43,10 +46,33 @@ def test_deserialize():
     parameter = Parameter(name="A parameter", value=NormalReal(mean=17, std=1, units=''))
     measurement = MeasurementRun(tags="A tag on a measurement", conditions=condition,
                                  parameters=parameter)
-    copy = loads(dumps(measurement))
-    assert(copy.conditions[0].value == measurement.conditions[0].value)
-    assert(copy.parameters[0].value == measurement.parameters[0].value)
-    assert(copy.uids["auto"] == measurement.uids["auto"])
+    copy_meas = copy(measurement)
+    assert(copy_meas.conditions[0].value == measurement.conditions[0].value)
+    assert(copy_meas.parameters[0].value == measurement.parameters[0].value)
+    assert(copy_meas.uids["auto"] == measurement.uids["auto"])
+
+
+def test_enumeration_serde():
+    """An enumeration should get serialized as a string."""
+    condition = Condition(name="A condition", notes=Origin.UNKNOWN)
+    copy_condition = copy(condition)
+    assert copy_condition.notes == Origin.get_value(condition.notes)
+
+
+def test_thin_dumps():
+    """Test that thin_dumps turns pointers into links and doesn't work on non-BaseEntity."""
+    mat = MaterialRun("The actual material")
+    meas_spec = MeasurementSpec("measurement", uids={'my_scope': '324324'})
+    meas = MeasurementRun("The measurement", spec=meas_spec, material=mat)
+
+    thin_copy = MeasurementRun.build(json.loads(thin_dumps(meas)))
+    assert isinstance(thin_copy, MeasurementRun)
+    assert isinstance(thin_copy.material, LinkByUID)
+    assert isinstance(thin_copy.spec, LinkByUID)
+    assert thin_copy.spec.id == meas_spec.uids['my_scope']
+
+    with pytest.raises(TypeError):
+        thin_dumps(LinkByUID('scope', 'id'))
 
 
 def test_uid_deser():
@@ -59,6 +85,40 @@ def test_uid_deser():
     assert ingredient_copy.material.uids['sample id'] == material.uids['Sample ID']
 
 
+def test_dict_serialization():
+    """Test that a dictionary can be serialized and then deserialized as a taurus object."""
+    process = ProcessRun("A process")
+    mat = MaterialRun("A material", process=process)
+    meas = MeasurementRun("A measurement", material=mat)
+    copy = loads(dumps(meas.as_dict()))
+    assert copy == meas
+
+
+def test_unexpected_serialization():
+    """Trying to serialize an unexpected class should throw a TypeError."""
+    class DummyClass:
+        def __init__(self, foo):
+            self.foo = foo
+
+    with pytest.raises(TypeError):
+        dumps(ProcessRun("A process", notes=DummyClass("something")))
+
+
+def test_unexpected_deserialization():
+    """Trying to deserialize an unexpected class should throw a TypeError."""
+    class DummyClass(DictSerializable):
+        typ = 'dummy_class'
+
+        def __init__(self, foo):
+            self.foo = foo
+
+    # DummyClass can be serialized because it is a DictSerializable, but cannot be
+    # deserialized because it is not in the _clazzes list.
+    serialized = dumps(ProcessRun("A process", notes=DummyClass("something")))
+    with pytest.raises(TypeError):
+        loads(serialized)
+
+
 def test_case_insensitive_rehydration():
     """
 

taurus/demo/cake.py

@@ -1,7 +1,7 @@
 """Bake a cake."""
 import json
 
-from taurus.client.json_encoder import thin_dumps, dumps
+from taurus.client.json_encoder import thin_dumps
 from taurus.entity.attribute.condition import Condition
 from taurus.entity.attribute.parameter import Parameter
 from taurus.entity.attribute.property import Property
@@ -27,6 +27,7 @@
 from taurus.entity.value.normal_real import NormalReal
 from taurus.enumeration.origin import Origin
 from taurus.util.impl import set_uuids
+from taurus.entity.util import complete_material_history
 
 
 def make_cake():
@@ -228,6 +229,11 @@ def make_cake():
 
 if __name__ == "__main__":
     cake = make_cake()
+    set_uuids(cake)
+
+    with open("example_taurus_material_history.json", "w") as f:
+        context_list = complete_material_history(cake)
+        f.write(json.dumps(context_list, indent=2))
 
     with open("example_taurus_material_template.json", "w") as f:
         f.write(thin_dumps(cake.template, indent=2))
@@ -261,7 +267,3 @@ def make_cake():
 
     with open("example_taurus_measurement_run.json", "w") as f:
         f.write(thin_dumps(cake.measurements[0], indent=2))
-
-    with open("example_taurus_material_history.json", "w") as f:
-        context = json.loads(dumps(cake))[0]
-        f.write(json.dumps(context, indent=2))

taurus/entity/attribute/base_attribute.py

@@ -31,8 +31,6 @@ class BaseAttribute(DictSerializable):
 
     """
 
-    attribute_type = None
-
     def __init__(self, name=None, template=None, origin="unknown", value=None, notes=None,
                  file_links=None):
         if name is None:
@@ -62,7 +60,7 @@ def value(self, value):
         elif isinstance(value, (BaseValue, str, bool)):
             self._value = value
         else:
-            raise ValueError("value must be a BaseValue, string or bool")
+            raise TypeError("value must be a BaseValue, string or bool: {}".format(value))
 
     @property
     def template(self):
@@ -76,7 +74,8 @@ def template(self, template):
         elif isinstance(template, (LinkByUID, AttributeTemplate)):
             self._template = template
         else:
-            raise ValueError("template must be a BaseAttributeTemplate or LinkByUID")
+            raise TypeError("template must be a BaseAttributeTemplate or "
+                            "LinkByUID: {}".format(template))
 
     @property
     def origin(self):

taurus/entity/attribute/condition.py

@@ -1,5 +1,4 @@
 from taurus.entity.attribute.base_attribute import BaseAttribute
-from taurus.enumeration import AttributeType
 
 
 class Condition(BaseAttribute):
@@ -12,4 +11,3 @@ class Condition(BaseAttribute):
     """
 
     typ = "condition"
-    attribute_type = AttributeType.CONDITION

taurus/entity/attribute/metadata.py

@@ -1,5 +1,4 @@
 from taurus.entity.attribute.base_attribute import BaseAttribute
-from taurus.enumeration import AttributeType
 
 
 class Parameter(BaseAttribute):
@@ -13,4 +12,3 @@ class Parameter(BaseAttribute):
     """
 
     typ = "parameter"
-    attribute_type = AttributeType.PARAMETER

taurus/entity/attribute/parameter.py

@@ -1,5 +1,4 @@
 from taurus.entity.attribute.base_attribute import BaseAttribute
-from taurus.enumeration import AttributeType
 
 
 class Property(BaseAttribute):
@@ -12,4 +11,3 @@ class Property(BaseAttribute):
     """
 
     typ = "property"
-    attribute_type = AttributeType.PROPERTY

taurus/entity/attribute/property.py

@@ -68,4 +68,4 @@ def property(self, value):
         if isinstance(value, Property):
             self._property = value
         else:
-            raise ValueError("property must be a Property")
+            raise TypeError("property must be a Property")

taurus/entity/attribute/property_and_conditions.py

@@ -0,0 +1,18 @@
+"""Tests of the BaseAttribute class."""
+import pytest
+
+from taurus.entity.attribute.property import Property
+from taurus.entity.template.process_template import ProcessTemplate
+from taurus.entity.value.nominal_real import NominalReal
+
+
+def test_invalid_assignment():
+    """Test that invalid assignments throw the appropriate errors."""
+    with pytest.raises(ValueError):
+        Property(value=NominalReal(10, ''))
+    with pytest.raises(TypeError):
+        Property(name="property", value=10)
+    with pytest.raises(TypeError):
+        Property(name="property", template=ProcessTemplate("wrong kind of template"))
+    with pytest.raises(ValueError):
+        Property(name="property", origin=None)

taurus/entity/attribute/tests/test_base_attribute.py

@@ -0,0 +1,41 @@
+import pytest
+
+from taurus.entity.attribute.property_and_conditions import Property, Condition, \
+    PropertyAndConditions
+from taurus.entity.link_by_uid import LinkByUID
+from taurus.entity.template.property_template import PropertyTemplate
+from taurus.entity.template.condition_template import ConditionTemplate
+from taurus.entity.value.nominal_integer import NominalInteger
+from taurus.entity.value.nominal_categorical import NominalCategorical
+from taurus.entity.bounds.integer_bounds import IntegerBounds
+from taurus.entity.bounds.categorical_bounds import CategoricalBounds
+
+
+def test_fields_from_property():
+    """Test that several fields of the attribute are derived from the property."""
+    prop_template = PropertyTemplate(name="cookie eating template", bounds=IntegerBounds(0, 1000))
+    cond_template = ConditionTemplate(name="Hunger template",
+                                      bounds=CategoricalBounds(["hungry", "full", "peckish"]))
+    prop = Property(name="number of cookies eaten",
+                    template=prop_template,
+                    origin='measured',
+                    value=NominalInteger(27))
+    cond = Condition(name="hunger level",
+                     template=cond_template,
+                     origin='specified',
+                     value=NominalCategorical("hungry"))
+
+    prop_and_conds = PropertyAndConditions(property=prop, conditions=[cond])
+    assert prop_and_conds.name == prop.name
+    assert prop_and_conds.template == prop.template
+    assert prop_and_conds.origin == prop.origin
+    assert prop_and_conds.value == prop.value
+
+
+def test_invalid_assignment():
+    """Test that invalid assignment throws a TypeError."""
+    with pytest.raises(TypeError):
+        PropertyAndConditions(property=LinkByUID('id', 'a15'))
+    with pytest.raises(TypeError):
+        PropertyAndConditions(property=Property("property"),
+                              conditions=[Condition("condition"), LinkByUID('scope', 'id')])

taurus/entity/attribute/tests/test_property_and_conditions.py

@@ -29,10 +29,6 @@ def __init__(self, uids, tags):
         self._uids = None
         self.uids = uids
 
-    def content_hash(self):
-        """A hash of the object's content."""
-        return str(sorted(list(self.__dict__.items())))
-
     @property
     def tags(self):
         """Get the tags."""

taurus/entity/base_entity.py

@@ -93,19 +93,11 @@ def _convert_bounds(self, target_units):
             A tuple of the (lower_bound, upper_bound) in the target units.
 
         """
-        # if neither have units, then just return the bounds
-        if not self.default_units and not target_units:
-            return self.lower_bound, self.upper_bound
-        # if either have units but both don't, then we can't return anything
-        elif not self.default_units or not target_units:
+        try:
+            lower_bound = units.convert_units(
+                self.lower_bound, self.default_units, target_units)
+            upper_bound = units.convert_units(
+                self.upper_bound, self.default_units, target_units)
+            return lower_bound, upper_bound
+        except units.IncompatibleUnitsError:
             return None, None
-        # if both have units, then we can try to convert
-        else:
-            try:
-                lower_bound = units.convert_units(
-                    self.lower_bound, self.default_units, target_units)
-                upper_bound = units.convert_units(
-                    self.upper_bound, self.default_units, target_units)
-                return lower_bound, upper_bound
-            except units.IncompatibleUnitsError:
-                return None, None

taurus/entity/bounds/real_bounds.py

@@ -29,6 +29,7 @@ def test_contains():
     assert bounds.contains(CategoricalBounds(categories={"spam"}))
     assert not bounds.contains(CategoricalBounds(categories={"spam", "foo"}))
     assert not bounds.contains(RealBounds(0.0, 2.0, ''))
+    assert not bounds.contains(None)
     with pytest.raises(TypeError):
         bounds.contains({"spam", "eggs"})
 

taurus/entity/bounds/tests/test_categorical_bounds.py

@@ -29,6 +29,7 @@ def test_contains():
     assert bounds.contains(CompositionBounds(components={"spam"}))
     assert not bounds.contains(CompositionBounds(components={"foo"}))
     assert not bounds.contains(RealBounds(0.0, 2.0, ''))
+    assert not bounds.contains(None)
     with pytest.raises(TypeError):
         bounds.contains({"spam"})
 

taurus/entity/bounds/tests/test_composition_bounds.py

@@ -31,5 +31,6 @@ def test_contains():
     assert int_bounds.contains(IntegerBounds(0, 1))
     assert int_bounds.contains(IntegerBounds(1, 2))
     assert not int_bounds.contains(IntegerBounds(1, 3))
+    assert not int_bounds.contains(None)
     with pytest.raises(TypeError):
         int_bounds.contains([0, 1])