qairt-visualizer 0.5.1__py3-none-win_amd64.whl → 0.7.0__py3-none-win_amd64.whl

qairt_visualizer/core/helpers/version.py

@@ -0,0 +1,23 @@
+# ==============================================================================
+#
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# All Rights Reserved.
+# Confidential and Proprietary - Qualcomm Technologies, Inc.
+#
+# ==============================================================================
+"""Extract Python Version"""
+
+import platform
+import sys
+
+
+def main():
+    """
+    CLI entry point: Sends python version to stdout
+    """
+    sys.stdout.write(platform.python_version())
+    sys.stdout.flush()
+
+
+if __name__ == "__main__":
+    main()

qairt_visualizer/core/launchers/base_ui_launcher_context.py

@@ -125,23 +125,44 @@ class BaseUILauncherContext(ABC):
         extract the port from that process first.
         :return: The port number for the existing process, -1 if cannot be found
         """
+        process_attrs, port = self.locate_ui_process()
         if self._pid:
-            port = self.find_ui_process_port_using_pid(self._pid)
             if port is not self._PROCESS_NOT_FOUND:
                 return port
 
-        if platform.system().lower() == "windows":
-            process_name = self.application_name
-            process_attrs, port = self._find_ui_process_port_windows(process_name)
-        else:
-            process_attrs, port = self._find_ui_process_port_by_iteration()
-
         if process_attrs is None or port == self._PROCESS_NOT_FOUND:
             return self._PROCESS_NOT_FOUND
 
         self.set_pid(process_attrs.pid)
         return port
 
+    def locate_ui_process(self) -> Tuple[ProcessAttributes | None, int]:
+        """
+        Will loop through all running processes and checks if any of them match the application_name provided
+        If a process is found, both process attributes and the port number is extracted. If _pid is set,
+        this function will attempt to locate the process and parse it to return process attributes and port.
+        :return: A tuple containing the ProcessAttributes and the port number
+        """
+        port = None
+        process_attrs = None
+        if self._pid:
+            try:
+                process: psutil.Process = psutil.Process(self._pid)
+                process_attrs = ProcessAttributes(process.cmdline(), process.name(), pid=self._pid)
+                port = self.extract_port_from_process(process_attrs)
+            except psutil.NoSuchProcess:
+                process_attrs, port = [None, self._PROCESS_NOT_FOUND]
+
+        if port is not None and port is not self._PROCESS_NOT_FOUND:
+            return process_attrs, port
+
+        if platform.system().lower() == "windows":
+            process_name = self.application_name
+            process_attrs, port = self._find_ui_process_port_windows(process_name)
+        else:
+            process_attrs, port = self._find_ui_process_port_by_iteration()
+        return process_attrs, port
+
     @classmethod
     def set_pid(cls, pid: int) -> None:
         """Sets the pid class variable

qairt_visualizer/core/launchers/electron_launcher_context.py

@@ -7,9 +7,12 @@
 # ==============================================================================
 """Electron launcher"""
 
+import os
 import platform
 import subprocess
-from typing import List
+import time
+from pathlib import Path
+from typing import List, Optional, cast
 
 from qairt_visualizer.core.launchers.base_ui_launcher_context import BaseUILauncherContext
 from qairt_visualizer.core.launchers.models.process_attributes import ProcessAttributes
