qairt-visualizer 0.8.0__py3-none-macosx_11_0_arm64.whl → 0.9.0__py3-none-macosx_11_0_arm64.whl

qairt_visualizer/__init__.py

@@ -8,13 +8,16 @@
 """qairt_visualizer module exports"""
 
 import importlib
+import os
 
-from qairt_visualizer.apis import view
+from qairt_visualizer.apis import diff, view
 from qairt_visualizer.core.ui.helpers import post_install
 from qairt_visualizer.core.visualizer_logging.helpers import set_log_level
 from qairt_visualizer.models.display_options import DisplayOptions
 
-post_install.run()
+skip_post_install_run = os.getenv("SKIP_AUTOMATIC_POST_INSTALL_RUN", "false").lower()
+if skip_post_install_run == "false":
+    post_install.run()
 
-__all__ = ["view", "set_log_level", "DisplayOptions"]
+__all__ = ["view", "diff", "set_log_level", "DisplayOptions"]
 __version__ = importlib.metadata.version("qairt_visualizer")

qairt_visualizer/apis.py

@@ -15,6 +15,7 @@ from qairt_visualizer.core.communicators.base_communicator_context import BaseCo
 from qairt_visualizer.core.communicators.factory_communicator import get_communicator
 from qairt_visualizer.core.launchers.base_ui_launcher_context import BaseUILauncherContext
 from qairt_visualizer.core.launchers.factory_ui_launcher import get_launcher
+from qairt_visualizer.core.launchers.node_launcher_context import NodeLauncherContext
 from qairt_visualizer.core.visualizer_logging.logger_constants import api_logger
 from qairt_visualizer.core.visualizer_logging.logging_config import LoggingConfig
 from qairt_visualizer.core.visualizer_service import VisualizerService
