only name attribute for most objects

Author: tomvanmele

src/compas/data/data.py

@@ -72,9 +72,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 +95,14 @@ def __jsondump__(self, minimal=False):
             "dtype": self.dtype,
             "data": self.data,
         }
-        if self.attributes:
-            state["attrs"] = self.attributes
         if minimal:
             return state
+        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 +111,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 +122,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 +135,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 +168,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 +301,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, name)
 
         return obj

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
@@ -91,6 +85,7 @@ class CellNetwork(Datastructure):
     DATASCHEMA = {
         "type": "object",
         "properties": {
+            "attributes": {"type": "object"},
             "dva": {"type": "object"},
             "dea": {"type": "object"},
             "dfa": {"type": "object"},
@@ -100,6 +95,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 +132,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 +152,9 @@ class CellNetwork(Datastructure):
             "dfa",
             "dca",
             "vertex",
+            "edge",
+            "face",
             "cell",
-            "edge_data",
             "face_data",
             "cell_data",
             "max_vertex",
@@ -158,7 +171,7 @@ def __init__(
         default_cell_attributes=None,
         **kwargs
     ):
-        super(Datastructure, self).__init__(**kwargs)
+        super(CellNetwork, self).__init__(**kwargs)
         self._max_vertex = -1
         self._max_face = -1
         self._max_cell = -1
@@ -243,19 +256,20 @@ def from_data(cls, data):
         dfa = data.get("dfa") or {}
         dca = data.get("dca") or {}
 
+        attributes = data.get("attributes") or {}
+
         cell_network = cls(
             default_vertex_attributes=dva,
             default_edge_attributes=dea,
             default_face_attributes=dfa,
             default_cell_attributes=dca,
+            **attributes
         )
 
-        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)

src/compas/datastructures/datastructure.py

@@ -8,6 +8,10 @@
 class Datastructure(Data):
     """Base class for all data structures."""
 
+    def __init__(self, **kwargs):
+        super(Datastructure, self).__init__(**kwargs)
+        self.attributes = kwargs
+
     def transform(self, transformation):
         """Transforms the data structure.
 

src/compas/datastructures/graph/graph.py

@@ -58,10 +58,12 @@ class Graph(Datastructure):
     default_edge_attributes: dict, optional
         Default values for edge attributes.
     **kwargs : dict, optional
-        Additional attributes to add to the graph.
+        Additional attributes.
 
     Attributes
     ----------
+    attributes : dict[str, Any]
+        General attributes of the data structure which will be included in the data representation.
     default_node_attributes : dict[str, Any]
         dictionary containing default values for the attributes of nodes.
         It is recommended to add a default to this dictionary using :meth:`update_default_node_attributes`
@@ -76,6 +78,7 @@ class Graph(Datastructure):
     DATASCHEMA = {
         "type": "object",
         "properties": {
+            "attributes": {"type": "object"},
             "dna": {"type": "object"},
             "dea": {"type": "object"},
             "node": {
@@ -138,6 +141,7 @@ def __str__(self):
     @property
     def data(self):
         data = {
+            "attributes": self.attributes,
             "dna": self.default_node_attributes,
             "dea": self.default_edge_attributes,
             "node": {},
@@ -158,10 +162,12 @@ def data(self):
     def from_data(cls, data):
         dna = data.get("dna") or {}
         dea = data.get("dea") or {}
-        node = data.get("node") or {}
-        edge = data.get("edge") or {}
+        attributes = data.get("attributes") or {}
 
-        graph = cls(default_node_attributes=dna, default_edge_attributes=dea)
+        node = data["node"] or {}
+        edge = data["edge"] or {}
+
+        graph = cls(default_node_attributes=dna, default_edge_attributes=dea, **attributes)
 
         for node, attr in iter(node.items()):
             node = literal_eval(node)
@@ -227,6 +233,7 @@ def from_networkx(cls, graph):
 
         """
         g = cls()
+        g.name = graph.graph.get("name")
         g.attributes.update(graph.graph)
 
         for node in graph.nodes():
@@ -473,6 +480,7 @@ def to_networkx(self):
         import networkx as nx
 
         G = nx.DiGraph()
+        G.graph["name"] = self.name  # type: ignore
         G.graph.update(self.attributes)  # type: ignore
 
         for node, attr in self.nodes(data=True):

src/compas/datastructures/mesh/mesh.py

@@ -91,12 +91,12 @@ class Mesh(Datastructure):
     default_face_attributes: dict[str, Any], optional
         Default values for face attributes.
     **kwargs : dict, optional
-        Additional attributes to add to the mesh object.
+        Additional attributes to add to the mesh.
 
     Attributes
     ----------
     attributes : dict[str, Any]
-        General attributes of the data structure that are included in the data representation and serialization.
+        General attributes of the data structure which will be included in the data representation.
     default_vertex_attributes : dict[str, Any]
         Dictionary containing default values for the attributes of vertices.
         It is recommended to add a default to this dictionary using :meth:`update_default_vertex_attributes`
@@ -125,6 +125,7 @@ class Mesh(Datastructure):
     DATASCHEMA = {
         "type": "object",
         "properties": {
+            "attributes": {"type": "object"},
             "dva": {"type": "object"},
             "dea": {"type": "object"},
             "dfa": {"type": "object"},
@@ -218,6 +219,7 @@ def __str__(self):
     @property
     def data(self):
         return {
+            "attributes": self.attributes,
             "dva": self.default_vertex_attributes,
             "dea": self.default_edge_attributes,
             "dfa": self.default_face_attributes,
@@ -234,11 +236,13 @@ def from_data(cls, data):
         dva = data.get("dva") or {}
         dfa = data.get("dfa") or {}
         dea = data.get("dea") or {}
+        attributes = data.get("attributes") or {}
 
-        halfedge = cls(default_vertex_attributes=dva, default_face_attributes=dfa, default_edge_attributes=dea)
+        halfedge = cls(default_vertex_attributes=dva, default_face_attributes=dfa, default_edge_attributes=dea, **attributes)
+
+        vertex = data["vertex"] or {}
+        face = data["face"] or {}
 
-        vertex = data.get("vertex") or {}
-        face = data.get("face") or {}
         facedata = data.get("facedata") or {}
         edgedata = data.get("edgedata") or {}
 

src/compas/datastructures/tree/tree.py

@@ -49,6 +49,7 @@ class TreeNode(Data):
 
     def __init__(self, **kwargs):
         super(TreeNode, self).__init__(**kwargs)
+        self.attributes = kwargs
         self._parent = None
         self._children = []
         self._tree = None
@@ -86,11 +87,6 @@ def tree(self):
     @property
     def data(self):
         return {
-            # this duplicates the behaviour of the Data class
-            # but it is necessary to make the tree serializable
-            # however, it only duplicates the attributes if the node is serialized independently
-            # perhaps this should not be possible
-            # in this sense, the node is a prototype of an independen graph node, or mesh vertex
             "attributes": self.attributes,
             "children": [child.data for child in self.children],
         }