Merge pull request #93 from CitrineInformatics/feature/rename-to-gemd

Rename `taurus` to `GEMD`

Author: maxhutch

.travis.yml

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

README.md

@@ -1,32 +1,32 @@
-# taurus
-Python binding for Citrine's nextgen data model (codename: taurus). 
+# GEMD-python 
+Python binding for Citrine's nextgen data model, GEMD. 
 
 This package provides a framework for storing information about the processes that create materials, the materials themselves, and measurements performed on those materials. 
 
 ## Usage
 
-To install `taurus`, you can simply:
+To install `gemd`, you can simply:
 ```
-$ pip install taurus-citrine
+$ pip install gemd
 ```
 
 Detailed documentation of the `GEMD` data model can be found in the [language-agnostic documentation](https://citrineinformatics.github.io/gemd-docs/).
-Documentation of this package can be found [here](https://citrineinformatics.github.io/taurus/).
+Documentation of this package can be found [here](https://citrineinformatics.github.io/gemd/).
 
 ## Developer instructions
 To download the repo and install requirements, run 
 
-```pip install git+https://github.com/CitrineInformatics/taurus.git```
+```pip install git+https://github.com/CitrineInformatics/gemd-python.git```
 
 Tests are run with `pytest`, and the `pytest-cov` package is used to assess test coverage. 
 In order to assess coverage locally, run `pytest` with the following arguments:
-* `--cov=taurus/` Assess coverage of all modules in the directory `taurus/` (required)
+* `--cov=gemd/` Assess coverage of all modules in the directory `gemd/` (required)
 * `--cov-report term-missing` Prints line numbers for lines that are not executed (optional)
 * `--cov-report term:skip-covered` Skips output for modules with full coverage (optional)
 * `--cov-report xml` Saves coverage report to `coverage.xml` (optional)
 * `--cov-fail-under=100` Throws an error if coverage is less than 100% (optional)
 
 The following command will run all tests, print line numbers for lines that are not executed, skip modules with full coverage, and fail if coverage is less than 100%:
-`python -m pytest --cov=taurus/ --cov-report term:skip-covered --cov-report term-missing --cov-fail-under=100`
+`python -m pytest --cov=gemd/ --cov-report term:skip-covered --cov-report term-missing --cov-fail-under=100`
 
 

docs/source/conf.py

@@ -12,13 +12,13 @@
 #
 import os
 import sys
-sys.path.insert(0, os.path.abspath('../../taurus'))
+sys.path.insert(0, os.path.abspath('../../gemd'))
 
 
 # -- Project information -----------------------------------------------------
 
-project = 'Taurus'
-copyright = '2019, Citrine Informatics'
+project = 'GEMD'
+copyright = '2020, Citrine Informatics'
 author = 'Citrine Informatics'
 
 # The full version, including alpha/beta/rc tags
@@ -40,7 +40,7 @@
 # build.
 #
 # See: https://github.com/sphinx-contrib/apidoc
-apidoc_module_dir = '../../taurus'
+apidoc_module_dir = '../../gemd'
 apidoc_output_dir = 'reference'
 apidoc_excluded_paths = ['tests']
 apidoc_separate_modules = True

docs/source/depth/serialization.rst

@@ -4,37 +4,37 @@
 Serialization (with Graphs!)
 ==============================
 
-Taurus objects link together to form graphs with directional edges.
-For example, a :class:`~taurus.entity.object.material_run.MaterialRun` links back to the :class:`~taurus.entity.object.process_run.ProcessRun` that produced it.
+GEMD objects link together to form graphs with directional edges.
+For example, a :class:`~gemd.entity.object.material_run.MaterialRun` links back to the :class:`~gemd.entity.object.process_run.ProcessRun` that produced it.
 Some of these links are bi-directional.
-For example, a :class:`~taurus.entity.object.process_run.ProcessRun` also links forward to the :class:`~taurus.entity.object.material_run.MaterialRun` that it produces, if there is one.
+For example, a :class:`~gemd.entity.object.process_run.ProcessRun` also links forward to the :class:`~gemd.entity.object.material_run.MaterialRun` that it produces, if there is one.
 Other links are uni-directional.
-For example, a :class:`~taurus.entity.object.material_run.MaterialRun` links to its :class:`~taurus.entity.object.material_spec.MaterialSpec` but that :class:`~taurus.entity.object.material_spec.MaterialSpec` doesn't link back.
+For example, a :class:`~gemd.entity.object.material_run.MaterialRun` links to its :class:`~gemd.entity.object.material_spec.MaterialSpec` but that :class:`~gemd.entity.object.material_spec.MaterialSpec` doesn't link back.
 Uni-directional links are typically used when the multiplicity of a relationship can be large.
 For example, a material may be referenced in thousands of ingredients.
 
-In taurus, bi-directional links are readable but only a single direction is writable.
-For example, a :class:`~taurus.entity.object.measurement_run.MeasurementRun` can set the :class:`~taurus.entity.object.material_run.MaterialRun` material that it was performed on,
-but a :class:`~taurus.entity.object.material_run.MaterialRun` cannot set the :class:`~taurus.entity.object.measurement_run.MeasurementRun`s it contains.
-Each time a :class:`~taurus.entity.object.measurement_run.MeasurementRun`'s ``material`` field is set,
-that :class:`~taurus.entity.object.material_run.MaterialRun` has the :class:`~taurus.entity.object.measurement_run.MeasurementRun` appended to its ``measurements`` field.
+In GEMD, bi-directional links are readable but only a single direction is writable.
+For example, a :class:`~gemd.entity.object.measurement_run.MeasurementRun` can set the :class:`~gemd.entity.object.material_run.MaterialRun` material that it was performed on,
+but a :class:`~gemd.entity.object.material_run.MaterialRun` cannot set the :class:`~gemd.entity.object.measurement_run.MeasurementRun`s it contains.
+Each time a :class:`~gemd.entity.object.measurement_run.MeasurementRun`'s ``material`` field is set,
+that :class:`~gemd.entity.object.material_run.MaterialRun` has the :class:`~gemd.entity.object.measurement_run.MeasurementRun` appended to its ``measurements`` field.
 
 This linking structure presents several challenges for serialization and deserialization:
 
 a. The graph cannot be traversed through uni-directional links in the wrong direction.
 b. Only the writeable side of bi-directional links can be persisted.
 c. Objects that are referenced by multiple objects must be deserialized to the same object.
 
-These challenges are addressed by a custom json serialization procedure and the special :class:`~taurus.entity.link_by_uid.LinkByUID` class.
+These challenges are addressed by a custom json serialization procedure and the special :class:`~gemd.entity.link_by_uid.LinkByUID` class.
 
 1. Each entity that doesn't already have at least one unique identifier is assigned a unique identifier so it can be referenced.
-2. The graph is flattened by traversing it while maintaining a seen list and replacing object references to other entities with :class:`~taurus.entity.link_by_uid.LinkByUID` objects, producing the set of entities that are reachable.
+2. The graph is flattened by traversing it while maintaining a seen list and replacing object references to other entities with :class:`~gemd.entity.link_by_uid.LinkByUID` objects, producing the set of entities that are reachable.
 3. The objects are sorted into a special "writable" order that ensures that link targets are created when deserializing.
 4. This sorted list of entities is assigned to the "context" field in the serialization output.
 5. The original object (which may contain multiple entities) is assigned to the "object" field in the serialization output.
-6. The serialization output is serialized with a special :class:`~json.JSONEncoder`, :class:`~taurus.json.taurus_encoder.TaurusEncoder`, that skips the soft side of links.
+6. The serialization output is serialized with a special :class:`~json.JSONEncoder`, :class:`~gemd.json.gemd_encoder.GEMDEncoder`, that skips the soft side of links.
 
-Here's an example of the serialized output for a :class:`~taurus.entity.object.material_spec.MaterialSpec` and :class:`~taurus.entity.object.process_spec.ProcessSpec`:
+Here's an example of the serialized output for a :class:`~gemd.entity.object.material_spec.MaterialSpec` and :class:`~gemd.entity.object.process_spec.ProcessSpec`:
 
 ::
 
@@ -81,10 +81,10 @@ Here's an example of the serialized output for a :class:`~taurus.entity.object.m
 The deserialization is a comparatively simple two-step process.
 First, the string or file is deserialized with python's builtin deserializer and a custom object hook.
 This hook does three things:
-it knows how to build taurus entities and other :class:`~taurus.entity.dict_serializable.DictSerializable` objects,
-it creates an index with the unique identifiers of the taurus entities that it has seen so far,
-and it replaces any :class:`~taurus.entity.link_by_uid.LinkByUID` that it encounters with objects from that index.
+it knows how to build GEMD entities and other :class:`~gemd.entity.dict_serializable.DictSerializable` objects,
+it creates an index with the unique identifiers of the gemd entities that it has seen so far,
+and it replaces any :class:`~gemd.entity.link_by_uid.LinkByUID` that it encounters with objects from that index.
 The only thing left to do is return the ``"object"`` item from the resulting dictionary.
 
-This strategy is implemented in the :class:`~taurus.json.taurus_json.TaurusJson` class
-and conveniently exposed in the :py:mod:`taurus.json` module, which provides the familiar `json` interface.
+This strategy is implemented in the :class:`~gemd.json.gemd_json.GEMDJson` class
+and conveniently exposed in the :py:mod:`gemd.json` module, which provides the familiar `json` interface.

docs/source/depth/unit_parsing.rst

@@ -4,11 +4,11 @@ Unit Parsing
 
 Unit parsing is performed using the Pint_ package.
 By default, Pint supports a larger set of units than the Citrine Platform.
-Therefore, we include a custom unit definition file in Taurus: `citrine_en.txt`_.
+Therefore, we include a custom unit definition file in GEMD: `citrine_en.txt`_.
 This file contains the most commonly used units and will grow over time.
 
-Requests for support of additional units can be made by opening an issue in the `taurus repository`_ on github.
+Requests for support of additional units can be made by opening an issue in the `GEMD repository`_ on github.
 
 .. _Pint: https://pint.readthedocs.io/en/0.9/
-.. _citrine_en.txt: https://github.com/CitrineInformatics/taurus/blob/master/taurus/units/citrine_en.txt
-.. _taurus repository: https://github.com/CitrineInformatics/taurus
+.. _citrine_en.txt: https://github.com/CitrineInformatics/gemd/blob/master/gemd/units/citrine_en.txt
+.. _GEMD repository: https://github.com/CitrineInformatics/gemd

docs/source/index.rst

@@ -1,13 +1,13 @@
-.. Taurus documentation master file, created by
+.. GEMD documentation master file, created by
    sphinx-quickstart on Thu Aug 22 14:40:14 2019.
    You can adapt this file completely to your liking, but it should at least
    contain the root `toctree` directive.
 
-Welcome to the Taurus Documentation!
+Welcome to the GEMD Documentation!
 ===================================================
 
-Taurus is the Python implementation of the Citrine data model, the full documentation of which
-can be found `here <https://citrineinformatics.github.io/taurus-documentation/>`_.
+GEMD is the Python implementation of the Citrine data model, the full documentation of which
+can be found `here <https://citrineinformatics.github.io/gemd-docs/>`_.
 
 To learn about the details of specific classes, please see the module index.
 

gemd/__init__.py

@@ -0,0 +1 @@
+"""Data concepts library."""

gemd/client/__init__.py

@@ -0,0 +1 @@
+"""gemd client."""

gemd/client/json_encoder.py

@@ -0,0 +1,53 @@
+# flake8: noqa
+"""Encoding and decoding gemd objects to/from json."""
+import deprecation
+import gemd
+from gemd.json import GEMDEncoder, GEMDJson
+
+
+@deprecation.deprecated(deprecated_in="0.6.0", removed_in="0.7.0",
+                        details="Use gemd.json.dumps instead")
+def dumps(obj, **kwargs):
+    return gemd.json.dumps(obj, **kwargs)
+
+
+@deprecation.deprecated(deprecated_in="0.6.0", removed_in="0.7.0",
+                        details="Use gemd.json.loads instead")
+def loads(json_str, **kwargs):
+    return gemd.json.loads(json_str, **kwargs)
+
+
+@deprecation.deprecated(deprecated_in="0.6.0", removed_in="0.7.0",
+                        details="Use gemd.json.load instead")
+def load(fp, **kwargs):
+    return gemd.json.load(fp, **kwargs)
+
+
+@deprecation.deprecated(deprecated_in="0.6.0", removed_in="0.7.0",
+                        details="Use gemd.json.dump instead")
+def dump(obj, fp, **kwargs):
+    return gemd.json.dump(obj, fp, **kwargs)
+
+
+@deprecation.deprecated(deprecated_in="0.6.0", removed_in="0.7.0",
+                        details="Use gemd.json.GEMDJson().raw_dumps instead")
+def raw_dumps(obj, **kwargs):
+    return GEMDJson().raw_dumps(obj, **kwargs)
+
+
+@deprecation.deprecated(deprecated_in="0.6.0", removed_in="0.7.0",
+                        details="Use gemd.json.GEMDJson().thin_dumps instead")
+def thin_dumps(obj, **kwargs):
+    return GEMDJson().thin_dumps(obj, **kwargs)
+
+
+@deprecation.deprecated(deprecated_in="0.6.0", removed_in="0.7.0",
+                        details="Use gemd.json.GEMDJson().raw_loads instead")
+def raw_loads(json_str, **kwargs):
+    return GEMDJson().raw_loads(json_str, **kwargs)
+
+
+@deprecation.deprecated(deprecated_in="0.6.0", removed_in="0.7.0",
+                        details="Use gemd.json.GEMDJson().copy instead")
+def copy(obj):
+    return GEMDJson().copy(obj)

gemd/demo/__init__.py

@@ -0,0 +1 @@
+"""Demonstration of the data concepts library."""