@@ -45,6 +46,8 @@ def view(
         visualization window to display.
     :param options: Customizes the visualization window behavior.
     """
+
+    print("Opening QAIRT Visualizer...\n")
     LoggingConfig.setup_logging()
 
     options = options or DisplayOptions()
@@ -100,3 +103,46 @@ async def _view(
     except Exception as e:  # pylint: disable=broad-exception-caught
         api_logger.debug(e, exc_info=True)
         api_logger.error("An error occurred when attempting to view: %s", str(e))
+
+
+def diff(
+    reference_model_path: str,
+    comparison_model_path: str,
+    output_path: Optional[str] = None,
+    profile: bool = False,
+) -> str:
+    """
+    Compare two models and return a diff report path.
+
+    :param reference_model_path: Path to the reference model file
+    :param comparison_model_path: Path to the comparison model file
+    :param output_path: Optional path to save the JSON diff report
+    :param profile: Display diff profiling metrics
+    :return: Path to the diff report
+    """
+
+    print("Starting model diff...\n")
+    LoggingConfig.setup_logging()
+
+    api_logger.info("Comparing models: %s vs %s", reference_model_path, comparison_model_path)
+
+    try:
+        node_launcher = NodeLauncherContext()
+        visualizer_service = VisualizerService(
+            ui_launcher=None, communicator=None, node_launcher=node_launcher
+        )
+
+        report_path = visualizer_service.diff(
+            reference_model_path=reference_model_path,
+            comparison_model_path=comparison_model_path,
+            output_path=output_path,
+            profile=profile,
+        )
+
+        api_logger.info("Diff operation completed successfully")
+        return report_path
+
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        api_logger.debug(e, exc_info=True)
+        api_logger.error("An error occurred during diff operation: %s", str(e))
+        raise

qairt_visualizer/constants/node_constants.py

@@ -0,0 +1,10 @@
+# ==============================================================================
+#
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# All Rights Reserved.
+# Confidential and Proprietary - Qualcomm Technologies, Inc.
+#
+# ==============================================================================
+"""Node.js related constants"""
+
+NODE_VERSION = "v20.12.2"

qairt_visualizer/core/launchers/electron_launcher_context.py

@@ -10,14 +10,13 @@
 import os
 import platform
 import subprocess
-import threading
 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
-from qairt_visualizer.helpers.ui_helpers import find_ui_path_to
+from qairt_visualizer.helpers.path_helpers import find_path_to
 
 
 class ElectronLauncherContext(BaseUILauncherContext):
@@ -38,7 +37,7 @@ class ElectronLauncherContext(BaseUILauncherContext):
             app_extension = ".exe"
         elif caller_platform == "darwin":
             app_extension = ".app"
-        return find_ui_path_to(f"dist/{self.application_name}{app_extension}")
+        return find_path_to(f"dist/{self.application_name}{app_extension}")
 
     def is_same_process(self, process_attrs: ProcessAttributes, process_name: str) -> bool:
         return process_attrs.proc_name == process_name
@@ -106,7 +105,7 @@ class ElectronLauncherContext(BaseUILauncherContext):
             proc = subprocess.Popen(  # pylint: disable=consider-using-with
                 command_line_args,
                 stdout=subprocess.DEVNULL,
-                stderr=subprocess.PIPE,
+                stderr=subprocess.DEVNULL,
                 start_new_session=True,
                 text=True,
                 bufsize=1,
@@ -115,20 +114,6 @@ class ElectronLauncherContext(BaseUILauncherContext):
             raise RuntimeError(f"Spawning QAIRT visualizer application failed: {e}") from e
         self.set_pid(proc.pid)
 
-        capture_seconds = 3.0
-        if proc.stderr:
-            start_time = time.time()
-
-            def _capture_initial_stderr():
-                while True:
-                    if proc.poll() is not None or time.time() - start_time > capture_seconds:
-                        break
-                    line = proc.stderr.readline().rstrip() if proc.stderr else None
-                    if line:
-                        self.logger.error("Error while starting QAIRT Visualizer: %s", line)
-
-            threading.Thread(target=_capture_initial_stderr, daemon=True).start()
-
     def _get_existing_zmq_port(self) -> Optional[int]:
         """Check for existing ZMQ port from temp file"""
         try:

qairt_visualizer/core/launchers/node_launcher_context.py

@@ -0,0 +1,88 @@
+# ==============================================================================
+#
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# All Rights Reserved.
+# Confidential and Proprietary - Qualcomm Technologies, Inc.
+#
+# ==============================================================================
+"""Node Launcher Context"""
+
+import os
+import platform
+import shutil
+import subprocess
+from pathlib import Path
+from typing import List, Optional
+
+from qairt_visualizer.core.ui.helpers.os_helpers import is_linux, is_mac, is_windows
+from qairt_visualizer.core.visualizer_logging.logger_constants import api_logger
+from qairt_visualizer.helpers.path_helpers import find_path_to
+
+
+class NodeLauncherContext:
+    """
+    Context class for launching and managing Node.js subprocess executions.
+    """
+
+    def __init__(self, node_home: str | None = None):
+        self.logger = api_logger
+        self.node_home = node_home
+
+    def launch(
+        self,
+        script_path: str,
+        args: List[str],
+        cwd: Optional[str] = None,
+    ) -> subprocess.CompletedProcess:
+        """
+        Execute program script with Node.js.
+
+        :param script_path: Path to the program script
+        :param args: List of arguments to pass to the script
+        :param cwd: Optional working directory for the subprocess
+        :return: CompletedProcess object containing the result
+        """
+        script_path_obj = Path(script_path)
+        working_dir = cwd or str(script_path_obj.parent)
+        node_path = (
+            self._get_node_path(platform.system().lower()) if self.node_home is None else self.node_home
+        )
+        cmd = [node_path, str(script_path_obj)] + args
+
+        self.logger.debug("Working directory: %s", working_dir)
+        self.logger.debug("Executing node command: %s", " ".join(cmd))
+
+        try:
+            return subprocess.run(
+                cmd,
+                text=True,
+                encoding="utf-8",
+                check=True,
+                cwd=working_dir,
+            )
+
+        except (subprocess.CalledProcessError, FileNotFoundError) as e:
+            error_msg = e.stderr if isinstance(e, subprocess.CalledProcessError) else str(e)
+            self.logger.debug("Node.js script execution failed", exc_info=True)
+            raise RuntimeError(f"Failed to execute Node.js script: {error_msg}") from None
+
+    def _get_node_path(self, caller_platform: str) -> str:
+        path = ""
+        if is_windows(caller_platform):
+            path = "node.exe"
+        elif is_mac(caller_platform) or is_linux(caller_platform):
+            path = "bin/node"
+        else:
+            raise ValueError(
+                f"Unknown platform to run node, platform={caller_platform}. Contact support and attach logs."
+            )
+        try:
+            return find_path_to(f"resources/node/{path}", "qairt_visualizer")
+        except (ValueError, FileNotFoundError):
+            global_node_path = shutil.which("node")
+            if os.getenv("SKIP_POST_INSTALL", "false").lower() == "true" and global_node_path is not None:
+                self.logger.debug(
+                    "SKIP_POST_INSTALL=true, unable to locate node path. Using global node instance."
+                )
+                return global_node_path
+            raise

qairt_visualizer/core/launchers/web_launcher_context.py

@@ -18,7 +18,7 @@ from IPython.display import HTML, display
 
 from qairt_visualizer.core.launchers.base_ui_launcher_context import BaseUILauncherContext
 from qairt_visualizer.core.launchers.models.process_attributes import ProcessAttributes
-from qairt_visualizer.helpers.ui_helpers import find_ui_path_to
+from qairt_visualizer.helpers.path_helpers import find_path_to
 
 
 class WebLauncherContext(BaseUILauncherContext):
@@ -33,7 +33,7 @@ class WebLauncherContext(BaseUILauncherContext):
 
     def launch(self):
         port = self.detect_port(5555)
-        server_path = find_ui_path_to(self.application_name)
+        server_path = find_path_to(self.application_name)
         cmd = [
             sys.executable,
             str(server_path),

qairt_visualizer/core/parsers/dlc_parser/dlc_parser.py

@@ -7,7 +7,9 @@
 # ==============================================================================
 """DLC Parser class"""
 
+import json
 import os
+import re
 from collections import defaultdict
 from typing import Any, Dict, Literal, Optional, Set, Tuple
 
@@ -56,7 +58,7 @@ class DlcParser:
         if not os.path.splitext(dlc_file_path)[1] == ".dlc":
             raise ValueError(f"The specified file {dlc_file_path} is not a DLC file")
 
-    def extract_onnx_mappings(self) -> DlcOpTensorMappings:
+    def extract_mappings(self) -> DlcOpTensorMappings:
         """
         Creates a JSON serializable map of DLC ops and tensors to source,
         and source model ops and tensors back to DLC
@@ -66,39 +68,94 @@ class DlcParser:
         DLC ops/tensors
         """
 
-        graph = self.get_ir_graph(self.model_reader)
-        op_source = graph.get_trace_info().get_op_trace_info()
-        tensor_source = graph.get_trace_info().get_tensor_trace_info()
-
+        source_mappings: Optional[OpTensorMappings] = None
+        has_valid_sdk_trace = "source.topology0" in self.model_reader.get_record_names()
+        if has_valid_sdk_trace:
+            graph = self.get_ir_graph(self.model_reader)
+            if graph is not None:
+                op_source = graph.get_trace_info().get_op_trace_info()
+                tensor_source = graph.get_trace_info().get_tensor_trace_info()
+                source_mappings = self._extract_onnx_mappings(op_source, tensor_source)
+        htp_file_data = self.get_htp_file()
+        backend_mappings = self.extract_htp_mappings(htp_file_data) if htp_file_data else None
         return DlcOpTensorMappings(
             dlc_model_path=self.dlc_path,
-            source_mappings=self._extract_onnx_mappings(op_source, tensor_source),
+            source_mappings=source_mappings,
             # Add backend parsing here for phase 2
-            backend_mappings=None,
+            backend_mappings=backend_mappings,
         )
 
     # pylint: disable=too-many-locals
-    def _extract_onnx_mappings(self, dlc_op_map, dlc_tensor_map) -> Optional[OpTensorMappings]:
-        """
-        Takes op and tensor traces and returns four maps:
-        1. DLC op -> ONNX op/tensor
-        2. ONNX op -> DLC op/tensor
-        3. DLC tensor -> ONNX op/tensor
-        4. ONNX tensor -> DLC op/tensor
+    def extract_htp_mappings(self, data) -> Optional[OpTensorMappings]:
+        """Extract mappings between backend operations/tensors and their parent DLC ops.
+
+        The backend graph JSON contains nodes keyed by hex identifiers (e.g. "0x0000103000000016")
+        with a nested qnn_op_name->1544 field that gives the originating high-level
+        DLC op name (e.g. "_layernorm_0", "Input").
+
+        During backend compilation, each DLC operation may be decomposed into multiple backend operations.
+        Note: Backend tensors map to DLC ops, not DLC tensors, as the backend graph structure
+        links tensors to their producing/consuming operations rather than to tensor names as HTP graphs
+        do not have tensor data.
+
+        :param data: JSON string containing the backend graph structure
+        :return: OpTensorMappings with backend_mappings populated, or None if no valid mappings found
         """
-        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]]] = {}
 
