ttnn-visualizer 0.66.0__py3-none-any.whl → 0.67.0__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/static/assets/{allPaths-Dy4oqQPs.js → allPaths-DiBJY9fQ.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-BO1FGYnE.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-B_zDRgGR.js

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