ttnn-visualizer 0.49.0__py3-none-any.whl → 0.64.0__py3-none-any.whl

ttnn_visualizer/app.py

@@ -25,7 +25,7 @@ from ttnn_visualizer.exceptions import (
 )
 from ttnn_visualizer.instances import create_instance_from_local_paths
 from ttnn_visualizer.settings import Config, DefaultConfig
-from ttnn_visualizer.utils import create_path_resolver
+from ttnn_visualizer.utils import find_gunicorn_path, get_app_data_directory
 from werkzeug.debug import DebuggedApplication
 from werkzeug.middleware.proxy_fix import ProxyFix
 
@@ -55,8 +55,9 @@ def create_app(settings_override=None):
         static_folder=config.STATIC_ASSETS_DIR,
         static_url_path=f"{config.BASE_PATH}static",
     )
-    logging.basicConfig(level=app.config.get("LOG_LEVEL", "INFO"))
 
+    # logging.basicConfig(level=app.config.get("LOG_LEVEL", "DEBUG"))
+    logging.basicConfig(level=logging.DEBUG)
     app.config.from_object(config)
 
     if settings_override:
@@ -80,6 +81,7 @@ def create_app(settings_override=None):
                 "SERVER_MODE": app.config["SERVER_MODE"],
                 "BASE_PATH": app.config["BASE_PATH"],
                 "TT_METAL_HOME": app.config["TT_METAL_HOME"],
+                "REPORT_DATA_DIRECTORY": str(app.config["REPORT_DATA_DIRECTORY"]),
             }
             js = f"window.TTNN_VISUALIZER_CONFIG = {json.dumps(js_config)};"
 