-        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]]] = {}
+        try:
+            data = json.loads(data)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"File data {data} is not valid JSON: {exc}") from exc
+
+        graph = data.get("graph", {})
+        nodes: Dict[str, Any] = graph.get("nodes", {})
+
+        # Tracks cross-domain relationships that will be used to:
+        # 1. Build direct source↔target mappings
+        # 2. Derive same-graph mappings via transitive relationships
+        source_item_to_target_set: Dict[Tuple[str, str], Set[str]] = defaultdict(set)
+        target_item_to_source_set: Dict[Tuple[str, str], Set[str]] = defaultdict(set)
+
+        # Parse backend graph nodes to build mappings:
+        # - DLC op ↔ backend op
+        # - DLC op ↔ backend tensors (inputs/outputs)
+        for backend_op_id, node in nodes.items():
+            scalar_params = node.get("scalar_params", {})
+            qnn_name_entry = scalar_params.get("qnn_op_name", {})
+            htp_string_key = "1544"
+            qnn_op_name = None
+            if isinstance(qnn_name_entry, dict):
+                qnn_op_name = qnn_name_entry.get(htp_string_key)
+            if not qnn_op_name:
+                continue
+
+            source_item_to_target_set[(OPS_KEY, qnn_op_name)].add(f"{OPS_KEY}:{backend_op_id}")
+            target_item_to_source_set[(OPS_KEY, backend_op_id)].add(f"{OPS_KEY}:{qnn_op_name}")
+
+            input_names = node.get("input_names", []) or []
+            output_names = node.get("output_names", []) or []
+            referenced_tensors = set(input_names + output_names)
+            for tensor_id in referenced_tensors:
+                source_item_to_target_set[(OPS_KEY, qnn_op_name)].add(f"{TENSOR_KEY}:{tensor_id}")
+                target_item_to_source_set[(TENSOR_KEY, tensor_id)].add(f"{OPS_KEY}:{qnn_op_name}")
 
