Merge pull request #43 from simulate-digital-rail/json-import

add basic from_json() implementation to topology

Author: dfriedenberger

poetry.lock

@@ -1,14 +1,15 @@
 [tool.poetry]
 name = "yaramo"
-version = "0.1.1"
+version = "0.2"
 description = "yaramo is a railway model focusing on interoperability between different existing planning formats."
 authors = ["OSM at HPI <arne.boockmeyer@hpi.de>"]
 readme = "README.md"
 packages = [{include = "yaramo"}]
 
 [tool.poetry.dependencies]
-python = "^3.8"
-pyproj = "^3.4.1"
+python = "^3.9"
+pyproj = "^3.6.1"
+simplejson = "^3.19.2"
 
 
 [tool.poetry.group.dev.dependencies]

pyproject.toml

@@ -23,3 +23,22 @@ def _test_edge(_node_a, _node_b, _expected_edge):
     _test_edge(node_a, node_b, edge)
     _test_edge(node_b, node_a, edge)
     _test_edge(node_a, node_c, None)
+
+
+def test_json_export_and_import():
+    topology = Topology()
+
+    node_a = Node()
+    node_b = Node()
+    topology.add_node(node_a)
+    topology.add_node(node_b)
+    edge = Edge(node_a, node_b)
+    topology.add_edge(edge)
+
+    json_str = topology.to_json()
+    topology_copy = Topology.from_json(json_str)
+
+    assert len(topology.nodes) == len(topology_copy.nodes)
+    assert len(topology.edges) == len(topology_copy.edges)
+    assert len(topology.signals) == len(topology_copy.signals)
+    assert len(topology.routes) == len(topology_copy.routes)

test/topology_test.py

@@ -1,7 +1,8 @@
-import json
 from typing import Tuple
 from uuid import uuid4
 
+import simplejson as json
+
 
 class BaseElement(object):
     def __init__(self, uuid: str = None, name: str = None, **kwargs) -> None:
@@ -26,4 +27,4 @@ def to_serializable(self) -> Tuple[dict, dict]:
         return self.__dict__, {}
 
     def to_json(self) -> str:
-        return json.dumps(self.to_serializable()[0])
+        return json.dumps(self.to_serializable()[0], iterable_as_array=True)

yaramo/base_element.py

@@ -21,6 +21,9 @@ def __init__(
         node_b: Node,
         vacancy_section: Optional[VacancySection] = None,
         length: float = None,
+        intermediate_geo_nodes: List[GeoNode] = None,
+        signals: list["Signal"] = None,
+        maximum_speed: int = None,
         **kwargs
     ):
         """
@@ -37,12 +40,12 @@ def __init__(
         """
 
         super().__init__(**kwargs)
+        self.intermediate_geo_nodes = intermediate_geo_nodes or []
         self.node_a = node_a
         self.node_b = node_b
-        self.intermediate_geo_nodes: list[GeoNode] = []
-        self.signals: list[Signal] = []
+        self.signals = signals or []
         self.length = length
-        self.maximum_speed: int = None
+        self.maximum_speed = maximum_speed
         self.vacancy_section = vacancy_section
 
     def is_node_connected(self, other_node) -> bool:
@@ -143,7 +146,7 @@ def to_serializable(self):
             "intermediate_geo_nodes": [geo_node.uuid for geo_node in self.intermediate_geo_nodes],
             "signals": [signal.uuid for signal in self.signals],
         }
-        objects = {}
+        objects = dict()
         for geo_node in self.intermediate_geo_nodes:
             geo_node_object, serialized_geo_node = geo_node.to_serializable()
             objects = {**objects, geo_node.uuid: geo_node_object, **serialized_geo_node}

yaramo/edge.py

@@ -42,7 +42,7 @@ def get_distance_to_other_geo_point(self, geo_point_b: "Wgs84GeoPoint"):
         return self.__haversine_distance(geo_point_b) / 1000
 
     def __haversine_distance(self, geo_point_b: "GeoPoint"):
