move export/import dependencies to one place

Author: JFoederer

atest/resources/helpers/modelgenerator.py

@@ -61,8 +61,8 @@ def check_requirements(self) -> bool:
         return visualisation_deps_present
 
     @keyword(name='Generate Trace Information')  # type:ignore
-    def generate_trace_information(self) -> TraceInfo:
-        return TraceInfo()
+    def generate_trace_information(self, suite_name) -> TraceInfo:
+        return TraceInfo(suite_name)
 
     @keyword(name='The Algorithm Inserts')  # type:ignore
     def insert_trace_info(self, trace_info: TraceInfo, scenario_name: str, state_str: str | None = None) -> TraceInfo:
@@ -103,13 +103,13 @@ def generate_networkgraph(self, graph: AbstractGraph) -> NetworkVisualiser:
         return NetworkVisualiser(graph=graph, suite_name="")
 
     @keyword(name='Export Graph')  # type:ignore
-    def export_graph(self, suite: str, trace_info: TraceInfo) -> str:
-        return trace_info.export_graph(suite, atest=True)
+    def export_graph(self, trace_info: TraceInfo) -> str:
+        return trace_info.export_graph(atest=True)
 
     @keyword(name='Import Graph')  # type:ignore
     def import_graph(self, filepath: str) -> TraceInfo:
         suiteprocessor = SuiteProcessors()
-        suiteprocessor._load_graph('scenario', 'atest', filepath)
+        suiteprocessor._load_graph('scenario', filepath)
         return suiteprocessor.visualiser.trace_info
 
     @keyword(name='Check File Exists')  # type:ignore

atest/resources/visualisation.resource

@@ -18,7 +18,7 @@ test suite ${suite} has trace info ${trace}
     ...     :IN: new trace_info | trace_info.current_trace=0 | trace_info.all_traces=0 | 
     ...     trace_info.name = ${trace} | new graph
     ...     :OUT: None
-    ${trace_info} =     Generate Trace Information
+    ${trace_info} =     Generate Trace Information    ${suite}
     Set Suite Variable  ${trace_info}
 
 trace info ${trace}
@@ -184,7 +184,7 @@ test suite ${suite} is exported to json
     Variable Should Exist   ${suite}
     Variable Should Exist   ${trace_info}
 
-    ${filepath} =   Export Graph      ${suite}    ${trace_info}
+    ${filepath} =   Export Graph    ${trace_info}
     Set Suite Variable  ${filepath}
 
 the file ${filename} exists

robotmbt/suiteprocessors.py

@@ -44,7 +44,6 @@
 try:
     from .visualise.visualiser import Visualiser
     from .visualise.models import TraceInfo
-    import jsonpickle
     visualisation_deps_present = True
 except ImportError:
     Visualiser = None
