ttnn-visualizer 0.66.0__py3-none-any.whl → 0.67.2__py3-none-any.whl

ttnn_visualizer/app.py

@@ -9,10 +9,13 @@ import os
 import subprocess
 import sys
 import threading
+import time
 import webbrowser
 from os import environ
 from pathlib import Path
 from typing import cast
+from urllib.error import URLError
+from urllib.request import urlopen
 
 import flask
 from dotenv import load_dotenv
@@ -172,14 +175,33 @@ def open_browser(host, port, instance_id=None):
     if instance_id:
         url = f"{url}?instanceId={instance_id}"
 
-    print(f"Launching browser with url: {url}")
-    try:
-        if os.name == "posix" and "DISPLAY" in os.environ:  # Checks for non-headless
-            subprocess.run(["xdg-open", url], check=True)
-        else:
-            webbrowser.open(url)
-    except webbrowser.Error as e:
-        print(f"Could not open the default browser: {e}")
+    max_attempts = 10
+    attempt = 0
+    server_ready = False
+
+    print(f"Waiting for server to be ready at {url}...")
+    while attempt < max_attempts and not server_ready:
+        try:
+            urlopen(url, timeout=1)
+            server_ready = True
+        except (URLError, ConnectionError, OSError):
+            attempt += 1
+            time.sleep(0.5)
+
+    if not server_ready:
+        print(f"❌ Server not ready after {max_attempts} attempts.")
+    else:
+        print(f"Launching browser with url: {url}")
+
+        try:
+            if (
+                os.name == "posix" and "DISPLAY" in os.environ
+            ):  # Checks for non-headless
+                subprocess.run(["xdg-open", url], check=True)
+            else:
+                webbrowser.open(url)
+        except webbrowser.Error as e:
+            print(f"Could not open the default browser: {e}")
 
 
 def parse_args():
@@ -382,7 +404,7 @@ def main():
         flask_env = os.getenv("FLASK_ENV", "development")
         port = config.PORT if flask_env == "production" else config.DEV_SERVER_PORT
         host = config.HOST if flask_env == "production" else config.DEV_SERVER_HOST
-        threading.Timer(2, open_browser, [host, port, instance_id]).start()
+        threading.Thread(target=open_browser, args=[host, port, instance_id]).start()
     try:
         subprocess.run(gunicorn_args)
     except KeyboardInterrupt:

ttnn_visualizer/models.py

@@ -113,6 +113,7 @@ class Tensor(SerializeableDataclass):
     address: int
     buffer_type: BufferType
     device_addresses: list[int]
+    size: Optional[int] = None
 
     def __post_init__(self):
         self.memory_config = parse_memory_config(self.memory_config)

ttnn_visualizer/queries.py

@@ -185,26 +185,88 @@ class DatabaseQueries:
     def query_tensors(
         self, filters: Optional[Dict[str, Any]] = None
     ) -> Generator[Tensor, None, None]:
-        rows = self._query_table("tensors", filters)
+        # Check if device_tensors table exists
+        device_tensors_exists = self._check_table_exists("device_tensors")
+
+        # Build the base query with joins to get size and optionally device_tensors
+        if device_tensors_exists:
+            query = """
+                SELECT 
+                    t.*, 
+                    b.max_size_per_bank as size,
+                    GROUP_CONCAT(dt.device_id || ':' || dt.address, ',') as device_tensors_data
+                FROM tensors t
+                LEFT JOIN input_tensors it ON it.tensor_id = t.tensor_id
+                LEFT JOIN output_tensors ot ON ot.tensor_id = t.tensor_id
+                LEFT JOIN buffers b ON b.operation_id = COALESCE(it.operation_id, ot.operation_id)
+                    AND t.address = b.address
+                    AND t.device_id = b.device_id
+                LEFT JOIN device_tensors dt ON dt.tensor_id = t.tensor_id
+                WHERE 1=1
+            """
+        else:
+            query = """
+                SELECT 
+                    t.*, 
+                    b.max_size_per_bank as size,
+                    NULL as device_tensors_data
+                FROM tensors t
+                LEFT JOIN input_tensors it ON it.tensor_id = t.tensor_id
+                LEFT JOIN output_tensors ot ON ot.tensor_id = t.tensor_id
+                LEFT JOIN buffers b ON b.operation_id = COALESCE(it.operation_id, ot.operation_id)
+                    AND t.address = b.address
+                    AND t.device_id = b.device_id
+                WHERE 1=1
+            """
+        params = []
+
+        # Apply filters to tensors table
+        if filters:
+            for column, value in filters.items():
+                if value is None:
+                    continue
+
+                if isinstance(value, list):
+                    if len(value) == 0:
+                        continue
+                    placeholders = ", ".join(["?"] * len(value))
+                    query += f" AND t.{column} IN ({placeholders})"
+                    params.extend(value)
+                else:
+                    query += f" AND t.{column} = ?"
+                    params.append(value)
+
+        query += " GROUP BY t.tensor_id"
+
+        rows = self.query_runner.execute_query(query, params)
         for row in rows:
+            # Extract size and device_tensors_data (last two columns) and tensor data
+            tensor_row = row[:-2]  # All tensor columns
+            size = row[-2]  # size column
+            device_tensors_data = row[-1]  # device_tensors_data column
+
             device_addresses = []
 
-            try:
-                device_tensors = self._query_table(
-                    "device_tensors", filters={"tensor_id": row[0]}
-                )
-            except sqlite3.OperationalError as err:
-                if str(err).startswith("no such table"):
-                    pass
-                else:
-                    raise err
-            else:
-                for device_tensor in sorted(device_tensors, key=lambda x: x[1]):
-                    while len(device_addresses) < device_tensor[1]:
+            if device_tensors_data:
+                # Parse the concatenated device_id:address pairs
+                pairs = device_tensors_data.split(",")
+                device_tensor_list = []
+                for pair in pairs:
+                    if pair:
+                        device_id_str, address_str = pair.split(":")
+                        device_id = int(device_id_str)
+                        address = int(address_str)
+                        device_tensor_list.append((device_id, address))
+
+                # Sort by device_id and build the list with proper indexing
+                for device_id, address in sorted(
+                    device_tensor_list, key=lambda x: x[0]
+                ):
+                    while len(device_addresses) < device_id:
                         device_addresses.append(None)
-                    device_addresses.append(device_tensor[2])
+                    device_addresses.append(address)
 
