Merge pull request #1260 from compas-dev/rogue-customization

No more rogue customization

Author: tomvanmele

CHANGELOG.md

@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 * Added `compas.dtastructures.Network` as alias of `compas.datastructures.Graph`.
+* Added `compas.data.Data.name` and included it in serialisation in case `compas.data.Data._name is not None`.
 
 ### Changed
 
@@ -22,6 +23,14 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Removed `compas.datastructures.Network`.
 * Removed `compas.datastructures.Halfedge`.
 * Removed `compas.datastructures.Halfface`.
+* Removed `compas.data.Data.attributes`.
+* Removed `compas.data.Datastructure.attributes`.
+* Removed `attributes` from `compas.datastructures.Assembly.data`.
+* Removed `attributes` from `compas.datastructures.CellNetwork.data`.
+* Removed `attributes` from `compas.datastructures.Graph.data`.
+* Removed `attributes` from `compas.datastructures.Mesh.data`.
+* Removed `attributes` from `compas.datastructures.Tree.data`.
+* Removed `attributes` from `compas.datastructures.VolMesh.data`.
 
 ## [2.0.0-beta.2] 2024-01-12
 

src/compas/data/data.py

@@ -39,12 +39,6 @@ class Data(object):
 
     Attributes
     ----------
-    dtype : str, read-only
-        The type of the object in the form of a fully qualified module name and a class name, separated by a forward slash ("/").
-        For example: ``"compas.datastructures/Mesh"``.
-    data : dict
-        The representation of the object as a dictionary containing only built-in Python data types.
-        The structure of the dict is described by the data schema.
     guid : str, read-only
         The globally unique identifier of the object.
         The guid is generated with ``uuid.uuid4()``.
@@ -72,9 +66,9 @@ class Data(object):
 
     DATASCHEMA = {}
 
-    def __init__(self, name=None, **kwargs):
+    def __init__(self, name=None):
         self._guid = None
-        self.attributes = kwargs or {}
+        self._name = None
         if name:
             self.name = name
 
@@ -95,15 +89,15 @@ def __jsondump__(self, minimal=False):
             "dtype": self.dtype,
             "data": self.data,
         }
-        if self.attributes:
-            state["attrs"] = self.attributes
         if minimal:
             return state
+        if self._name is not None:
+            state["name"] = self._name
         state["guid"] = str(self.guid)
         return state
 
     @classmethod
