Merge branch 'main' into fixes-assembly

Author: gonzalocasas

CHANGELOG.md

@@ -15,12 +15,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Added optional `path` parameter to `compas.rpc.Proxy` to allow for non-package calls.
 * Added Grasshopper component to call RPC functions.
 * Added `Mesh.to_lines` method and tests.
+* Added `Data.guid` to JSON serialization.
+* Added `Data.guid` to pickle state.
 * Added `Assembly.find_by_key` to locate parts by key.
 
 ### Changed
 
 * Set `jinja >= 3.0` to dev dependencies to fix docs build error.
 * Fixed removing of collections for `compas_plotters`.
+* Fixed bug in `compas.robots.Configuration`.
 * Rebuild part index after deserialization in `Assembly`.
 
 ### Removed

README.md

@@ -2,6 +2,8 @@
 
 ![build](https://github.com/compas-dev/compas/workflows/build/badge.svg)
 [![GitHub - License](https://img.shields.io/github/license/compas-dev/compas.svg)](https://github.com/compas-dev/compas)
+[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/compas)](https://anaconda.org/conda-forge/compas)
+[![pip downloads](https://img.shields.io/pypi/dm/compas)](https://pypi.python.org/project/COMPAS)
 [![PyPI - Python Version](https://img.shields.io/pypi/pyversions/COMPAS.svg)](https://pypi.python.org/project/COMPAS)
 [![PyPI - Latest Release](https://img.shields.io/pypi/v/COMPAS.svg)](https://pypi.python.org/project/COMPAS)
 [![Conda (channel only)](https://img.shields.io/conda/vn/conda-forge/compas)](https://anaconda.org/conda-forge/compas)

src/compas/data/data.py

@@ -6,6 +6,7 @@
 import json
 import hashlib
 from uuid import uuid4
+from uuid import UUID
 from copy import deepcopy
 
 import compas
@@ -113,12 +114,19 @@ def __init__(self, name=None):
 
     def __getstate__(self):
         """Return the object data for state serialization with older pickle protocols."""
-        return {"__dict__": self.__dict__, "dtype": self.dtype, "data": self.data}
+        return {
+            "__dict__": self.__dict__,
+            "dtype": self.dtype,
+            "data": self.data,
+            "guid": str(self.guid),
+        }
 
     def __setstate__(self, state):
         """Assign a deserialized state to the object data to support older pickle protocols."""
         self.__dict__.update(state["__dict__"])
         self.data = state["data"]
+        if "guid" in state:
+            self._guid = UUID(state['guid'])
 
     @property
     def DATASCHEMA(self):

src/compas/data/encoders.py

@@ -4,11 +4,12 @@
 
 import json
 import platform
+import uuid
 
 from compas.data.exceptions import DecoderError
 
 # We don't do this from `compas.IPY` to avoid circular imports
-if 'ironpython' == platform.python_implementation().lower():
+if "ironpython" == platform.python_implementation().lower():
     try:
         from System.Collections.Generic import IDictionary
     except:  # noqa: E722
@@ -40,7 +41,7 @@ def cls_from_dtype(dtype):
         If the module doesn't contain the specified data type.
 
     """
-    mod_name, attr_name = dtype.split('/')
+    mod_name, attr_name = dtype.split("/")
     module = __import__(mod_name, fromlist=[attr_name])
     return getattr(module, attr_name)
 
@@ -97,18 +98,19 @@ def default(self, o):
             The serialized object.
 
         """
-        if hasattr(o, 'to_data'):
+        if hasattr(o, "to_data"):
             value = o.to_data()
-            if hasattr(o, 'dtype'):
+            if hasattr(o, "dtype"):
                 dtype = o.dtype
             else:
-                dtype = '{}/{}'.format('.'.join(o.__class__.__module__.split('.')[:-1]), o.__class__.__name__)
-            return {
-                'dtype': dtype,
-                'value': value
-            }
+                dtype = "{}/{}".format(
+                    ".".join(o.__class__.__module__.split(".")[:-1]),
+                    o.__class__.__name__,
+                )
 
-        if hasattr(o, '__next__'):
+            return {"dtype": dtype, "value": value, "guid": str(o.guid)}
+
+        if hasattr(o, "__next__"):
             return list(o)
 
         try:
@@ -118,9 +120,22 @@ def default(self, o):
         else:
             if isinstance(o, np.ndarray):
                 return o.tolist()
-            if isinstance(o, (np.int_, np.intc, np.intp, np.int8,
-                              np.int16, np.int32, np.int64, np.uint8,
-                              np.uint16, np.uint32, np.uint64)):
+            if isinstance(
+                o,
+                (
+                    np.int_,
+                    np.intc,
+                    np.intp,
+                    np.int8,
+                    np.int16,
+                    np.int32,
+                    np.int64,
+                    np.uint8,
+                    np.uint16,
+                    np.uint32,
+                    np.uint64,
+                ),
+            ):
                 return int(o)
             if isinstance(o, (np.float_, np.float16, np.float32, np.float64)):
                 return float(o)
@@ -185,25 +200,39 @@ def object_hook(self, o):
             A (reconstructed), deserialized object.
 
         """
-        if 'dtype' not in o:
+        if "dtype" not in o:
             return o
 
         try:
-            cls = cls_from_dtype(o['dtype'])
+            cls = cls_from_dtype(o["dtype"])
 
         except ValueError:
-            raise DecoderError("The data type of the object should be in the following format: '{}/{}'".format(o.__class__.__module__, o.__class__.__name__))
+            raise DecoderError(
+                "The data type of the object should be in the following format: '{}/{}'".format(
+                    o.__class__.__module__, o.__class__.__name__
+                )
+            )
 
         except ImportError:
-            raise DecoderError("The module of the data type can't be found: {}.".format(o['dtype']))
+            raise DecoderError(
+                "The module of the data type can't be found: {}.".format(o["dtype"])
+            )
 
         except AttributeError:
-            raise DecoderError("The data type can't be found in the specified module: {}.".format(o['dtype']))
+            raise DecoderError(
+                "The data type can't be found in the specified module: {}.".format(
+                    o["dtype"]
+                )
+            )
 
-        obj_value = o['value']
+        obj_value = o["value"]
 
         # Kick-off from_data from a rebuilt Python dictionary instead of the C# data type
         if IDictionary and isinstance(o, IDictionary[str, object]):
             obj_value = {key: obj_value[key] for key in obj_value.Keys}
 
-        return cls.from_data(obj_value)
+        obj = cls.from_data(obj_value)
+        if "guid" in o:
+            obj._guid = uuid.UUID(o["guid"])
+
+        return obj

src/compas/robots/configuration.py

@@ -134,7 +134,9 @@ class Configuration(Data):
 
     """
 
-    def __init__(self, joint_values=None, joint_types=None, joint_names=None):
+    def __init__(self, joint_values=None, joint_types=None, joint_names=None, **kwargs):
+        super(Configuration, self).__init__(**kwargs)
+
         joint_values = FixedLengthList(joint_values or [])
         joint_types = FixedLengthList(joint_types or [])
         joint_names = FixedLengthList(joint_names or [], validator=joint_names_validator)

tests/compas/data/test_json.py

@@ -10,16 +10,21 @@
 
 
 def test_json_native():
-    before = [[], (), {}, '', 1, 1.0, True, None]
+    before = [[], (), {}, "", 1, 1.0, True, None]
     after = compas.json_loads(compas.json_dumps(before))
-    assert after == [[], [], {}, '', 1, 1.0, True, None]
+    assert after == [[], [], {}, "", 1, 1.0, True, None]
 
 
 if not compas.IPY:
     import numpy as np
 
     def test_json_numpy():
-        before = [np.array([1, 2, 3]), np.array([1.0, 2.0, 3.0]), np.float64(1.0), np.int32(1)]
+        before = [
+            np.array([1, 2, 3]),
+            np.array([1.0, 2.0, 3.0]),
+            np.float64(1.0),
+            np.int32(1),
+        ]
         after = compas.json_loads(compas.json_dumps(before))
         assert after == [[1, 2, 3], [1.0, 2.0, 3.0], 1.0, 1]
 
@@ -29,20 +34,23 @@ def test_json_primitive():
     after = compas.json_loads(compas.json_dumps(before))
     assert before.dtype == after.dtype
     assert all(a == b for a, b in zip(before, after))
+    assert before.guid == after.guid
 
 
 def test_json_shape():
     before = Box(Frame(Point(0, 0, 0), Vector(1, 0, 0), Vector(0, 1, 0)), 1, 1, 1)
     after = compas.json_loads(compas.json_dumps(before))
     assert before.dtype == after.dtype
     assert all(a == b for a, b in zip(before.vertices, after.vertices))
+    assert before.guid == after.guid
 
 
 def test_json_xform():
     before = Transformation.from_frame_to_frame(Frame.worldXY(), Frame.worldXY())
     after = compas.json_loads(compas.json_dumps(before))
     assert before.dtype == after.dtype
     assert all(a == b for a, b in zip(before, after))
+    assert before.guid == after.guid
 
 
 def test_json_network():
@@ -57,10 +65,13 @@ def test_json_network():
     assert all(after.has_node(node) for node in before.nodes())
     assert all(before.has_edge(*edge) for edge in after.edges())
     assert all(after.has_edge(*edge) for edge in before.edges())
+    assert before.guid == after.guid
 
 
 def test_json_mesh():
-    before = Mesh.from_vertices_and_faces([[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]], [[0, 1, 2, 3]])
+    before = Mesh.from_vertices_and_faces(
+        [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0]], [[0, 1, 2, 3]]
+    )
     after = compas.json_loads(compas.json_dumps(before))
     assert before.dtype == after.dtype
     assert before.attributes == after.attributes
@@ -70,13 +81,36 @@ def test_json_mesh():
     assert all(after.has_face(face) for face in before.faces())
     assert all(before.has_edge(edge) for edge in after.edges())
     assert all(after.has_edge(edge) for edge in before.edges())
-    assert all(before.face_vertices(a) == after.face_vertices(b) for a, b in zip(before.faces(), after.faces()))
+    assert all(
+        before.face_vertices(a) == after.face_vertices(b)
+        for a, b in zip(before.faces(), after.faces())
+    )
+    assert before.guid == after.guid
 
 
 def test_json_volmesh():
     before = VolMesh.from_vertices_and_cells(
-        [[0, 0, 0], [1, 0, 0], [1, 1, 0], [0, 1, 0], [0, 0, 1], [1, 0, 1], [1, 1, 1], [0, 1, 1]],
-        [[[0, 1, 5, 4], [1, 2, 5, 6], [2, 3, 7, 6], [3, 0, 4, 7], [4, 5, 6, 7], [0, 3, 2, 1]]])
+        [
+            [0, 0, 0],
+            [1, 0, 0],
+            [1, 1, 0],
+            [0, 1, 0],
+            [0, 0, 1],
+            [1, 0, 1],
+            [1, 1, 1],
+            [0, 1, 1],
+        ],
+        [
+            [
+                [0, 1, 5, 4],
+                [1, 2, 5, 6],
+                [2, 3, 7, 6],
+                [3, 0, 4, 7],
+                [4, 5, 6, 7],
+                [0, 3, 2, 1],
+            ]
+        ],
+    )
     after = compas.json_loads(compas.json_dumps(before))
     assert before.dtype == after.dtype
     assert before.attributes == after.attributes
@@ -88,12 +122,13 @@ def test_json_volmesh():
     # assert all(after.has_cell(cell) for cell in before.cells())
     # assert all(before.has_edge(edge) for edge in after.edges())
     # assert all(after.has_edge(edge) for edge in before.edges())
+    assert before.guid == after.guid
 
 
 def test_json_pretty():
     result = compas.json_dumps(dict(a=12, b=6565), pretty=True)
     # strip some spacing to make the test pass on ironpython
-    result = '\n'.join([line.strip() for line in result.split('\n')])
+    result = "\n".join([line.strip() for line in result.split("\n")])
     assert result == """{\n"a": 12,\n"b": 6565\n}"""
 
 

tests/compas/data/test_pickle.py

@@ -10,3 +10,4 @@ def test_pickling():
     assert all(a == b for a, b in zip(f1.xaxis, f2.xaxis))
     assert all(a == b for a, b in zip(f1.yaxis, f2.yaxis))
     assert all(a == b for a, b in zip(f1.zaxis, f2.zaxis))
+    assert f1.guid == f2.guid