@@ -94,7 +93,7 @@ def process_test_suite(self, in_suite: Suite, *, seed: str | int | bytes | bytea
         self.flat_suite = self.flatten(in_suite)
 
         if import_graph_data != '':
-            self._load_graph(graph, in_suite.name, import_graph_data)
+            self._load_graph(graph, import_graph_data)
 
         else:
             self._run_test_suite(seed, graph, in_suite.name, export_graph_data)
@@ -103,16 +102,15 @@ def process_test_suite(self, in_suite: Suite, *, seed: str | int | bytes | bytea
 
         return self.out_suite
 
-    def _load_graph(self, graph: str, suite_name: str, file_path: str):
+    def _load_graph(self, graph: str, file_path: str):
         """
         Imports a JSON encoding of a graph and reconstructs the graph from it. The reconstructed graph overrides the
         current graph instance this method is called on.
-        file_path: the relative path to the graph JSON.
+        file_path: the path to a previously exported graph.
         """
-        with open(file_path, "r") as f:
-            string = f.read()
-            traceinfo = jsonpickle.decode(string)
-        self.visualiser = Visualiser(graph, suite_name, trace_info=traceinfo)
+        if Visualiser:
+            self.visualiser = Visualiser(graph)
+            self.visualiser.load_from_file(file_path)
 
     def _run_test_suite(self, seed: str | int | bytes | bytearray, graph: str, suite_name: str, export_dir: str):
         for id, scenario in enumerate(self.flat_suite.scenarios, start=1):
@@ -251,7 +249,7 @@ def _report_tracestate_wrapup(tracestate: TraceState):
             logger.debug(f"model\n{progression.model.get_status_text()}\n")
 
     @staticmethod
-    def _init_randomiser(seed: str | int | bytes | bytearray):
+    def _init_randomiser(seed: str | int | bytes | bytearray | None):
         if isinstance(seed, str):
             seed = seed.strip()
         if str(seed).lower() == 'none':

robotmbt/visualise/models.py

@@ -195,8 +195,11 @@ class TraceInfo:
     - all_traces: all valid traces encountered in trace exploration, up until the point they could not go any further
     - previous_length: used to identify backtracking
     """
+    ROBOTMBT_MODEL_VERSION = '1.0.0'
 
-    def __init__(self):
+    def __init__(self, name: str = ''):
+        self.ROBOTMBT_MODEL_VERSION: str = TraceInfo.ROBOTMBT_MODEL_VERSION
+        self.model_name: str = name
         self.current_trace: list[tuple[ScenarioInfo, StateInfo]] = []
         self.all_traces: list[list[tuple[ScenarioInfo, StateInfo]]] = []
         self.previous_length: int = 0
@@ -256,14 +259,14 @@ def _sanity_check(self, scen: ScenarioInfo, state: StateInfo, after: str):
             logger.warn(
                 f'TraceInfo got out of sync after {after}\nExpected state: {prev_state}\nActual state: {state}')
 
-    def export_graph(self, suite_name: str, dir: str = '', atest: bool = False) -> str | None:
+    def export_graph(self, dir: str = '', atest: bool = False) -> str | None:
         encoded_instance = jsonpickle.encode(self)
-        name = suite_name.lower().replace(' ', '_')
+        name = self.model_name.lower().replace(' ', '_')
         if atest:
             '''
             temporary file to not accidentally overwrite an existing file
             mkstemp() is not ideal but given Python's limitations this is the easiest solution
-            as temporary file, a different method, is problematic on Windows 
+            as temporary file, a different method, is problematic on Windows
             https://stackoverflow.com/a/57015383
             '''
             fd, dir = tempfile.mkstemp()
@@ -282,6 +285,22 @@ def export_graph(self, suite_name: str, dir: str = '', atest: bool = False) -> s
             f.write(encoded_instance)
         return None
 
+    @staticmethod
+    def import_graph_from_file(file_path: str) -> TraceInfo:
+        try:
+            with open(file_path, "r") as f:
+                traceinfo =  jsonpickle.decode(f.read())
+            traceinfo.ROBOTMBT_MODEL_VERSION  # trigger AttributeError if non-robotmbt data
+        except OSError:
+            raise
+        except Exception:
+            raise TypeError(f"Contents from '{file_path}' could not be loaded as RobotMBT graph data")
+
+        if str(traceinfo.ROBOTMBT_MODEL_VERSION).split('.')[0] != TraceInfo.ROBOTMBT_MODEL_VERSION.split('.')[0]:
+            # raise if major version differs
+            raise ValueError("Graph data is from an incompatible RobotMBT version")
+        return traceinfo
+
     @staticmethod
     def stringify_pair(pair: tuple[ScenarioInfo, StateInfo]) -> str:
         """

robotmbt/visualise/visualiser.py

@@ -63,13 +63,16 @@ def __init__(self, graph_type: str, suite_name: str = "", export: str = '', trac
         self.graph_type: str = graph_type
 
         if trace_info is None:
-            self.trace_info: TraceInfo = TraceInfo()
+            self.trace_info: TraceInfo = TraceInfo(suite_name)
         else:
             self.trace_info = trace_info
 
         self.suite_name = suite_name
         self.export = export
 
+    def load_from_file(self, file_path: str):
+        self.trace_info = TraceInfo.import_graph_from_file(file_path)
+
     def update_trace(self, trace: TraceState):
         """
         Uses the new snapshots from trace to update the trace info.
@@ -110,14 +113,14 @@ def generate_visualisation(self) -> tuple[str, bool]:
         The boolean signals whether the output is in HTML format or not.
         """
         if self.export:
-            self.trace_info.export_graph(self.suite_name, self.export)
+            self.trace_info.export_graph(self.export)
 
         graph: AbstractGraph = self._get_graph()
         if graph is None and self.export:
             return f"Successfully exported to {self.export}!", False
         elif graph is None:
             raise ValueError(f"Unknown graph type: {self.graph_type}")
 
-        html_bokeh = networkvisualiser.NetworkVisualiser(graph, self.suite_name).generate_html()
+        html_bokeh = networkvisualiser.NetworkVisualiser(graph, self.trace_info.model_name).generate_html()
 
         return f'<iframe srcdoc="{html.escape(html_bokeh)}" width="{networkvisualiser.OUTER_WINDOW_WIDTH}px" height="{networkvisualiser.OUTER_WINDOW_HEIGHT}px"></iframe>', True