Gemd

It's been a while since our last release, so we're happy to offer up the results of some spring cleaning. No big changes, but a good number of little ones tidying up the code base and hopefully making our partners lives easier.

Improvements
* We've substantially increased the number of type hints in our API. This should make many IDEs happier, and thus increase your happiness as well. (168)
* We've exposed `cached_isinstance` through our public API. Some of our downstream code was doing a large number of type checks, and so this just seemed like the right thing to do. (169)
* And we've added another unit to our materials-tuned units file. (167)

Fixes
* We've fixed a number of typographic errors in the code base (168, 165)
* We fixed a bug where an Iterable type check was behaving badly with strings. (166)

**Full Changelog**: https://github.com/CitrineInformatics/gemd-python/compare/v1.8.1...v1.9.0

This release has several quality-of-life improvements that make it drastically easier to build and validate large GEMD material histories using fewer keystrokes. Let us know what you think!

What’s New
* We've made creating objects simpler. Instead of creating each object individually, helper functions allow you to quickly create self-contained blocks of information. (160):
* A method to make a material node, containing a material run, its corresponding spec, and the corresponding process run and spec that created them.
* A method to use one input material node as an ingredient in an output material node.
* A method to add a Measurement to a MaterialRun.
* Methods to easily build and add Attributes and Values in a type-safe way.
* We've added support for instant data validation. Any added values are automatically checked against the bounds of the relevant template, allowing you to spot errors at the source. As a user, you can specify if the results of that check are ignored, raise a warning, or throw an exception. Note that instant checks are only performed against local templates. If the template is a LinkByUID, then validation can only be done upon ingestion. (161)
* We've added a convenience method for returning a full list of every object that a single object references. Given the complex way objects can reference each other, having a central way to ask about all the objects, templates and links that they depend will help in bookkeeping for database construction. (155)

Improvements
* We've made importing easier. We've dramatically increased the number of modules that expose GEMD objects and helper functions for import -- you can now import all defined objects as easily as `from gemd import *`. (159)
* We've added up to Python 3.10 to our Travis testing. (162)

**Full Changelog**: https://github.com/CitrineInformatics/gemd-python/compare/v1.4.1...v1.8.1

The only significant user-facing change in this release is the ability to substitute objects in place instead of duplicating your entire data structure. But most users should notice a substantial improvement in speed, particularly when doing object comparisons.

Improvements
* The equality comparison between Base Objects should now be much faster. While it still uses `__eq__` or `==`, internally it hands off to a function that can maintain context as it crawls the graph.
* The substitute_objects and substitute_links methods can now operate either by copying your structure (as before) or in place. This should make rehydrating objects a lot simpler.
* Following a lot of profiling, several functions that were doing introspection are now being cached, reducing the degree to which we relied on repeating expensive evaluations.

This release contains quality of life improvements for linking and indexing, as well as some minor fixes.

Improvements
* A `to_link` method was added to Base Entities (154). This offers similar functionality to the `LinkByUID.from_entity` method, but we expect this is a more intuitive interface and saves an import + typing. Plus it avoids the confusing situation where passing an object to a factory can mutate the object.
* We also modified the hashing and equality behavior of Link By UIDs so that they behave the same as tuples of scope and ID (154). Methods like `make_index` used the tuples instead of the object, and so this should unify those approaches.

Fixes
* `iterable` objects are now handled correctly by recursive_foreach (151)
* `allowed_names` and `allowed_labels` are now empty lists by default, in contrast to maintaining a distinction between empty lists and `None`. The [docs](https://citrineinformatics.github.io/gemd-docs/specification/object-templates/#process-template) were ambiguous about which behavior was intended and other implementations had the new behavior. (153)

What’s New
* GEMD objects now support a much more robust version of equality checks. `==` will now check if references within an object (e.g., `material_run.spec`) refer to the same things by making LinkByUIDs equal to objects that share their IDs. This check will also recursively crawl through ingredients and measurements, making it much easier to determine if a stored version of a material history contains the same information as a newer one. (150)
Improvements
* There were some minor performance improvements as well stemming from some updates that were missed in 142.

Improvements
* The `from_entity` method from `LinkByUID` now uses the keyword argument `scope`, with the positional keyword `name` now deprecated. This matches library behaviors elsewhere. Documentation of the method was improved while we were in there. (149)