@@ -21,6 +24,9 @@ class ElectronLauncherContext(BaseUILauncherContext):
     Concrete launcher class responsible for launching the Electron Visualization application.
     """
 
+    _DEFAULT_PORT = 5555
+    _PORT_FILE_LOCATION = os.path.expanduser("~/.qairt_visualizer/current_port.txt")
+
     def __init__(self):
         super().__init__()
         self.application_name = "qairt_visualizer"
@@ -37,8 +43,42 @@ class ElectronLauncherContext(BaseUILauncherContext):
         return process_attrs.proc_name == process_name
 
     def launch(self) -> int:
-        """Launches application in background at given port"""
-        port = self.detect_port(5555)
+        """Launches application in background at given port
+        :return: The port Visualizer is listening on
+        """
+        process_attrs, existing_port = self.locate_ui_process()
+
+        visual_only_launched_previously_application_listening_for_connection = (
+            process_attrs is not None and existing_port != -1
+        )
+        if visual_only_launched_previously_application_listening_for_connection:
+            return existing_port
+
+        port_written_to_port_file = self._get_existing_zmq_port()
+        main_app_launched_listening_for_connection = (
+            process_attrs is not None and port_written_to_port_file is not None
+        )
+
+        if main_app_launched_listening_for_connection:
+            return cast(int, port_written_to_port_file)
+
+        has_stale_port_file = (
+            process_attrs is None and port_written_to_port_file is not None and self._is_port_file_old()
+        )
+        # This block handles when another python script may have launched
+        # visualizer while the above code already ran
+        if has_stale_port_file:
+            try:
+                port_file = Path(self._PORT_FILE_LOCATION)
+                port_file.unlink(missing_ok=True)
+                self.logger.debug("Deleted stale port file")
+            except OSError as e:
+                self.logger.error("Failed to delete stale port file: %s", e)
+        elif port_written_to_port_file is not None:
+            return port_written_to_port_file
+        # End handler for multi-python script scenario
+
+        port = self.detect_port(self._DEFAULT_PORT)
         self._launch(["--port", f"{port}"])
         return port
 
@@ -64,6 +104,35 @@ class ElectronLauncherContext(BaseUILauncherContext):
         )
         self.set_pid(proc.pid)
 
+    def _get_existing_zmq_port(self) -> Optional[int]:
+        """Check for existing ZMQ port from temp file"""
+        try:
+            if os.path.exists(self._PORT_FILE_LOCATION):
+                with open(self._PORT_FILE_LOCATION, "r", encoding="utf-8") as f:
+                    port = int(f.read().strip())
+                    self.logger.debug("Found existing ZMQ port: %s", port)
+                    return port
+        except (ValueError, IOError, OSError) as e:
+            self.logger.debug("Could not read port file: %s", e)
+
+        return None
+
+    def _is_port_file_old(self, seconds: int = 30) -> bool:
+        """Check if the port file is older than the specified number of seconds"""
+        try:
+            if not os.path.exists(self._PORT_FILE_LOCATION):
+                return False
+
+            file_mod_time = os.path.getmtime(self._PORT_FILE_LOCATION)
+            current_time = time.time()
+            age_in_seconds = current_time - file_mod_time
+
+            return age_in_seconds > seconds
+
+        except OSError as e:
+            self.logger.debug("Error checking port file age: %s", e)
+            return False
+
     def extract_port_from_process(self, process_attrs: ProcessAttributes) -> int:
         app_extension = ""
         process_name = self.application_name

qairt_visualizer/core/parsers/dlc_parser/dlc_parser.py

@@ -8,7 +8,8 @@
 """DLC Parser class"""
 
 import os
-from typing import Any, Dict, Optional, Set
+from collections import defaultdict
+from typing import Any, Dict, Literal, Optional, Set, Tuple
 
 from qairt_visualizer.core.errors import ArgumentError
 from qairt_visualizer.core.parsers.dlc_parser.models.op_tensor_mappings import (  # type: ignore
@@ -28,9 +29,9 @@ from . import libPyIrGraph as ir_graph  # type: ignore
 _ = ir_graph
 
 OP = 1
-OPS_KEY = "ops"
+OPS_KEY: Literal["ops"] = "ops"
 TENSOR = 0
-TENSOR_KEY = "tensors"
+TENSOR_KEY: Literal["tensors"] = "tensors"
 
 
 class DlcParser:
@@ -49,7 +50,7 @@ class DlcParser:
         """
 
         if not dlc_file_path:
-            raise ArgumentError("A valid DLC file argument is required")
+            raise ArgumentError("A DLC file path is required")
         if not os.path.isfile(dlc_file_path):
             raise FileNotFoundError(f"The input file path {dlc_file_path} does not exist")
         if not os.path.splitext(dlc_file_path)[1] == ".dlc":