-            yield Tensor(*row, device_addresses)
+            yield Tensor(*tensor_row, device_addresses, size=size)
 
     def query_input_tensors(
         self, filters: Optional[Dict[str, Any]] = None

ttnn_visualizer/sftp_operations.py

@@ -620,13 +620,21 @@ def read_remote_file(
 
 @remote_exception_handler
 def check_remote_path_for_reports(remote_connection):
-    remote_profiler_paths = find_folders_by_files(
-        remote_connection, remote_connection.profilerPath, [TEST_CONFIG_FILE]
-    )
+    remote_profiler_paths = []
+    if remote_connection.profilerPath:
+        remote_profiler_paths = find_folders_by_files(
+            remote_connection, remote_connection.profilerPath, [TEST_CONFIG_FILE]
+        )
+    else:
+        logger.info("No profiler path configured; skipping check.")
 
-    remote_performance_paths = find_folders_by_files(
-        remote_connection, remote_connection.performancePath, [TEST_PROFILER_FILE]
-    )
+    remote_performance_paths = []
+    if remote_connection.performancePath:
+        remote_performance_paths = find_folders_by_files(
+            remote_connection, remote_connection.performancePath, [TEST_PROFILER_FILE]
+        )
+    else:
+        logger.info("No performance path configured; skipping check.")
 
     errors = []
     if not remote_profiler_paths and remote_connection.profilerPath:
@@ -682,6 +690,9 @@ def find_folders_by_files(
     remote_connection: RemoteConnection, root_folder: str, file_names: List[str]
 ) -> List[str]:
     """Given a remote path, return a list of top-level folders that contain any of the specified files."""
+    if not root_folder:
+        return []
+
     matched_folders: List[str] = []
 
     # Build SSH command to find directories in root_folder
@@ -761,23 +772,28 @@ def get_remote_performance_folders(
     remote_connection: RemoteConnection,
 ) -> List[RemoteReportFolder]:
     """Return a list of remote folders containing a profile_log_device file."""
-    if remote_connection.performancePath is None:
+    performance_paths = []
+
+    if remote_connection.performancePath:
+        performance_paths = find_folders_by_files(
+            remote_connection, remote_connection.performancePath, [TEST_PROFILER_FILE]
+        )
+    else:
         error = "Performance path is not configured for this connection"
         logger.error(error)
         raise NoProjectsException(status=ConnectionTestStates.FAILED, message=error)
 
-    performance_paths = find_folders_by_files(
-        remote_connection, remote_connection.performancePath, [TEST_PROFILER_FILE]
-    )
     if not performance_paths:
-        error = f"No profiler paths found at {remote_connection.performancePath}"
+        error = f"No performance reports found at {remote_connection.performancePath}"
         logger.info(error)
         raise NoProjectsException(status=ConnectionTestStates.FAILED, message=error)
+
     remote_folder_data = []
     for path in performance_paths:
         remote_folder_data.append(
             get_remote_performance_folder(remote_connection, path)
         )
+
     return remote_folder_data
 
 
@@ -786,19 +802,24 @@ def get_remote_profiler_folders(
     remote_connection: RemoteConnection,
 ) -> List[RemoteReportFolder]:
     """Return a list of remote folders containing a config.json file."""
-    remote_config_paths = find_folders_by_files(
-        remote_connection, remote_connection.profilerPath, [TEST_CONFIG_FILE]
-    )
-    if not remote_config_paths:
-        error = f"No projects found at {remote_connection.profilerPath}"
+    remote_config_paths = []
+
+    if remote_connection.profilerPath:
+        remote_config_paths = find_folders_by_files(
+            remote_connection, remote_connection.profilerPath, [TEST_CONFIG_FILE]
+        )
+    else:
+        error = f"No profiler reports found at {remote_connection.profilerPath}"
         logger.info(error)
         raise NoProjectsException(status=ConnectionTestStates.FAILED, message=error)
+
     remote_folder_data = []
     for config_path in remote_config_paths:
         remote_folder = get_remote_profiler_folder_from_config_path(
             remote_connection, str(Path(config_path).joinpath(TEST_CONFIG_FILE))
         )
         remote_folder_data.append(remote_folder)
+
     return remote_folder_data
 
 

ttnn_visualizer/static/assets/{allPaths-Dy4oqQPs.js → allPaths-D8fLup7j.js}

@@ -1 +1 @@
-import{I as s}from"./index-voJy5fZe.js";import{I as r}from"./index-BZITDwoa.js";import{p as n,I as c}from"./index-BE4YTLKK.js";function p(t,a){const o=n(t);return a===c.STANDARD?s[o]:r[o]}export{s as IconSvgPaths16,r as IconSvgPaths20,p as getIconPaths};
+import{I as s}from"./index-voJy5fZe.js";import{I as r}from"./index-BZITDwoa.js";import{p as n,I as c}from"./index-Uz_q_wTj.js";function p(t,a){const o=n(t);return a===c.STANDARD?s[o]:r[o]}export{s as IconSvgPaths16,r as IconSvgPaths20,p as getIconPaths};

ttnn_visualizer/static/assets/allPathsLoader-ib5itfwn.js

@@ -0,0 +1,2 @@
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/allPaths-D8fLup7j.js","assets/index-voJy5fZe.js","assets/index-BZITDwoa.js","assets/index-Uz_q_wTj.js","assets/index-bdndbd_j.css"])))=>i.map(i=>d[i]);
+import{_ as e}from"./index-Uz_q_wTj.js";const s=async(t,a)=>{const{getIconPaths:o}=await e(async()=>{const{getIconPaths:r}=await import("./allPaths-D8fLup7j.js");return{getIconPaths:r}},__vite__mapDeps([0,1,2,3,4]));return o(t,a)};export{s as allPathsLoader};