-        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)
+        return self._build_op_tensor_mappings(source_item_to_target_set, target_item_to_source_set)
 
+    # pylint: disable=too-many-locals
+    def _extract_onnx_mappings(self, dlc_op_map, dlc_tensor_map) -> Optional[OpTensorMappings]:
+        """
+        Takes op and tensor traces and returns mappings between ONNX (source) and DLC (target):
+        - ONNX op -> DLC op/tensor (source_ops_to_target_ops_and_tensors)
+        - DLC op -> ONNX op/tensor (target_ops_to_source_ops_and_tensors)
+        - ONNX tensor -> DLC op/tensor (source_tensors_to_target_ops_and_tensors)
+        - DLC tensor -> ONNX op/tensor (target_tensors_to_source_ops_and_tensors)
+        Plus same-domain mappings for ONNX (source) and DLC (target).
+        """
+        # Track relationships for building same-graph mappings
+        source_item_to_target_set: Dict[Tuple[str, str], Set[str]] = defaultdict(set)
+        target_item_to_source_set: Dict[Tuple[str, str], Set[str]] = defaultdict(set)
+
+        # Extract ONNX -> DLC mappings
         for dlc_type, dlc_items in zip([OPS_KEY, TENSOR_KEY], [dlc_op_map, dlc_tensor_map]):
             for dlc_item in dlc_items:
                 dlc_name = dlc_item.get_name()