@@ -85,38 +86,78 @@ class DlcParser:
         3. DLC tensor -> ONNX op/tensor
         4. ONNX tensor -> DLC op/tensor
         """
-        dlc_ops_to_target_ops: Dict[str, Dict[str, Set[str]]] = {}
-        target_ops_to_dlc_ops: Dict[str, Dict[str, Set[str]]] = {}
-        dlc_tensors_to_target_tensors: Dict[str, Dict[str, Set[str]]] = {}
-        target_tensors_to_dlc_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        dlc_ops_to_source_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        source_ops_to_dlc_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        dlc_tensors_to_source_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        source_tensors_to_dlc_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
 
-        for category, dlc_items in zip([OPS_KEY, TENSOR_KEY], [dlc_op_map, dlc_tensor_map]):
+        dlc_ops_to_dlc_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        dlc_tensors_to_dlc_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        source_ops_to_source_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        source_tensors_to_source_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+
+        dlc_item_to_source_set: Dict[Tuple[str, str], Set[str]] = defaultdict(set)
+        source_item_to_dlc_set: Dict[Tuple[str, str], Set[str]] = defaultdict(set)
+
+        for dlc_type, dlc_items in zip([OPS_KEY, TENSOR_KEY], [dlc_op_map, dlc_tensor_map]):
             for dlc_item in dlc_items:
-                dlc_item_name = dlc_item.get_name()
+                dlc_name = dlc_item.get_name()
                 source_items = dlc_item.get_trace_pair()
-
                 for source_item in source_items:
                     source_name = source_item.get_name()
-                    source_type = OPS_KEY if source_item.get_type() == OP else TENSOR_KEY
-
-                    # DLC -> ONNX
-                    self.update_mapping(dlc_ops_to_target_ops, dlc_item_name, source_type, source_name)
-
-                    # ONNX -> DLC
-                    self.update_mapping(target_ops_to_dlc_ops, source_name, category, dlc_item_name)
+                    source_type: Literal["ops", "tensors"] = (
+                        OPS_KEY if source_item.get_type() == OP else TENSOR_KEY
+                    )
 
-                    # DLC tensor -> ONNX
-                    if category == TENSOR_KEY:
+                    if dlc_type == OPS_KEY:
                         self.update_mapping(
-                            dlc_tensors_to_target_tensors, dlc_item_name, source_type, source_name
+                            dlc_ops_to_source_ops_and_tensors, dlc_name, source_type, source_name
+                        )
+                    else:
+                        self.update_mapping(
+                            dlc_tensors_to_source_ops_and_tensors, dlc_name, source_type, source_name
                         )
 
-                    # ONNX tensor -> DLC
-                    if source_type == TENSOR_KEY:
+                    dlc_type_literal: Any = dlc_type
+                    if source_type == OPS_KEY:
+                        self.update_mapping(
+                            source_ops_to_dlc_ops_and_tensors, source_name, dlc_type_literal, dlc_name
+                        )
+                    else:
                         self.update_mapping(
-                            target_tensors_to_dlc_tensors, source_name, category, dlc_item_name
+                            source_tensors_to_dlc_ops_and_tensors, source_name, dlc_type_literal, dlc_name
                         )
 
+                    dlc_item_to_source_set[(dlc_type, dlc_name)].add(f"{source_type}:{source_name}")
+                    source_item_to_dlc_set[(source_type, source_name)].add(f"{dlc_type}:{dlc_name}")
+
+        def build_intra_relations(items_map, reverse_map, ops_map, tensors_map):
+            for (item_type, item_name), related_set in items_map.items():
+                for related_str in related_set:
+                    related_type, related_name = related_str.split(":", 1)
+                    other_items = reverse_map.get((related_type, related_name), set())
+                    for other_str in other_items:
+                        other_type, other_name = other_str.split(":", 1)
+
+                        if item_type == OPS_KEY:
+                            self.update_mapping(ops_map, item_name, other_type, other_name)
+                        else:
+                            self.update_mapping(tensors_map, item_name, other_type, other_name)
+
+        build_intra_relations(
+            dlc_item_to_source_set,
+            source_item_to_dlc_set,
+            dlc_ops_to_dlc_ops_and_tensors,
+            dlc_tensors_to_dlc_ops_and_tensors,
+        )
+
+        build_intra_relations(
+            source_item_to_dlc_set,
+            dlc_item_to_source_set,
+            source_ops_to_source_ops_and_tensors,
+            source_tensors_to_source_ops_and_tensors,
+        )
+
         def convert_sets(d: Dict[str, Dict[str, Set[str]]]) -> Dict[str, MappingGroup]:
             return {
                 k: MappingGroup(ops=sorted(v.get(OPS_KEY, [])), tensors=sorted(v.get(TENSOR_KEY, [])))
@@ -125,20 +166,34 @@ class DlcParser:
 
         return (
             OpTensorMappings(
-                dlc_ops_to_target_ops=convert_sets(dlc_ops_to_target_ops),
-                target_ops_to_dlc_ops=convert_sets(target_ops_to_dlc_ops),
-                dlc_tensors_to_target_tensors=convert_sets(dlc_tensors_to_target_tensors),
-                target_tensors_to_dlc_tensors=convert_sets(target_tensors_to_dlc_tensors),
+                dlc_ops_to_source_ops_and_tensors=convert_sets(dlc_ops_to_source_ops_and_tensors),
+                source_ops_to_dlc_ops_and_tensors=convert_sets(source_ops_to_dlc_ops_and_tensors),
+                dlc_tensors_to_source_ops_and_tensors=convert_sets(dlc_tensors_to_source_ops_and_tensors),
+                source_tensors_to_dlc_ops_and_tensors=convert_sets(source_tensors_to_dlc_ops_and_tensors),
+                dlc_ops_to_dlc_ops_and_tensors=convert_sets(dlc_ops_to_dlc_ops_and_tensors),
+                dlc_tensors_to_dlc_ops_and_tensors=convert_sets(dlc_tensors_to_dlc_ops_and_tensors),
+                source_ops_to_source_ops_and_tensors=convert_sets(source_ops_to_source_ops_and_tensors),
+                source_tensors_to_source_ops_and_tensors=convert_sets(
+                    source_tensors_to_source_ops_and_tensors
+                ),
             )
-            if len(dlc_ops_to_target_ops)
-            or len(target_ops_to_dlc_ops)
-            or len(dlc_tensors_to_target_tensors)
-            or len(target_tensors_to_dlc_tensors)
+            if len(dlc_ops_to_source_ops_and_tensors)
+            or len(source_ops_to_dlc_ops_and_tensors)
+            or len(dlc_tensors_to_source_ops_and_tensors)
+            or len(source_tensors_to_dlc_ops_and_tensors)
+            or len(dlc_ops_to_dlc_ops_and_tensors)
+            or len(dlc_tensors_to_dlc_ops_and_tensors)
+            or len(source_ops_to_source_ops_and_tensors)
+            or len(source_tensors_to_source_ops_and_tensors)
             else None
         )
 
     def update_mapping(
-        self, map_obj: Dict[str, Dict[str, Set[str]]], name: str, category: str, value: str
+        self,
+        map_obj: Dict[str, Dict[str, Set[str]]],
+        name: str,
+        category: Literal["ops", "tensors"],
+        value: str,
     ) -> None:
         """Simple helper function for setting dictionary objects"""
         group: Dict[str, Set[str]] = {OPS_KEY: set(), TENSOR_KEY: set()}
@@ -158,6 +213,23 @@ class DlcParser:
             raise NotImplementedError("DLC's with multiple IR graphs not currently supported")
         return self.model_reader.get_ir_graph(next(iter(graph_names)))
 
+    def get_source_topology(self):
+        """
+        Get the source topology from the DLC, if available. Requires converting the source
+        model with the --enable_framework_trace argument. Source topology will always be the
+        first and only entry 0
+        """
+        # Eventually when we support multiple source types, we need to
+        # get new enum values from the converter team to use for recordType
+        topology = self.model_reader.extract_record(
+            recordName="source.topology0", recordType=modeltools.DlcRecordType.SOURCE_TOPOLOGY
+        )
+        if topology.get_size() == 0:
+            raise ValueError(
+                f"DLC file {os.path.basename(self.dlc_path)} " + "does not contain its source topology"
+            )
+        return topology.get_bytes()
+
     def close_file(self):
         """
         Closes the model_reader file

qairt_visualizer/core/parsers/dlc_parser/get_source_topology.py

@@ -0,0 +1,47 @@
+# ==============================================================================
+#
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# All Rights Reserved.
+# Confidential and Proprietary - Qualcomm Technologies, Inc.
+#
+# ==============================================================================
+"""Extract Source Topology From DLC"""
+
+import sys
+import tempfile
+
+from qairt_visualizer.core.parsers.dlc_parser.dlc_parser import DlcParser
+from qairt_visualizer.core.parsers.dlc_parser.helpers.exception_helpers import handle_exception
+
+
+def main():
+    """
+    CLI entry point: Gets the DLC's topology, if available.
+    """
+    if len(sys.argv) == 1:
+        raise ValueError("An argument for a DLC file path was not provided")
+    dlc_path = sys.argv[1]
+
+    reader = DlcParser(dlc_path)
+    source_topology = reader.get_source_topology()
+
+    sys.stdout.write(save_topology_to_tmp(source_topology))
+    sys.stdout.flush()
+
+
+def save_topology_to_tmp(topology) -> str:
+    """
+    Saves the graph topology to a temp file, which must be removed by the caller
+    :param topology: The binary topology data to save to file
+    """
+    try:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".onnx", mode="wb") as tmp:
+            tmp.write(topology)
+            return tmp.name
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        handle_exception(e)
+        return ""
+
+
+if __name__ == "__main__":
+    main()

qairt_visualizer/core/parsers/dlc_parser/models/op_tensor_mappings.py

@@ -27,10 +27,14 @@ class OpTensorMappings(BaseModel):
     Class defining the various op / tensor mapping relationships
     """
 
-    dlc_ops_to_target_ops: Dict[str, MappingGroup]
-    target_ops_to_dlc_ops: Dict[str, MappingGroup]
-    dlc_tensors_to_target_tensors: Dict[str, MappingGroup]
-    target_tensors_to_dlc_tensors: Dict[str, MappingGroup]
+    dlc_ops_to_source_ops_and_tensors: Dict[str, MappingGroup]
+    source_ops_to_dlc_ops_and_tensors: Dict[str, MappingGroup]
+    dlc_tensors_to_source_ops_and_tensors: Dict[str, MappingGroup]
+    source_tensors_to_dlc_ops_and_tensors: Dict[str, MappingGroup]
+    dlc_ops_to_dlc_ops_and_tensors: Dict[str, MappingGroup]
+    dlc_tensors_to_dlc_ops_and_tensors: Dict[str, MappingGroup]
+    source_ops_to_source_ops_and_tensors: Dict[str, MappingGroup]
+    source_tensors_to_source_ops_and_tensors: Dict[str, MappingGroup]
 
 
 class DlcOpTensorMappings(BaseModel):

qairt_visualizer/core/ui/dist/browser/__init__.py

@@ -0,0 +1,47 @@
+""" Python Server entry point """
+
+import argparse
+import logging
+import os
+import sys
+
+from .server import __version__, serve, start, status, stop, wait, widget
+
+__all__ = ["start", "stop", "status", "wait", "serve", "widget", "__version__"]
+
+def main():
+    """ main entry point """
+    parser = argparse.ArgumentParser(description=
+        "Viewer for neural network, deep learning and machine learning models.")
+    parser.add_argument("file",
+        metavar="MODEL_FILE", help="model file to serve", nargs="?", default=None)
+    parser.add_argument("-b", "--browse",
+        help="launch web browser", action="store_true")
+    parser.add_argument("-p", "--port", help="port to serve", type=int)
+    parser.add_argument("--host",
+        metavar="ADDR", help="host to serve", default="localhost")
+    parser.add_argument("--verbosity",
+        metavar="LEVEL", help="log verbosity (quiet, default, debug)",
+        choices=[ "quiet", "debug", "default" ], default="default")
+    parser.add_argument("--version", help="print version", action="store_true")
+    args = parser.parse_args()
+    levels = {
+        "quiet": logging.CRITICAL,
+        "default": logging.INFO,
+        "debug": logging.DEBUG,
+    }
+    logging.basicConfig(level=levels[args.verbosity], format="%(message)s")
+    logger = logging.getLogger(__name__)
+    if args.file and not os.path.exists(args.file):
+        logger.error(f"Model file '{args.file}' does not exist.")
+        sys.exit(2)
+    if args.version:
+        logger.info(__version__)
+        sys.exit(0)
+    address = (args.host, args.port) if args.host else args.port if args.port else None
+    start(args.file, address=address, browse=args.browse)
+    wait()
+    sys.exit(0)
+
+if __name__ == "__main__":
+    main()

qairt_visualizer/core/ui/dist/browser/{assets/netron_plugin/source/acuity.js → acuity.js}

@@ -5,7 +5,7 @@ acuity.ModelFactory = class {
 
     async match(context) {
         const obj = await context.peek('json');
-        if (obj && obj.MetaData && obj.Layers) {
+        if (obj && obj.MetaData && obj.Layers && Object.keys(obj).length < 256) {
             return context.set('acuity', obj);
         }
         return null;
@@ -23,7 +23,7 @@ acuity.Model = class {
         this.name = model.MetaData.Name;
         this.format = `Acuity v${model.MetaData.AcuityVersion}`;
         this.runtime = model.MetaData.Platform;
-        this.graphs = [new acuity.Graph(metadata, model, data, quantization)];
+        this.modules = [new acuity.Graph(metadata, model, data, quantization)];
     }
 };
 
@@ -702,4 +702,4 @@ acuity.Error = class extends Error {
     }
 };
 
-export const ModelFactory = acuity.ModelFactory;
+export const ModelFactory = acuity.ModelFactory;