ttnn-visualizer 0.43.1__py3-none-any.whl → 0.44.1__py3-none-any.whl

ttnn_visualizer/app.py

@@ -7,20 +7,17 @@ import json
 import logging
 import os
 import subprocess
+import sys
 import threading
 import webbrowser
 from os import environ
 from pathlib import Path
-import sys
 from typing import cast
 
 import flask
 from dotenv import load_dotenv
 from flask import Flask, abort, jsonify
 from flask_cors import CORS
-from werkzeug.debug import DebuggedApplication
-from werkzeug.middleware.proxy_fix import ProxyFix
-
 from ttnn_visualizer.exceptions import (
     DatabaseFileNotFoundException,
     InvalidProfilerPath,
@@ -28,6 +25,8 @@ from ttnn_visualizer.exceptions import (
 )
 from ttnn_visualizer.instances import create_instance_from_local_paths
 from ttnn_visualizer.settings import Config, DefaultConfig
+from werkzeug.debug import DebuggedApplication
+from werkzeug.middleware.proxy_fix import ProxyFix
 
 logger = logging.getLogger(__name__)
 
@@ -104,7 +103,7 @@ def create_app(settings_override=None):
 
 
 def extensions(app: flask.Flask):
-    from ttnn_visualizer.extensions import flask_static_digest, db, socketio
+    from ttnn_visualizer.extensions import db, flask_static_digest, socketio
     from ttnn_visualizer.sockets import register_handlers
 
     """

ttnn_visualizer/csv_queries.py

@@ -8,20 +8,18 @@ import subprocess
 import tempfile
 from io import StringIO
 from pathlib import Path
-from typing import List, Dict, Union, Optional
+from typing import Dict, List, Optional, Union
 
 import pandas as pd
 import zstd
 from tt_perf_report import perf_report
-
-from ttnn_visualizer.exceptions import DataFormatError
 from ttnn_visualizer.exceptions import (
-    SSHException,
     AuthenticationException,
+    DataFormatError,
     NoValidConnectionsError,
+    SSHException,
 )
 from ttnn_visualizer.models import Instance, RemoteConnection
-from ttnn_visualizer.sftp_operations import read_remote_file
 
 
 def handle_ssh_subprocess_error(
@@ -148,180 +146,6 @@ class LocalCSVQueryRunner:
         return sanitized_df.values.tolist()
 
 
-class RemoteCSVQueryRunner:
-    def __init__(
-        self, file_path: str, remote_connection, sep: str = ",", offset: int = 0
-    ):
-        """
-        Initialize the RemoteCSVQueryRunner.
-
-        :param file_path: Path to the remote file.
-        :param remote_connection: RemoteConnection object for SSH access.
-        :param sep: Separator used in the CSV file.
-        :param offset: Number of lines to skip before treating the first valid line as headers.
-        """
-        self.file_path = file_path
-        self.remote_connection = remote_connection
-        self.sep = sep
-        self.offset = offset
-
-    def _execute_ssh_command(self, command: str) -> str:
-        """Execute an SSH command and return the output."""
-        ssh_cmd = ["ssh", "-o", "PasswordAuthentication=no"]
-
-        # Handle non-standard SSH port
-        if self.remote_connection.port != 22:
-            ssh_cmd.extend(["-p", str(self.remote_connection.port)])
-
-        ssh_cmd.extend(
-            [
-                f"{self.remote_connection.username}@{self.remote_connection.host}",
-                command,
-            ]
-        )
-
-        try:
-            result = subprocess.run(
-                ssh_cmd, capture_output=True, text=True, check=True, timeout=30
-            )
-            return result.stdout
-        except subprocess.CalledProcessError as e:
-            if e.returncode == 255:  # SSH protocol errors
-                handle_ssh_subprocess_error(e, self.remote_connection)
-                # This line should never be reached as handle_ssh_subprocess_error raises an exception
-                raise RuntimeError(f"SSH command failed: {e.stderr}")
-            else:
-                raise RuntimeError(f"SSH command failed: {e.stderr}")
-        except subprocess.TimeoutExpired:
-            raise RuntimeError(f"SSH command timed out: {command}")
-
-    def execute_query(
-        self,
-        filters: Optional[Dict[str, str]] = None,  # Allow unsanitized filter keys
-        as_dict: bool = False,  # Convert rows to dictionaries if True
-        limit: int = None,
-        columns=None,
-    ) -> Union[List[List[str]], List[Dict[str, str]]]:
-        """
-        Fetch rows with optional filtering and limit, returning either raw rows or dictionaries.
-        :param filters: Dictionary of unsanitized column filters (e.g., {"zone name": "BRISC-FW"}).
-        :param as_dict: Whether to return results as a list of dictionaries.
-        :param limit: Maximum number of rows to return.
-        :return: List of rows as lists or dictionaries.
-        """
-        # Fetch header row, accounting for the offset
-        header_cmd = f"head -n {self.offset + 1} {self.file_path} | tail -n 1"
-        raw_header = self._execute_ssh_command(header_cmd).strip()
-
-        # Sanitize headers
-        headers = [
-            col.strip().replace(" ", "_").lower() for col in raw_header.split(self.sep)
-        ]
-
-        # Build the AWK command for filtering
-        awk_filter = ""
-        if filters:
-            filter_conditions = []
-            for unsanitized_col, value in filters.items():
-                # Sanitize the filter key
-                sanitized_col = unsanitized_col.strip().replace(" ", "_").lower()
-                if sanitized_col in headers:
-                    col_idx = headers.index(sanitized_col) + 1
-                    filter_conditions.append(f'${col_idx} == "{value}"')
-                else:
-                    print(
-                        f"WARNING: Column '{unsanitized_col}' (sanitized: '{sanitized_col}') not found in headers."
-                    )
-            awk_filter = " && ".join(filter_conditions)
-
-        # Build AWK command
-        limit_clause = f"| head -n {limit}" if limit else ""
-        awk_cmd = f"awk -F'{self.sep}' 'NR > {self.offset + 1} {f'&& {awk_filter}' if awk_filter else ''} {{print}}' {self.file_path} {limit_clause}"
-
-        output = self._execute_ssh_command(awk_cmd).strip()
-
-        # Split rows into lists of strings
-        rows = [
-            [field.strip().strip('"') for field in line.split(self.sep)]
-            for line in output.splitlines()
-        ]
-        if as_dict:
-            # Convert rows to dictionaries
-            result = [dict(zip(headers, row)) for row in rows]
-
-            if columns:
-                sanitized_columns = [
-                    col.strip().replace(" ", "_").lower() for col in columns
-                ]
-                result = [
-                    {
-                        key: value
-                        for key, value in row.items()
-                        if key in sanitized_columns
-                    }
-                    for row in result
-                ]
-                print(f"DEBUG: Filtered columns: {sanitized_columns}")
-            return result
-        return rows
-
-    def execute_query_raw(self, limit: int = None) -> List[str]:
-        """
-        Fetch raw lines from the remote CSV file, accounting for the offset.
-
-        :param limit: Maximum number of rows to fetch (including offset rows).
-        :return: List of raw rows as strings.
-        """
-        total_lines = self.offset + limit if limit else ""
-        cmd = (
-            f"head -n {total_lines} {self.file_path}"
-            if total_lines
-            else f"cat {self.file_path}"
-        )
-        output = self._execute_ssh_command(cmd).strip()
-
-        return output.splitlines()[self.offset :]
-
-    def get_csv_header(self) -> Dict[str, int]:
-        """
-        Retrieve the CSV headers as a dictionary mapping column names to their indices (1-based).
-        :return: Dictionary of headers.
-        """
-        header_cmd = f"head -n {self.offset + 1} {self.file_path} | tail -n 1"
-        header = self._execute_ssh_command(header_cmd).strip()
-
-        # Trim spaces in header names
-        column_names = [name.strip() for name in header.split(self.sep)]
-        return {name: idx + 1 for idx, name in enumerate(column_names)}
-
-    def build_awk_filter(
-        self, column_indices: Dict[str, int], filters: Dict[str, str]
-    ) -> str:
-        if not filters:
-            return ""
-        conditions = [
-            f'${column_indices[col]} == "{val}"' for col, val in filters.items()
-        ]
-        return " && ".join(conditions)
-
-    def build_awk_columns(
-        self, column_indices: Dict[str, int], columns: List[str]
-    ) -> str:
-        return ", ".join([f"${column_indices[col]}" for col in columns])
-
-    def __enter__(self):
-        """
-        Enable usage with context management.
-        """
-        return self
-
-    def __exit__(self, exc_type, exc_val, exc_tb):
-        """
-        Clean up resources when exiting context.
-        """
-        pass
-
-
 class NPEQueries:
     NPE_FOLDER = "npe_viz"
     MANIFEST_FILE = "manifest.json"
@@ -329,24 +153,13 @@ class NPEQueries:
     @staticmethod
     def get_npe_manifest(instance: Instance):
 
-        if (
-            not instance.remote_connection
-            or instance.remote_connection
-            and not instance.remote_connection.useRemoteQuerying
-        ):
-            file_path = Path(
-                instance.performance_path,
-                NPEQueries.NPE_FOLDER,
-                NPEQueries.MANIFEST_FILE,
-            )
-            with open(file_path, "r") as f:
-                return json.load(f)
-        else:
-            profiler_folder = instance.remote_profile_folder
-            return read_remote_file(
-                instance.remote_connection,
-                f"{profiler_folder.remotePath}/{NPEQueries.NPE_FOLDER}/{NPEQueries.MANIFEST_FILE}",
-            )
+        file_path = Path(
+            instance.performance_path,
+            NPEQueries.NPE_FOLDER,
+            NPEQueries.MANIFEST_FILE,
+        )
+        with open(file_path, "r") as f:
+            return json.load(f)
 
     @staticmethod
     def get_npe_timeline(instance: Instance, filename: str):
@@ -355,40 +168,19 @@ class NPEQueries:
                 "filename parameter is required and cannot be None or empty"
             )
 
-        if (
-            not instance.remote_connection
-            or not instance.remote_connection.useRemoteQuerying
-        ):
-            if not instance.performance_path:
-                raise ValueError("instance.performance_path is None")
-
-            file_path = Path(instance.performance_path, NPEQueries.NPE_FOLDER, filename)
+        if not instance.performance_path:
+            raise ValueError("instance.performance_path is None")
 
-            if filename.endswith(".zst"):
-                with open(file_path, "rb") as file:
-                    compressed_data = file.read()
-                    uncompressed_data = zstd.uncompress(compressed_data)
-                    return json.loads(uncompressed_data)
-            else:
-                with open(file_path, "r") as f:
-                    return json.load(f)
-
-        else:
-            profiler_folder = instance.remote_profile_folder
-            remote_path = (
-                f"{profiler_folder.remotePath}/{NPEQueries.NPE_FOLDER}/{filename}"
-            )
-            remote_data = read_remote_file(instance.remote_connection, remote_path)
+        file_path = Path(instance.performance_path, NPEQueries.NPE_FOLDER, filename)
 
-            if filename.endswith(".zst"):
-                if isinstance(remote_data, str):
-                    remote_data = remote_data.encode("utf-8")
-                uncompressed_data = zstd.decompress(remote_data)
+        if filename.endswith(".zst"):
+            with open(file_path, "rb") as file:
+                compressed_data = file.read()
+                uncompressed_data = zstd.uncompress(compressed_data)
                 return json.loads(uncompressed_data)
-            else:
-                if isinstance(remote_data, bytes):
-                    remote_data = remote_data.decode("utf-8")
-                return json.loads(remote_data)
+        else:
+            with open(file_path, "r") as f:
+                return json.load(f)
 
 
 class DeviceLogProfilerQueries:
@@ -421,36 +213,17 @@ class DeviceLogProfilerQueries:
         """
         Determine the appropriate query runner based on the instance's remote connection.
         """
-
-        is_remote = self.instance.remote_connection
-        use_remote_querying = False
-
-        # Disabled until we resolve the issue with sqlite versions
-        # if is_remote:
-        #     use_remote_querying = self.instance.remote_connection.useRemoteQuerying
-
-        # Determine if this is a local or remote operation
-        if is_remote and use_remote_querying:
-            remote_profiler_folder = self.instance.remote_profile_folder
-            file_path = f"{remote_profiler_folder.remotePath}/{self.DEVICE_LOG_FILE}"
-            self.runner = RemoteCSVQueryRunner(
-                file_path=file_path,
-                remote_connection=self.instance.remote_connection,
-                offset=1,  # Skip the first line for device log files
-            )
-        else:
-            self.runner = LocalCSVQueryRunner(
-                file_path=Path(self.instance.performance_path).joinpath(
-                    self.DEVICE_LOG_FILE
-                ),
-                offset=1,  # Skip the first line for device log files
-            )
+        self.runner = LocalCSVQueryRunner(
+            file_path=Path(self.instance.performance_path).joinpath(
+                self.DEVICE_LOG_FILE
+            ),
+            offset=1,  # Skip the first line for device log files
+        )
 
         self.runner.__enter__()
 
-        if not is_remote or (is_remote and not use_remote_querying):
-            self.runner.df.columns = self.DEVICE_LOG_COLUMNS
-            self.runner.df.columns = self.runner.df.columns.str.strip()
+        self.runner.df.columns = self.DEVICE_LOG_COLUMNS
+        self.runner.df.columns = self.runner.df.columns.str.strip()
 
         return self
 
@@ -498,24 +271,11 @@ class DeviceLogProfilerQueries:
 
     @staticmethod
     def get_raw_csv(instance: Instance):
-        from ttnn_visualizer.sftp_operations import read_remote_file
-
-        if (
-            not instance.remote_connection
-            or instance.remote_connection
-            and not instance.remote_connection.useRemoteQuerying
-        ):
-            file_path = Path(
-                instance.performance_path, DeviceLogProfilerQueries.DEVICE_LOG_FILE
-            )
-            with open(file_path, "r") as f:
-                return f.read()
-        else:
-            profiler_folder = instance.remote_profile_folder
-            return read_remote_file(
-                instance.remote_connection,
-                f"{profiler_folder.remotePath}/{DeviceLogProfilerQueries.DEVICE_LOG_FILE}",
-            )
+        file_path = Path(
+            instance.performance_path, DeviceLogProfilerQueries.DEVICE_LOG_FILE
+        )
+        with open(file_path, "r") as f:
+            return f.read()
 
 
 class OpsPerformanceQueries:
@@ -637,20 +397,8 @@ class OpsPerformanceQueries:
 
     @staticmethod
     def get_raw_csv(instance):
-        from ttnn_visualizer.sftp_operations import read_remote_file
-
-        if (
-            not instance.remote_connection
-            or instance.remote_connection
-            and not instance.remote_connection.useRemoteQuerying
-        ):
-            with open(
-                OpsPerformanceQueries.get_local_ops_perf_file_path(instance)
-            ) as f:
-                return f.read()
-        else:
-            path = OpsPerformanceQueries.get_remote_ops_perf_file_path(instance)
-            return read_remote_file(instance.remote_connection, path)
+        with open(OpsPerformanceQueries.get_local_ops_perf_file_path(instance)) as f:
+            return f.read()
 
     def __exit__(self, exc_type, exc_val, exc_tb):
         """

ttnn_visualizer/decorators.py

@@ -4,19 +4,18 @@
 
 import logging
 import re
-from ttnn_visualizer.enums import ConnectionTestStates
-
-
 from functools import wraps
+
 from flask import abort, request, session
+from ttnn_visualizer.enums import ConnectionTestStates
 from ttnn_visualizer.exceptions import (
     AuthenticationException,
-    NoValidConnectionsError,
-    SSHException,
-    RemoteConnectionException,
     AuthenticationFailedException,
     NoProjectsException,
+    NoValidConnectionsError,
+    RemoteConnectionException,
     RemoteSqliteException,
+    SSHException,
 )
 from ttnn_visualizer.instances import get_or_create_instance
 

ttnn_visualizer/extensions.py

@@ -3,9 +3,8 @@
 # SPDX-FileCopyrightText: © 2025 Tenstorrent AI ULC
 
 from flask_socketio import SocketIO
-from flask_static_digest import FlaskStaticDigest
 from flask_sqlalchemy import SQLAlchemy
-
+from flask_static_digest import FlaskStaticDigest
 
 flask_static_digest = FlaskStaticDigest()
 # Initialize Flask SQLAlchemy

ttnn_visualizer/file_uploads.py

@@ -13,7 +13,6 @@ import time
 from pathlib import Path
 
 from flask import current_app
-
 from ttnn_visualizer.exceptions import DataFormatError
 
 logger = logging.getLogger(__name__)

ttnn_visualizer/instances.py

@@ -9,20 +9,16 @@ from logging import getLogger
 from pathlib import Path
 
 from flask import request
-
-from ttnn_visualizer.exceptions import InvalidReportPath, InvalidProfilerPath
-from ttnn_visualizer.utils import get_profiler_path, get_performance_path, get_npe_path
-from ttnn_visualizer.models import (
-    InstanceTable,
-)
+from ttnn_visualizer.exceptions import InvalidProfilerPath, InvalidReportPath
 from ttnn_visualizer.extensions import db
+from ttnn_visualizer.models import InstanceTable
+from ttnn_visualizer.utils import get_npe_path, get_performance_path, get_profiler_path
 
 logger = getLogger(__name__)
 
-from flask import jsonify, current_app
+from flask import current_app, jsonify
 from sqlalchemy.exc import IntegrityError, SQLAlchemyError
 
-
 _sentinel = object()
 
 

ttnn_visualizer/models.py

@@ -6,17 +6,14 @@ import dataclasses
 import enum
 import json
 from json import JSONDecodeError
-from typing import Optional, Any
+from typing import Any, Optional
 
 from pydantic import BaseModel, Field
-from sqlalchemy import Integer, Column, String, JSON
+from sqlalchemy import JSON, Column, Integer, String
 from sqlalchemy.ext.mutable import MutableDict
-
-from ttnn_visualizer.utils import SerializeableDataclass
 from ttnn_visualizer.enums import ConnectionTestStates
 from ttnn_visualizer.extensions import db
-
-from ttnn_visualizer.utils import parse_memory_config
+from ttnn_visualizer.utils import SerializeableDataclass, parse_memory_config
 
 
 class BufferType(enum.Enum):
@@ -172,7 +169,6 @@ class RemoteConnection(SerializeableModel):
     profilerPath: str
     performancePath: Optional[str] = None
     sqliteBinaryPath: Optional[str] = None
-    useRemoteQuerying: bool = False
 
 
 class StatusMessage(SerializeableModel):

ttnn_visualizer/queries.py

@@ -2,29 +2,26 @@
 #
 # SPDX-FileCopyrightText: © 2025 Tenstorrent AI ULC
 
-from typing import Generator, Dict, Any, Union
+import sqlite3
+from pathlib import Path
+from typing import Any, Dict, Generator, List, Optional, Union
 
-from ttnn_visualizer.exceptions import (
-    DatabaseFileNotFoundException,
-)
+from ttnn_visualizer.exceptions import DatabaseFileNotFoundException
 from ttnn_visualizer.models import (
-    Operation,
-    DeviceOperation,
     Buffer,
     BufferPage,
+    Device,
+    DeviceOperation,
+    InputTensor,
     Instance,
-    Tensor,
+    Operation,
     OperationArgument,
-    StackTrace,
-    InputTensor,
     OutputTensor,
-    Device,
     ProducersConsumers,
+    StackTrace,
+    Tensor,
     TensorComparisonRecord,
 )
-import sqlite3
-from typing import List, Optional
-from pathlib import Path
 
 
 class LocalQueryRunner:
@@ -75,11 +72,7 @@ class DatabaseQueries:
                 raise ValueError(
                     "Must provide either an existing connection or instance"
                 )
-            remote_connection = instance.remote_connection if instance else None
-            if remote_connection and remote_connection.useRemoteQuerying:
-                raise NotImplementedError("Remote querying is not implemented yet")
-            else:
-                self.query_runner = LocalQueryRunner(instance=instance)
+            self.query_runner = LocalQueryRunner(instance=instance)
 
     def _check_table_exists(self, table_name: str) -> bool:
         """

ttnn_visualizer/remote_sqlite_setup.py

@@ -8,10 +8,10 @@ import subprocess
 from ttnn_visualizer.decorators import remote_exception_handler
 from ttnn_visualizer.enums import ConnectionTestStates
 from ttnn_visualizer.exceptions import (
-    RemoteSqliteException,
-    SSHException,
     AuthenticationException,
     NoValidConnectionsError,
+    RemoteSqliteException,
+    SSHException,
 )
 from ttnn_visualizer.models import RemoteConnection
 

ttnn_visualizer/settings.py

@@ -4,8 +4,8 @@
 
 import os
 from pathlib import Path
-from dotenv import load_dotenv
 
+from dotenv import load_dotenv
 from ttnn_visualizer.utils import str_to_bool
 
 load_dotenv()

ttnn_visualizer/sftp_operations.py

@@ -5,30 +5,25 @@
 import json
 import logging
 import re
-import time
 import subprocess
+import time
 from pathlib import Path
 from stat import S_ISDIR
 from threading import Thread
 from typing import List, Optional
 
 from flask import current_app
-
 from ttnn_visualizer.decorators import remote_exception_handler
 from ttnn_visualizer.enums import ConnectionTestStates
 from ttnn_visualizer.exceptions import (
+    AuthenticationException,
     NoProjectsException,
+    NoValidConnectionsError,
     RemoteConnectionException,
     SSHException,
-    AuthenticationException,
-    NoValidConnectionsError,
 )
 from ttnn_visualizer.models import RemoteConnection, RemoteReportFolder
-from ttnn_visualizer.sockets import (
-    FileProgress,
-    FileStatus,
-    emit_file_status,
-)
+from ttnn_visualizer.sockets import FileProgress, FileStatus, emit_file_status
 from ttnn_visualizer.utils import update_last_synced
 
 logger = logging.getLogger(__name__)

ttnn_visualizer/sockets.py

@@ -9,11 +9,9 @@ from datetime import datetime
 from enum import Enum
 from logging import getLogger
 
-from flask_socketio import join_room, disconnect, leave_room
-
+from flask_socketio import disconnect, join_room, leave_room
 from ttnn_visualizer.utils import SerializeableDataclass
 
-
 logger = getLogger(__name__)
 
 

ttnn_visualizer/static/assets/{allPaths-CGmhlOs-.js → allPaths-CFKU23gh.js}

@@ -1 +1 @@
-import{I as n}from"./index-DLOviMB1.js";import{I as e}from"./index-B-fsa5Ru.js";import{p as r,I as s}from"./index-DEb3r1jy.js";function I(o,t){var a=r(o);return t===s.STANDARD?n[a]:e[a]}function p(o){return r(o)}export{n as IconSvgPaths16,e as IconSvgPaths20,I as getIconPaths,p as iconNameToPathsRecordKey};
+import{I as n}from"./index-DLOviMB1.js";import{I as e}from"./index-B-fsa5Ru.js";import{p as r,I as s}from"./index-B2fHW2_O.js";function I(o,t){var a=r(o);return t===s.STANDARD?n[a]:e[a]}function p(o){return r(o)}export{n as IconSvgPaths16,e as IconSvgPaths20,I as getIconPaths,p as iconNameToPathsRecordKey};

ttnn_visualizer/static/assets/{allPathsLoader-CH9za42_.js → allPathsLoader-CpaihUCo.js}

@@ -1,2 +1,2 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/allPaths-CGmhlOs-.js","assets/index-DLOviMB1.js","assets/index-B-fsa5Ru.js","assets/index-DEb3r1jy.js","assets/index-C-t6jBt9.css"])))=>i.map(i=>d[i]);
-import{_ as o,a as n,b as i}from"./index-DEb3r1jy.js";var _=function(e,a){return o(void 0,void 0,void 0,function(){var t;return n(this,function(r){switch(r.label){case 0:return[4,i(()=>import("./allPaths-CGmhlOs-.js"),__vite__mapDeps([0,1,2,3,4]))];case 1:return t=r.sent().getIconPaths,[2,t(e,a)]}})})};export{_ as allPathsLoader};
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/allPaths-CFKU23gh.js","assets/index-DLOviMB1.js","assets/index-B-fsa5Ru.js","assets/index-B2fHW2_O.js","assets/index-BueCaPcI.css"])))=>i.map(i=>d[i]);
+import{_ as o,a as n,b as i}from"./index-B2fHW2_O.js";var _=function(e,a){return o(void 0,void 0,void 0,function(){var t;return n(this,function(r){switch(r.label){case 0:return[4,i(()=>import("./allPaths-CFKU23gh.js"),__vite__mapDeps([0,1,2,3,4]))];case 1:return t=r.sent().getIconPaths,[2,t(e,a)]}})})};export{_ as allPathsLoader};