-    def __jsonload__(cls, data, guid=None, attrs=None):
+    def __jsonload__(cls, data, guid=None, name=None):
         """Construct an object of this type from the provided data to support COMPAS JSON serialization.
 
         Parameters
@@ -112,8 +106,8 @@ def __jsonload__(cls, data, guid=None, attrs=None):
             The raw Python data representing the object.
         guid : str, optional
             The GUID of the object.
-        attrs : dict, optional
-            The additional attributes of the object.
+        name : str, optional
+            The name of the object.
 
         Returns
         -------
@@ -123,8 +117,8 @@ def __jsonload__(cls, data, guid=None, attrs=None):
         obj = cls.from_data(data)
         if guid is not None:
             obj._guid = UUID(guid)
-        if attrs is not None:
-            obj.attributes.update(attrs)
+        if name is not None:
+            obj.name = name
         return obj
 
     def __getstate__(self):
@@ -136,9 +130,8 @@ def __setstate__(self, state):
         self.__dict__.update(state["__dict__"])
         if "guid" in state:
             self._guid = UUID(state["guid"])
-        # could be that this is already taken care of by the first line
-        if "attrs" in state:
-            self.attributes.update(state["attrs"])
+        if "name" in state:
+            self.name = state["name"]
 
     @property
     def dtype(self):
@@ -170,11 +163,11 @@ def guid(self):
 
     @property
     def name(self):
-        return self.attributes.get("name") or self.__class__.__name__
+        return self._name or self.__class__.__name__
 
     @name.setter
     def name(self, name):
-        self.attributes["name"] = name
+        self._name = name
 
     @classmethod
     def from_data(cls, data):  # type: (dict) -> Data
@@ -303,7 +296,7 @@ def copy(self, cls=None):  # type: (...) -> D
         if not cls:
             cls = type(self)
         obj = cls.from_data(deepcopy(self.data))
-        obj.attributes = deepcopy(self.attributes)
+        obj.name = self.name
         return obj  # type: ignore
 
     def sha256(self, as_string=False):

src/compas/data/encoders.py

@@ -231,12 +231,12 @@ def object_hook(self, o):
 
         data = o["data"]
         guid = o.get("guid")
-        attrs = o.get("attrs")
+        name = o.get("name")
 
         # Kick-off from_data from a rebuilt Python dictionary instead of the C# data type
         if IDictionary and isinstance(o, IDictionary[str, object]):
             data = {key: data[key] for key in data.Keys}
 
-        obj = cls.__jsonload__(data, guid, attrs)
+        obj = cls.__jsonload__(data, guid=guid, name=name)
 
         return obj

src/compas/datastructures/assembly/assembly.py

@@ -17,8 +17,6 @@ class Assembly(Datastructure):
 
     Attributes
     ----------
-    attributes : dict[str, Any]
-        General attributes of the data structure that will be included in the data dict and serialization.
     graph : :class:`compas.datastructures.Graph`
         The graph that is used under the hood to store the parts and their connections.
 
@@ -33,16 +31,13 @@ class Assembly(Datastructure):
     DATASCHEMA = {
         "type": "object",
         "properties": {
-            "attributes": {"type": "object"},
             "graph": Graph.DATASCHEMA,
         },
         "required": ["graph"],
     }
 
-    def __init__(self, name=None, **kwargs):
-        super(Assembly, self).__init__()
-        self.attributes = {"name": name or "Assembly"}
-        self.attributes.update(kwargs)
+    def __init__(self, name=None):
+        super(Assembly, self).__init__(name=name)
         self.graph = Graph()
         self._parts = {}
 
@@ -57,30 +52,16 @@ def __str__(self):
     @property
     def data(self):
         return {
-            "attributes": self.attributes,
             "graph": self.graph.data,
         }
 
     @classmethod
     def from_data(cls, data):
         assembly = cls()
-        assembly.attributes.update(data["attributes"] or {})
         assembly.graph = Graph.from_data(data["graph"])
         assembly._parts = {part.guid: part.key for part in assembly.parts()}  # type: ignore
         return assembly
 
-    # ==========================================================================
-    # Properties
-    # ==========================================================================
-
-    @property
-    def name(self):
-        return self.attributes.get("name") or self.__class__.__name__
-
-    @name.setter
-    def name(self, value):
-        self.attributes["name"] = value
-
     # ==========================================================================
     # Constructors
     # ==========================================================================

src/compas/datastructures/cell_network/cell_network.py

@@ -2,7 +2,6 @@
 from __future__ import division
 from __future__ import print_function
 
-# from itertools import product
 from random import sample
 
 from compas.datastructures import Mesh
@@ -28,18 +27,13 @@
 from compas.geometry import normal_polygon
 from compas.geometry import normalize_vector
 from compas.geometry import volume_polyhedron
-
-# from compas.topology import face_adjacency
 from compas.geometry import add_vectors
 from compas.geometry import bestfit_plane
 from compas.geometry import project_point_plane
 from compas.geometry import scale_vector
 from compas.geometry import subtract_vectors
 from compas.geometry import bounding_box
 
-# from compas.geometry import transform_points
-
-# from compas.utilities import linspace
 from compas.utilities import pairwise
 
 from compas.tolerance import TOL
@@ -58,13 +52,11 @@ class CellNetwork(Datastructure):
         Default values for face attributes.
     default_cell_attributes: dict, optional
         Default values for cell attributes.
-    **kwargs : dict, optional
-        Additional attributes for the data structure itself.
+    name : str, optional
+        The name of the cell network.
 
     Attributes
     ----------
-    attributes : dict[str, Any]
-        General attributes of the data structure which will be included in the data representation.
     default_vertex_attributes : dict[str, Any]
         Default attributes of the vertices.
     default_edge_attributes: dict[str, Any]
@@ -100,6 +92,28 @@ class CellNetwork(Datastructure):
                 "patternProperties": {"^[0-9]+$": {"type": "object"}},
                 "additionalProperties": False,
             },
+            "edge": {
+                "type": "object",
+                "patternProperties": {
+                    "^[0-9]+$": {
+                        "type": "object",
+                        "patternProperties": {"^[0-9]+$": {"type": "object"}},
+                        "additionalProperties": False,
+                    }
+                },
+                "additionalProperties": False,
+            },
+            "face": {
+                "type": "object",
+                "patternProperties": {
+                    "^[0-9]+$": {
+                        "type": "array",
+                        "items": {"type": "integer", "minimum": 0},
+                        "minItems": 3,
+                    }
+                },
+                "additionalProperties": False,
+            },
             "cell": {
                 "type": "object",
                 "patternProperties": {
@@ -115,11 +129,6 @@ class CellNetwork(Datastructure):
                 },
                 "additionalProperties": False,
             },
-            "edge_data": {
-                "type": "object",
-                "patternProperties": {"^\\([0-9]+, [0-9]+\\)$": {"type": "object"}},
-                "additionalProperties": False,
-            },
             "face_data": {
                 "type": "object",
                 "patternProperties": {"^\\([0-9]+(, [0-9]+){3, }\\)$": {"type": "object"}},
@@ -140,8 +149,9 @@ class CellNetwork(Datastructure):
             "dfa",
             "dca",
             "vertex",
+            "edge",
+            "face",
             "cell",
-            "edge_data",
             "face_data",
             "cell_data",
             "max_vertex",
@@ -156,9 +166,9 @@ def __init__(
         default_edge_attributes=None,
         default_face_attributes=None,
         default_cell_attributes=None,
-        **kwargs
+        name=None,
     ):
-        super(Datastructure, self).__init__(**kwargs)
+        super(CellNetwork, self).__init__(name=name)
         self._max_vertex = -1
         self._max_face = -1
         self._max_cell = -1
@@ -220,7 +230,6 @@ def data(self):
             cell[c] = sorted(list(faces))
 
         return {
-            "attributes": self.attributes,
             "dva": self.default_vertex_attributes,
             "dea": self.default_edge_attributes,
             "dfa": self.default_face_attributes,
@@ -250,12 +259,10 @@ def from_data(cls, data):
             default_cell_attributes=dca,
         )
 
-        cell_network.attributes.update(data.get("attributes") or {})
-
-        vertex = data.get("vertex") or {}
-        edge = data.get("edge") or {}
-        face = data.get("face") or {}
-        cell = data.get("cell") or {}
+        vertex = data["vertex"] or {}
+        edge = data["edge"] or {}
+        face = data["face"] or {}
+        cell = data["cell"] or {}
 
         for key, attr in iter(vertex.items()):
             cell_network.add_vertex(key=key, attr_dict=attr)