-        pi_over_180 = Decimal(math.pi / 180)
+        pi_over_180 = float(math.pi / 180)
         return (
             2
             * 6371000

yaramo/geo_point.py

@@ -37,7 +37,7 @@ def __init__(self, turnout_side=None, **kwargs):
         self.maximum_speed_on_left = None
         self.maximum_speed_on_right = None
         self.connected_nodes: list["Node"] = []
-        self.geo_node: GeoNode = None
+        self.geo_node: GeoNode = kwargs.get("geo_node", None)
         self.turnout_side: str = turnout_side
 
     def maximum_speed(self, node_a: "Node", node_b: "Node"):
@@ -182,7 +182,7 @@ def to_serializable(self):
             "connected_nodes": [node.uuid for node in self.connected_nodes],
             "geo_node": self.geo_node.uuid if self.geo_node else None,
         }
-        objects = {}
+        objects = dict()
         if self.geo_node:
             geo_node, serialized_geo_node = self.geo_node.to_serializable()
             objects = {**objects, self.geo_node.uuid: geo_node, **serialized_geo_node}

yaramo/node.py

@@ -142,12 +142,13 @@ def to_serializable(self) -> Tuple[dict, dict]:
             "edge": self.edge.uuid if self.edge else None,
             "trip": self.trip.uuid if self.trip else None,
             "additional_signals": [signal.uuid for signal in self.additional_signals],
+            "supported_states": [str(state) for state in self.supported_states],
             "direction": str(self.direction),
             "side_distance": self.side_distance,
             "function": str(self.function),
             "kind": str(self.kind),
         }
-        objects = {}
+        objects = dict()
         items = [self.trip] + self.additional_signals if self.trip else self.additional_signals
         for item in items:
             item_object, serialized_item = item.to_serializable()

yaramo/signal.py

@@ -1,5 +1,8 @@
+import simplejson as json
+
 from yaramo.base_element import BaseElement
 from yaramo.edge import Edge
+from yaramo.geo_node import Wgs84GeoNode
 from yaramo.node import Node
 from yaramo.route import Route
 from yaramo.signal import Signal
@@ -54,7 +57,7 @@ def to_serializable(self):
             A serializable dictionary of all the objects belonging to the Topology.
         """
         nodes, edges, signals, routes, vacancy_sections = [], [], [], [], []
-        objects = {}
+        objects = dict()
 
         for items, _list in [
             (list(self.signals.values()), signals),
@@ -76,3 +79,57 @@ def to_serializable(self):
             "objects": objects,
             "vacany_sections": vacancy_sections,
         }, {}
+
+    @classmethod
+    def from_json(cls, json_str: str):
+        obj = json.loads(json_str)
+        topology = cls()
+        for node in obj["nodes"]:
+            node_obj = Node(**node)
+            topology.add_node(node_obj)
+            if "geo_node" in node and node["geo_node"] is not None:
+                geo_node = obj["objects"][node["geo_node"]]
+                geo_node_obj = Wgs84GeoNode(
+                    obj["objects"][geo_node["geo_point"]]["x"],
+                    obj["objects"][geo_node["geo_point"]]["y"],
+                    name=geo_node["name"],
+                    uuid=geo_node["uuid"],
+                )
+                node_obj.geo_node = geo_node_obj
+
+        for signal in obj["signals"]:
+            topology.add_signal(Signal(**signal))
+        for edge in obj["edges"]:
+            node_a = topology.nodes[edge["node_a"]]
+            node_b = topology.nodes[edge["node_b"]]
+            node_a.connected_nodes.append(node_b)
+            node_b.connected_nodes.append(node_a)
+            geo_node_strings = [
+                obj["objects"][geo_node_uuid]
+                for geo_node_uuid in edge["intermediate_geo_nodes"]
+                if geo_node_uuid in obj["objects"]
+            ]
+            topology.add_edge(
+                Edge(
+                    **{
+                        **edge,
+                        "node_a": node_a,
+                        "node_b": node_b,
+                        "signals": [
+                            topology.signals[signal_uuid] for signal_uuid in edge["signals"]
+                        ],
+                        "intermediate_geo_nodes": [
+                            Wgs84GeoNode(
+                                obj["objects"][geo_node["geo_point"]]["x"],
+                                obj["objects"][geo_node["geo_point"]]["y"],
+                                name=geo_node["name"],
+                                uuid=geo_node["uuid"],
+                            )
+                            for geo_node in geo_node_strings
+                        ],
+                    }
+                )
+            )
+        for signal in obj["signals"]:
+            topology.signals[signal["uuid"]].edge = topology.edges[signal["edge"]]
+        return topology