@@ -109,28 +166,60 @@ class DlcParser:
                         OPS_KEY if source_item.get_type() == OP else TENSOR_KEY
                     )
 
-                    if dlc_type == OPS_KEY:
-                        self.update_mapping(
-                            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
-                        )
-
-                    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(
-                            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}")
+                    target_item_to_source_set[(dlc_type, dlc_name)].add(f"{source_type}:{source_name}")
+                    source_item_to_target_set[(source_type, source_name)].add(f"{dlc_type}:{dlc_name}")
+
+        return self._build_op_tensor_mappings(source_item_to_target_set, target_item_to_source_set)
 
+    def _build_op_tensor_mappings(
+        self,
+        source_item_to_target_set: Dict[Tuple[str, str], Set[str]],
+        target_item_to_source_set: Dict[Tuple[str, str], Set[str]],
+    ) -> Optional[OpTensorMappings]:
+        """
+        Build OpTensorMappings from the collected source-to-target and target-to-source relationships.
+
+        :param source_item_to_target_set: Map of (item_type, item_name) -> set of "type:name" strings
+        :param target_item_to_source_set: Map of (item_type, item_name) -> set of "type:name" strings
+        :return: OpTensorMappings object or None if no mappings found
+        """
+        source_ops_to_target_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        target_ops_to_source_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        source_tensors_to_target_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        target_tensors_to_source_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]]] = {}
+        target_ops_to_target_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+        target_tensors_to_target_ops_and_tensors: Dict[str, Dict[str, Set[str]]] = {}
+
+        for (item_type, item_name), related_set in source_item_to_target_set.items():
+            for related_str in related_set:
+                related_type_str, related_name = related_str.split(":", 1)
+                related_type: Literal["ops", "tensors"] = related_type_str  # type: ignore
+                if item_type == OPS_KEY:
+                    self.update_mapping(
+                        source_ops_to_target_ops_and_tensors, item_name, related_type, related_name
+                    )
+                else:
+                    self.update_mapping(
+                        source_tensors_to_target_ops_and_tensors, item_name, related_type, related_name
+                    )
+
+        for (item_type, item_name), related_set in target_item_to_source_set.items():
+            for related_str in related_set:
+                related_type_str, related_name = related_str.split(":", 1)
+                related_type: Literal["ops", "tensors"] = related_type_str  # type: ignore
+                if item_type == OPS_KEY:
+                    self.update_mapping(
+                        target_ops_to_source_ops_and_tensors, item_name, related_type, related_name
+                    )
+                else:
+                    self.update_mapping(
+                        target_tensors_to_source_ops_and_tensors, item_name, related_type, related_name
+                    )
+
+        # Builds same-graph mappings
         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:
@@ -145,18 +234,17 @@ class DlcParser:
                             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_item_to_target_set,
+            target_item_to_source_set,
             source_ops_to_source_ops_and_tensors,
             source_tensors_to_source_ops_and_tensors,
         )
+        build_intra_relations(
+            target_item_to_source_set,
+            source_item_to_target_set,
+            target_ops_to_target_ops_and_tensors,
+            target_tensors_to_target_ops_and_tensors,
+        )
 
         def convert_sets(d: Dict[str, Dict[str, Set[str]]]) -> Dict[str, MappingGroup]:
             return {
@@ -164,29 +252,38 @@ class DlcParser:
                 for k, v in d.items()
             }
 