@@ -114,23 +116,19 @@ def extensions(app: flask.Flask):
     :param app: Flask application instance
     :return: None
     """
-
     flask_static_digest.init_app(app)
     if app.config["USE_WEBSOCKETS"]:
         socketio.init_app(app)
+
+    Path(app.config["APP_DATA_DIRECTORY"]).mkdir(parents=True, exist_ok=True)
     db.init_app(app)
 
     if app.config["USE_WEBSOCKETS"]:
         register_handlers(socketio)
 
-    # Create the tables within the application context
     with app.app_context():
         db.create_all()
 
-    # For automatically reflecting table data
-    # with app.app_context():
-    #    db.reflect()
-
     return None
 
 
@@ -197,63 +195,151 @@ def parse_args():
     parser.add_argument(
         "--tt-metal-home", help="Specify a TT-Metal home path", default=None
     )
+    parser.add_argument(
+        "--host",
+        type=str,
+        help="Host to bind to (default: auto-detected based on environment)",
+        default=None,
+    )
+    parser.add_argument(
+        "--port",
+        type=str,
+        help="Port to bind to (default: 8000)",
+        default=None,
+    )
+    parser.add_argument(
+        "--server",
+        action="store_true",
+        help="Bind to all network interfaces (0.0.0.0) and enable server mode. Useful for servers and VMs",
+    )
+    parser.add_argument(
+        "-d",
+        "--daemon",
+        action="store_true",
+        help="Run the server as a daemon process",
+    )
     return parser.parse_args()
 
 
+def display_mode_info_without_db(config):
+    """Display mode information using only config, without initializing database."""
+    # Determine if we're in TT-Metal mode
+    tt_metal_home = config.TT_METAL_HOME
+    is_tt_metal_mode = tt_metal_home is not None
+
+    if is_tt_metal_mode:
+        print("🚀 TT-METAL MODE: Working directly with tt-metal generated directory")
+        print(f"   TT_METAL_HOME: {tt_metal_home}")
+
+        profiler_base = Path(tt_metal_home) / "generated" / "ttnn" / "reports"
+        performance_base = Path(tt_metal_home) / "generated" / "profiler" / "reports"
+
+        print(f"   Profiler reports: {profiler_base}")
+        print(f"   Performance reports: {performance_base}")
+
+        # Validate setup
+        if not Path(tt_metal_home).exists():
+            print(
+                f"   ⚠️  Warning: TT_METAL_HOME directory does not exist: {tt_metal_home}"
+            )
+        elif not (Path(tt_metal_home) / "generated").exists():
+            print(f"   ⚠️  Warning: TT-Metal generated directory not found")
+        elif not profiler_base.exists():
+            print(
+                f"   ⚠️  Warning: Profiler reports directory not found: {profiler_base}"
+            )
+        elif not performance_base.exists():
+            print(
+                f"   ⚠️  Warning: Performance reports directory not found: {performance_base}"
+            )
+        else:
+            print(f"   ✓ TT-Metal setup is valid")
+    else:
+        print(
+            "📁 UPLOAD/SYNC MODE: Using local data directory for uploaded/synced reports"
+        )
+        print(f"   Local directory: {config.LOCAL_DATA_DIRECTORY}")
+        print(f"   Remote directory: {config.REMOTE_DATA_DIRECTORY}")
+
+
 def main():
 
     run_command = sys.argv[0].split("/")
     if run_command[-1] == "ttnn-visualizer":
         os.environ.setdefault("FLASK_ENV", "production")
 
-    config = cast(DefaultConfig, Config())
     args = parse_args()
-    instance_id = None
 
-    if args.profiler_path or args.performance_path:
-        app = create_app()
-        app.app_context().push()
-        try:
-            session = create_instance_from_local_paths(
-                profiler_path=args.profiler_path,
-                performance_path=args.performance_path,
-            )
-        except InvalidReportPath:
-            sys.exit("Invalid report path")
-        except InvalidProfilerPath:
-            sys.exit("Invalid profiler path")
+    # Handle host/port CLI overrides
+    # Priority: CLI args > env vars > auto-detection (in settings.py)
+    # Note: We need to set env vars before creating Config, but also
+    # manually update the config object in case it was already instantiated
+    if args.host:
+        os.environ["HOST"] = args.host
+        print(f"🌐 Binding to host: {args.host} (from --host flag)")
+    elif args.server:
+        os.environ["HOST"] = "0.0.0.0"
+        os.environ["SERVER_MODE"] = "true"
+        print("🌐 Binding to all interfaces (0.0.0.0) via --server flag")
+        print("🖥️  Server mode enabled")
+
+    if args.port:
+        os.environ["PORT"] = args.port
+        print(f"🔌 Binding to port: {args.port}")
+
+    config = cast(DefaultConfig, Config())
+
+    # Apply CLI overrides directly to config object
+    # (Config is a singleton that may have been created before we set env vars)
+    if args.host:
+        config.HOST = args.host
+    elif args.server:
+        config.HOST = "0.0.0.0"
+        config.SERVER_MODE = True
 
-        instance_id = session.instance_id
+    if args.port:
+        config.PORT = args.port
 
+    # Recalculate GUNICORN_BIND with the updated values
+    config.GUNICORN_BIND = f"{config.HOST}:{config.PORT}"
+
+    instance_id = None
+
+    # Display mode information first (using config only, no DB needed)
     if args.tt_metal_home:
+        os.environ["TT_METAL_HOME"] = args.tt_metal_home
         config.TT_METAL_HOME = args.tt_metal_home
 
-    # Display mode information
-    app = create_app()
-    with app.app_context():
-        resolver = create_path_resolver(app)
-        mode_info = resolver.get_mode_info()
-
-        if mode_info["mode"] == "tt_metal":
-            print(
-                "🚀 TT-METAL MODE: Working directly with tt-metal generated directory"
+        if not os.getenv("APP_DATA_DIRECTORY"):
+            config.APP_DATA_DIRECTORY = get_app_data_directory(
+                args.tt_metal_home, config.APPLICATION_DIR
             )
-            print(f"   TT_METAL_HOME: {mode_info['tt_metal_home']}")
-            print(f"   Profiler reports: {mode_info['profiler_base']}")
-            print(f"   Performance reports: {mode_info['performance_base']}")
-
-            # Validate setup
-            is_valid, message = resolver.validate_tt_metal_setup()
-            if is_valid:
-                print(f"   ✓ {message}")
-            else:
-                print(f"   ⚠️  Warning: {message}")
-        else:
-            print(
-                "📁 UPLOAD/SYNC MODE: Using local data directory for uploaded/synced reports"
+            # Recalculate database path with new APP_DATA_DIRECTORY
+            _db_file_path = str(
+                Path(config.APP_DATA_DIRECTORY) / f"ttnn_{config.DB_VERSION}.db"
             )
-            print(f"   Local directory: {mode_info['local_dir']}")
-            print(f"   Remote directory: {mode_info['remote_dir']}")
+            config.SQLALCHEMY_DATABASE_URI = f"sqlite:///{_db_file_path}"
+
+    display_mode_info_without_db(config)
+
+    # If profiler/performance paths are provided, create an instance
+    # This requires DB access, so we create the app temporarily
+    if args.profiler_path or args.performance_path:
+        app = create_app()
+        with app.app_context():
+            try:
+                session = create_instance_from_local_paths(
+                    profiler_path=args.profiler_path,
+                    performance_path=args.performance_path,
+                )
+                instance_id = session.instance_id
+            except InvalidReportPath:
+                sys.exit("Invalid report path")
+            except InvalidProfilerPath:
+                sys.exit("Invalid profiler path")
+
+        # Clean up this temporary app - workers will create their own
+        del app
 
     # Check if DEBUG environment variable is set
     debug_mode = os.environ.get("DEBUG", "false").lower() == "true"
@@ -262,8 +348,21 @@ def main():
         for key, value in config.to_dict().items():
             print(f"{key}={value}")
 
+    # Warn if there's a gunicorn config file in current directory
+    if Path("gunicorn.conf.py").exists():
+        logger.warning(
+            "Found gunicorn.conf.py in current directory - this may override environment settings"
+        )
+
+    gunicorn_cmd, gunicorn_warning = find_gunicorn_path()
+
+    if gunicorn_warning:
+        print(gunicorn_warning)
+
     gunicorn_args = [
-        "gunicorn",
+        gunicorn_cmd,
+        "-t",
+        config.GUNICORN_TIMEOUT,
         "-k",
         config.GUNICORN_WORKER_CLASS,
         "-w",
@@ -276,7 +375,10 @@ def main():
     if debug_mode:
         gunicorn_args.insert(1, "--reload")
 
-    if config.LAUNCH_BROWSER_ON_START:
+    if args.daemon:
+        gunicorn_args.insert(1, "--daemon")
+
+    if config.LAUNCH_BROWSER_ON_START and not args.daemon:
         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

ttnn_visualizer/csv_queries.py

@@ -4,6 +4,7 @@
 
 import csv
 import json
+import logging
 import os
 import tempfile
 from io import StringIO
@@ -14,7 +15,9 @@ import pandas as pd
 import zstd
 from tt_perf_report import perf_report
 from ttnn_visualizer.exceptions import DataFormatError
-from ttnn_visualizer.models import Instance, RemoteConnection
+from ttnn_visualizer.models import Instance
+
+logger = logging.getLogger(__name__)
 
 
 class LocalCSVQueryRunner:
@@ -100,7 +103,6 @@ class NPEQueries:
 
     @staticmethod
     def get_npe_manifest(instance: Instance):
-
         file_path = Path(
             instance.performance_path,
             NPEQueries.NPE_FOLDER,
@@ -417,34 +419,71 @@ class OpsPerformanceReportQueries:
         "raw_op_code",
     ]
 
+    STACKED_REPORT_COLUMNS = [
+        "percent",
+        "op_code",
+        "device_time_sum_us",
+        "ops_count",
+        "flops_min",
+        "flops_max",
+        "flops_mean",
+        "flops_std",
+    ]
+
     PASSTHROUGH_COLUMNS = {
         "pm_ideal_ns": "PM IDEAL [ns]",
     }
 
-    DEFAULT_SIGNPOST = None
-    DEFAULT_IGNORE_SIGNPOSTS = None
+    DEFAULT_START_SIGNPOST = None
+    DEFAULT_END_SIGNPOST = None
+    DEFAULT_IGNORE_SIGNPOSTS = True
     DEFAULT_MIN_PERCENTAGE = 0.5
     DEFAULT_ID_RANGE = None
     DEFAULT_NO_ADVICE = False
     DEFAULT_TRACING_MODE = False
+    DEFAULT_RAW_OP_CODES = True
+    DEFAULT_NO_HOST_OPS = False
+    DEFAULT_NO_STACKED_REPORT = False
+    DEFAULT_NO_STACK_BY_IN0 = True
 
     @classmethod
-    def generate_report(cls, instance):
+    def generate_report(cls, instance, **kwargs):
         raw_csv = OpsPerformanceQueries.get_raw_csv(instance)
         csv_file = StringIO(raw_csv)
         csv_output_file = tempfile.mktemp(suffix=".csv")
-        perf_report.generate_perf_report(
-            csv_file,
-            cls.DEFAULT_SIGNPOST,
-            cls.DEFAULT_IGNORE_SIGNPOSTS,
-            cls.DEFAULT_MIN_PERCENTAGE,
-            cls.DEFAULT_ID_RANGE,
-            csv_output_file,
-            cls.DEFAULT_NO_ADVICE,
-            cls.DEFAULT_TRACING_MODE,
-            True,
-            True,
-        )
+        csv_stacked_output_file = tempfile.mktemp(suffix=".csv")
+        start_signpost = kwargs.get("start_signpost", cls.DEFAULT_START_SIGNPOST)
+        end_signpost = kwargs.get("end_signpost", cls.DEFAULT_END_SIGNPOST)
+        ignore_signposts = cls.DEFAULT_IGNORE_SIGNPOSTS
+        stack_by_in0 = kwargs.get("stack_by_in0", cls.DEFAULT_NO_STACK_BY_IN0)
+        no_host_ops = kwargs.get("hide_host_ops", cls.DEFAULT_NO_HOST_OPS)
+
+        if start_signpost or end_signpost:
+            ignore_signposts = False
+
+        # perf_report currently generates a PNG alongside the CSV using the same temp name - we'll just delete it afterwards
+        stacked_png_file = os.path.splitext(csv_output_file)[0] + ".png"
+
+        try:
+            perf_report.generate_perf_report(
+                [csv_file],
+                start_signpost,
+                end_signpost,
+                ignore_signposts,
+                cls.DEFAULT_MIN_PERCENTAGE,
+                cls.DEFAULT_ID_RANGE,
+                csv_output_file,
+                cls.DEFAULT_NO_ADVICE,
+                cls.DEFAULT_TRACING_MODE,
+                cls.DEFAULT_RAW_OP_CODES,
+                no_host_ops,
+                cls.DEFAULT_NO_STACKED_REPORT,
+                stack_by_in0,
+                csv_stacked_output_file,
+            )
+        except Exception as e:
+            logger.error(f"Error generating performance report: {e}")
+            raise DataFormatError(f"Error generating performance report: {e}") from e
 
         ops_perf_results = []
         ops_perf_results_reader = csv.DictReader(StringIO(raw_csv))
@@ -452,34 +491,104 @@ class OpsPerformanceReportQueries:
         for row in ops_perf_results_reader:
             ops_perf_results.append(row)
 
+        # Returns a list of unique signposts in the order they appear
+        # TODO: Signpost names are not unique but tt-perf-report treats them as such
+        captured_signposts = set()
+        signposts = []
+        for index, row in enumerate(ops_perf_results):
+            if row.get("OP TYPE") == "signpost":
+                op_code = row["OP CODE"]
+                op_id = index + 2  # Match IDs with row numbers in ops perf results csv
+                if not any(s["op_code"] == op_code for s in signposts):
+                    captured_signposts.add(op_code)
+                    signposts.append(
+                        {
+                            "id": op_id,
+                            "op_code": op_code,
+                        }
+                    )
+
         report = []
 
-        try:
-            with open(csv_output_file, newline="") as csvfile:
-                reader = csv.reader(csvfile, delimiter=",")
-                next(reader, None)
-                for row in reader:
-                    processed_row = {
-                        column: row[index]
-                        for index, column in enumerate(cls.REPORT_COLUMNS)
-                        if index < len(row)
-                    }
-                    if "advice" in processed_row and processed_row["advice"]:
-                        processed_row["advice"] = processed_row["advice"].split(" • ")
-                    else:
-                        processed_row["advice"] = []
-
-                    for key, value in cls.PASSTHROUGH_COLUMNS.items():
+        if os.path.exists(csv_output_file):
+            try:
+                with open(csv_output_file, newline="") as csvfile:
+                    reader = csv.reader(csvfile, delimiter=",")
+                    next(reader, None)
+                    for row in reader:
                         op_id = int(row[0])
-                        idx = (
-                            op_id - 2
-                        )  # IDs in result column one correspond to row numbers in ops perf results csv
-                        processed_row[key] = ops_perf_results[idx][value]
-
-                    report.append(processed_row)
-        except csv.Error as e:
-            raise DataFormatError() from e
-        finally:
-            os.unlink(csv_output_file)
-
-        return report
+                        # IDs in result column one correspond to row numbers in ops perf results csv
+                        idx = op_id - 2
+
+                        processed_row = {
+                            column: row[index]
+                            for index, column in enumerate(cls.REPORT_COLUMNS)
+                            if index < len(row)
+                        }
+
+                        if "advice" in processed_row and processed_row["advice"]:
+                            processed_row["advice"] = processed_row["advice"].split(
+                                " • "
+                            )
+                        else:
+                            processed_row["advice"] = []
+
+                        for key, value in cls.PASSTHROUGH_COLUMNS.items():
+                            if 0 <= idx < len(ops_perf_results):
+
+                                processed_row[key] = ops_perf_results[idx][value]
+                            else:
+                                processed_row[key] = None
+
+                        # Get the op type from the raw file for this row as it is not returned from tt-perf-report
+                        if 0 <= idx < len(ops_perf_results):
+                            processed_row["op_type"] = ops_perf_results[idx].get(
+                                "OP TYPE"
+                            )
+                        else:
+                            processed_row["op_type"] = None
+
+                        report.append(processed_row)
+            except csv.Error as e:
+                raise DataFormatError() from e
+            finally:
+                os.unlink(csv_output_file)
+
+        stacked_report = []
+
+        if os.path.exists(csv_stacked_output_file):
+            try:
+                with open(csv_stacked_output_file, newline="") as csvfile:
+                    reader = csv.reader(csvfile, delimiter=",")
+                    next(reader, None)
+
+                    for row in reader:
+                        processed_row = {
+                            column: row[index]
+                            for index, column in enumerate(cls.STACKED_REPORT_COLUMNS)
+                            if index < len(row)
+                        }
+
+                        if "op_code" in processed_row and any(
+                            processed_row["op_code"] in signpost["op_code"]
+                            for signpost in signposts
+                        ):
+                            processed_row["op_type"] = "signpost"
+                        else:
+                            processed_row["op_type"] = "unknown"
+
+                        stacked_report.append(processed_row)
+            except csv.Error as e:
+                raise DataFormatError() from e
+            finally:
+                os.unlink(csv_stacked_output_file)
+                if os.path.exists(stacked_png_file):
+                    os.unlink(stacked_png_file)
+
+                    stacked_report.append(processed_row)
+
+        return {
+            "report": report,
+            "stacked_report": stacked_report,
+            "signposts": signposts,
+        }

ttnn_visualizer/decorators.py

@@ -14,7 +14,6 @@ from ttnn_visualizer.exceptions import (
     NoProjectsException,
     NoValidConnectionsError,
     RemoteConnectionException,
-    RemoteSqliteException,
     SSHException,
 )
 from ttnn_visualizer.instances import get_or_create_instance
@@ -115,14 +114,6 @@ def remote_exception_handler(func):
                 message=user_message,
             )
 
-        except RemoteSqliteException as err:
-            current_app.logger.error(f"Remote Sqlite exception: {str(err)}")
-            message = err.message
-            if "No such file" in str(err):
-                message = "Unable to open SQLite binary, check path"
-            raise RemoteConnectionException(
-                status=ConnectionTestStates.FAILED, message=message
-            )
         except IOError as err:
             message = f"Error opening remote folder: {str(err)}"
             if "Name or service not known" in str(err):

ttnn_visualizer/exceptions.py

@@ -56,13 +56,6 @@ class NoProjectsException(RemoteConnectionException):
     pass
 
 
-class RemoteSqliteException(Exception):
-    def __init__(self, message, status):
-        super().__init__(message)
-        self.message = message
-        self.status = status
-
-
 class DatabaseFileNotFoundException(Exception):
     pass
 

ttnn_visualizer/models.py

@@ -154,6 +154,26 @@ class StackTrace(SerializeableDataclass):
     stack_trace: str
 
 
+@dataclasses.dataclass
+class ErrorRecord(SerializeableDataclass):
+    operation_id: int
+    operation_name: str
+    error_type: str
+    error_message: str
+    stack_trace: str
+    timestamp: str
+
+    def to_nested_dict(self) -> dict:
+        """
+        Returns a dictionary representation without operation_id and operation_name.
+        Use this when the error is nested under an operation to avoid redundancy.
+        """
+        result = self.to_dict()
+        result.pop("operation_id", None)
+        result.pop("operation_name", None)
+        return result
+
+
 # Non Data Models
 
 
@@ -169,7 +189,6 @@ class RemoteConnection(SerializeableModel):
     port: int = Field(ge=1, le=65535)
     profilerPath: str
     performancePath: Optional[str] = None
-    sqliteBinaryPath: Optional[str] = None
 
 
 class StatusMessage(SerializeableModel):

ttnn_visualizer/queries.py

@@ -12,6 +12,7 @@ from ttnn_visualizer.models import (
     BufferPage,
     Device,
     DeviceOperation,
+    ErrorRecord,
     InputTensor,
     Instance,
     Operation,
@@ -156,6 +157,13 @@ class DatabaseQueries:
             operation_id, stack_trace = row
             yield StackTrace(operation_id, stack_trace=stack_trace)
 
+    def query_error_records(
+        self, filters: Optional[Dict[str, Any]] = None
+    ) -> Generator[ErrorRecord, None, None]:
+        rows = self._query_table("errors", filters)
+        for row in rows:
+            yield ErrorRecord(*row)
+
     def query_tensor_comparisons(
         self, local: bool = True, filters: Optional[Dict[str, Any]] = None
     ) -> Generator[TensorComparisonRecord, None, None]: