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