-        return (
-            OpTensorMappings(
-                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),
+        # Check if any mappings exist
+        has_mappings = (
+            source_ops_to_target_ops_and_tensors
+            or source_tensors_to_target_ops_and_tensors
+            or target_ops_to_source_ops_and_tensors
+            or target_tensors_to_source_ops_and_tensors
+            or source_ops_to_source_ops_and_tensors
+            or source_tensors_to_source_ops_and_tensors
+            or target_ops_to_target_ops_and_tensors
+            or target_tensors_to_target_ops_and_tensors
+        )
+
+        if has_mappings:
+            return OpTensorMappings(
+                source_ops_to_target_ops_and_tensors=convert_sets(source_ops_to_target_ops_and_tensors),
+                target_ops_to_source_ops_and_tensors=convert_sets(target_ops_to_source_ops_and_tensors),
+                source_tensors_to_target_ops_and_tensors=convert_sets(
+                    source_tensors_to_target_ops_and_tensors
+                ),
+                target_tensors_to_source_ops_and_tensors=convert_sets(
+                    target_tensors_to_source_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
                 ),
+                target_ops_to_target_ops_and_tensors=convert_sets(target_ops_to_target_ops_and_tensors),
+                target_tensors_to_target_ops_and_tensors=convert_sets(
+                    target_tensors_to_target_ops_and_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
-        )
+        return None
 
     def update_mapping(
         self,
@@ -207,6 +304,8 @@ class DlcParser:
         :return: An IR graph object
         """
         graph_names: set = model_reader.get_ir_graph_names()
+        if len(graph_names) == 0:
+            return None
         # We only support single IR graph, so there's no need to iterate
         # It also might make sense to make 'graph' a member variable in the future
         if len(graph_names) > 1:
@@ -219,6 +318,8 @@ class DlcParser:
         model with the --enable_framework_trace argument. Source topology will always be the
         first and only entry 0
         """
+        if not "source.topology0" in self.model_reader.get_record_names():
+            return ""
         # 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(
@@ -230,6 +331,36 @@ class DlcParser:
             )
         return topology.get_bytes()
 
+    # Contains both HTP topology and mappings
+    def get_htp_file(self):
+        """
+        Gets the HTP file from the DLC, if available
+        :return: The HTP topology + mappings file
+        """
+        try:
+            record_names = self.model_reader.get_record_names()
+            htp_record_name = None
+            for record_name in record_names:
+                if re.match(r"^htp\.graph\.mapping\.", record_name):
+                    htp_record_name = record_name
+                    break
+
+            if htp_record_name is None:
+                return None
+
+            topology = self.model_reader.extract_record(
+                # There is no DlcRecordType for HTP, and it appears
+                # to be a bug in their code that this value isn't used at
+                # all but is still required
+                recordName=htp_record_name,
+                recordType=modeltools.DlcRecordType.SOURCE_TOPOLOGY,
+            )
+
+            return topology.get_bytes().decode("utf-8")
+        except Exception:  # pylint: disable=broad-exception-caught
+            # HTP mappings may not necessarily be in the DLC
+            return None
+
     def close_file(self):
         """
         Closes the model_reader file

qairt_visualizer/core/parsers/dlc_parser/get_htp_topology.py

@@ -0,0 +1,40 @@
+# ==============================================================================
+#
+# Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
+# All Rights Reserved.
+# Confidential and Proprietary - Qualcomm Technologies, Inc.
+#
+# ==============================================================================
+"""Extract HTP Topology From DLC"""
+
+import sys
+
+from qairt_visualizer.core.parsers.dlc_parser.dlc_parser import DlcParser
+from qairt_visualizer.core.parsers.dlc_parser.helpers.exception_helpers import handle_exception
+from qairt_visualizer.core.parsers.dlc_parser.helpers.file_helpers import save_topology_to_tmp
+
+
+def main():
+    """
+    CLI entry point: Gets the DLC's topology, if available.
+    """
+    try:
+        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)
+        htp_topology = reader.get_htp_file()
+
+        if htp_topology:
+            sys.stdout.write(save_topology_to_tmp(htp_topology, extension=".json"))
+            sys.stdout.flush()
+        else:
+            sys.stdout.write("")
+            sys.stdout.flush()
+    except Exception as e:  # pylint: disable=broad-exception-caught
+        handle_exception(e)
+
+
+if __name__ == "__main__":
+    main()