ttnn-visualizer 0.29.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

ttnn_visualizer/app.py

@@ -154,8 +154,8 @@ def open_browser(host, port, instance_id=None):
 
 def parse_args():
     parser = argparse.ArgumentParser(description="A tool for visualizing the Tenstorrent Neural Network model (TT-NN)")
-    parser.add_argument("--report-path", type=str, help="Specify a report path", default=None)
-    parser.add_argument("--profiler-path", help="Specify a profiler path", default=None)
+    parser.add_argument("--profiler-path", type=str, help="Specify a profiler path", default=None)
+    parser.add_argument("--performance-path", help="Specify a performance path", default=None)
     return parser.parse_args()
 
 
@@ -169,13 +169,13 @@ def main():
     args = parse_args()
     instance_id = None
 
-    if args.report_path or args.profiler_path:
+    if args.profiler_path or args.performance_path:
         app = create_app()
         app.app_context().push()
         try:
             session = create_instance_from_local_paths(
-                report_path=args.report_path,
                 profiler_path=args.profiler_path,
+                performance_path=args.performance_path,
             )
         except InvalidReportPath:
             sys.exit("Invalid report path")

ttnn_visualizer/csv_queries.py

@@ -261,7 +261,6 @@ class RemoteCSVQueryRunner:
 
 class DeviceLogProfilerQueries:
     DEVICE_LOG_FILE = "profile_log_device.csv"
-    LOCAL_PROFILER_DIRECTORY = "profiler"
     DEVICE_LOG_COLUMNS = [
         "PCIe slot",
         "core_x",
@@ -309,7 +308,7 @@ class DeviceLogProfilerQueries:
             )
         else:
             self.runner = LocalCSVQueryRunner(
-                file_path=Path(self.session.profiler_path).joinpath(
+                file_path=Path(self.session.performance_path).joinpath(
                     self.DEVICE_LOG_FILE
                 ),
                 offset=1,  # Skip the first line for device log files
@@ -375,7 +374,7 @@ class DeviceLogProfilerQueries:
             and not session.remote_connection.useRemoteQuerying
         ):
             file_path = Path(
-                session.profiler_path, DeviceLogProfilerQueries.DEVICE_LOG_FILE
+                session.performance_path, DeviceLogProfilerQueries.DEVICE_LOG_FILE
             )
             with open(file_path, "r") as f:
                 return f.read()
@@ -479,11 +478,11 @@ class OpsPerformanceQueries:
 
     @staticmethod
     def get_local_ops_perf_file_path(session):
-        profiler_path = Path(session.profiler_path)
+        performance_path = Path(session.performance_path)
 
         # Find the latest file with the correct prefix
         perf_files = list(
-            profiler_path.glob(f"{OpsPerformanceQueries.PERF_RESULTS_PREFIX}_*.csv")
+            performance_path.glob(f"{OpsPerformanceQueries.PERF_RESULTS_PREFIX}_*.csv")
         )
         if not perf_files:
             raise FileNotFoundError("No performance results file found.")
@@ -544,6 +543,22 @@ class OpsPerformanceQueries:
             columns=self.PERF_RESULTS_COLUMNS, as_dict=as_dict, limit=limit
         )
 
+    def get_all_folders(directory: str) -> List[str]:
+        """
+        Get a list of all folder names in the specified directory.
+
+        :param directory: Path to the /profiles directory.
+        :return: List of folder names.
+        """
+        try:
+            return [
+                folder.name
+                for folder in Path(directory).iterdir()
+                if folder.is_dir()
+            ]
+        except Exception as e:
+            raise RuntimeError(f"Error accessing directory: {e}")
+
 
 class OpsPerformanceReportQueries:
     REPORT_COLUMNS = [

ttnn_visualizer/decorators.py

@@ -36,13 +36,6 @@ def with_session(func):
         session_query_data = get_or_create_instance(instance_id=instance_id)
         session = session_query_data.to_pydantic()
 
-        if not session.active_report:
-            current_app.logger.error(
-                f"No active report exists for instanceId {instance_id}, returning 404"
-            )
-            # Raise 404 if report_path is missing or does not exist
-            abort(404)
-
         kwargs["session"] = session
         return func(*args, **kwargs)
 

ttnn_visualizer/file_uploads.py

@@ -36,12 +36,12 @@ def validate_files(files, required_files, pattern=None):
     return True
 
 
-def extract_report_name(files):
+def extract_profiler_name(files):
     """Extract the report name from the first file."""
     if not files:
         return None
-    unsplit_report_name = str(files[0].filename)
-    return unsplit_report_name.split("/")[0]
+    unsplit_profiler_name = str(files[0].filename)
+    return unsplit_profiler_name.split("/")[0]
 
 def extract_npe_name(files):
     if not files:
@@ -54,16 +54,14 @@ def extract_npe_name(files):
 def save_uploaded_files(
     files,
     target_directory,
-    report_name=None,
+    profiler_name=None,
 ):
     """
     Save uploaded files to the target directory.
 
     :param files: List of files to be saved.
     :param target_directory: The base directory for saving the files.
-    :param report_name: The report name to use for the directory.
-    :param modify_path: Optional function to modify the file path before saving.
-    :param flat_structure: If True, saves files directly under the report_name directory without subdirectories.
+    :param profiler_name: The report name to use for the directory.
     """
     for file in files:
         current_file_name = str(file.filename)

ttnn_visualizer/models.py

@@ -168,7 +168,7 @@ class RemoteConnection(SerializeableModel):
     username: str
     host: str
     port: int = Field(ge=1, le=65535)
-    reportPath: str
+    profilerPath: str
     performancePath: Optional[str] = None
     sqliteBinaryPath: Optional[str] = None
     useRemoteQuerying: bool = False
@@ -179,9 +179,9 @@ class StatusMessage(SerializeableModel):
     message: str
 
 
-class ActiveReport(SerializeableModel):
-    report_name: Optional[str] = None
-    profile_name: Optional[str] = None
+class ActiveReports(SerializeableModel):
+    profiler_name: Optional[str] = None
+    performance_name: Optional[str] = None
     npe_name: Optional[str] = None
 
 
@@ -194,13 +194,13 @@ class RemoteReportFolder(SerializeableModel):
 
 class Instance(BaseModel):
     instance_id: str
-    report_path: Optional[str] = None
     profiler_path: Optional[str] = None
+    performance_path: Optional[str] = None
     npe_path: Optional[str] = None
-    active_report: Optional[ActiveReport] = None
+    active_report: Optional[ActiveReports] = None
     remote_connection: Optional[RemoteConnection] = None
-    remote_folder: Optional[RemoteReportFolder] = None
-    remote_profile_folder: Optional[RemoteReportFolder] = None
+    remote_profiler_folder: Optional[RemoteReportFolder] = None
+    remote_performance_folder: Optional[RemoteReportFolder] = None
 
 
 class InstanceTable(db.Model):
@@ -208,33 +208,33 @@ class InstanceTable(db.Model):
 
     id = Column(Integer, primary_key=True)
     instance_id = Column(String, unique=True, nullable=False)
-    report_path = Column(String)
-    profiler_path = Column(String, nullable=True)
+    profiler_path = Column(String)
+    performance_path = Column(String, nullable=True)
     npe_path = Column(String, nullable=True)
     active_report = db.Column(MutableDict.as_mutable(JSON), nullable=False, default={})
     remote_connection = Column(JSON, nullable=True)
-    remote_folder = Column(JSON, nullable=True)
-    remote_profile_folder = Column(JSON, nullable=True)
+    remote_profiler_folder = Column(JSON, nullable=True)
+    remote_performance_folder = Column(JSON, nullable=True)
 
     def __init__(
         self,
         instance_id,
         active_report,
         remote_connection=None,
-        remote_folder=None,
-        remote_profile_folder=None,
-        report_path=None,
+        remote_profiler_folder=None,
+        remote_performance_folder=None,
         profiler_path=None,
+        performance_path=None,
         npe_path=None,
     ):
         self.instance_id = instance_id
         self.active_report = active_report
-        self.report_path = report_path
+        self.profiler_path = profiler_path
         self.npe_path = npe_path
         self.remote_connection = remote_connection
-        self.remote_folder = remote_folder
-        self.profiler_path = profiler_path
-        self.remote_profile_folder = remote_profile_folder
+        self.remote_profiler_folder = remote_profiler_folder
+        self.performance_path = performance_path
+        self.remote_performance_folder = remote_performance_folder
 
     def to_dict(self):
         return {
@@ -242,25 +242,25 @@ class InstanceTable(db.Model):
             "instance_id": self.instance_id,
             "active_report": self.active_report,
             "remote_connection": self.remote_connection,
-            "remote_folder": self.remote_folder,
-            "remote_profile_folder": self.remote_profile_folder,
-            "report_path": self.report_path,
+            "remote_profiler_folder": self.remote_profiler_folder,
+            "remote_performance_folder": self.remote_performance_folder,
             "profiler_path": self.profiler_path,
+            "performance_path": self.performance_path,
             "npe_path": self.npe_path
         }
 
     def to_pydantic(self) -> Instance:
         return Instance(
             instance_id=str(self.instance_id),
-            report_path=str(self.report_path) if self.report_path is not None else None,
-            profiler_path=(
-                str(self.profiler_path) if self.profiler_path is not None else None
+            profiler_path=str(self.profiler_path) if self.profiler_path is not None else None,
+            performance_path=(
+                str(self.performance_path) if self.performance_path is not None else None
             ),
             npe_path=(
                 str(self.npe_path) if self.npe_path is not None else None
             ),
             active_report=(
-                (ActiveReport(**self.active_report) if self.active_report else None)
+                (ActiveReports(**self.active_report) if self.active_report else None)
                 if isinstance(self.active_report, dict)
                 else None
             ),
@@ -269,16 +269,16 @@ class InstanceTable(db.Model):
                 if self.remote_connection is not None
                 else None
             ),
-            remote_folder=(
-                RemoteReportFolder.model_validate(self.remote_folder, strict=False)
-                if self.remote_folder is not None
+            remote_profiler_folder=(
+                RemoteReportFolder.model_validate(self.remote_profiler_folder, strict=False)
+                if self.remote_profiler_folder is not None
                 else None
             ),
-            remote_profile_folder=(
+            remote_performance_folder=(
                 RemoteReportFolder.model_validate(
-                    self.remote_profile_folder, strict=False
+                    self.remote_performance_folder, strict=False
                 )
-                if self.remote_profile_folder is not None
+                if self.remote_performance_folder is not None
                 else None
             ),
         )

ttnn_visualizer/queries.py

@@ -36,15 +36,15 @@ class LocalQueryRunner:
         if connection:
             self.connection = connection
         else:
-            if not session or not session.report_path:
+            if not session or not session.profiler_path:
                 raise ValueError("Report path must be provided for local queries")
-            db_path = str(session.report_path)
+            db_path = str(session.profiler_path)
             if not Path(db_path).exists():
                 raise DatabaseFileNotFoundException(
                     f"Database not found at path: {db_path}"
                 )
             self.connection = sqlite3.connect(
-                session.report_path, isolation_level=None, timeout=30
+                session.profiler_path, isolation_level=None, timeout=30
             )
 
     def execute_query(self, query: str, params: Optional[List] = None) -> List:
@@ -72,7 +72,7 @@ class RemoteQueryRunner:
         self.ssh_client = self._get_ssh_client(self.session.remote_connection)
         self.sqlite_binary = self.session.remote_connection.sqliteBinaryPath
         self.remote_db_path = str(
-            Path(self.session.remote_folder.remotePath, "db.sqlite")
+            Path(self.session.remote_profiler_folder.remotePath, "db.sqlite")
         )
 
     def _validate_session(self):
@@ -82,8 +82,8 @@ class RemoteQueryRunner:
         if (
             not self.session.remote_connection
             or not self.session.remote_connection.sqliteBinaryPath
-            or not self.session.remote_folder
-            or not self.session.remote_folder.remotePath
+            or not self.session.remote_profiler_folder
+            or not self.session.remote_profiler_folder.remotePath
         ):
             raise ValueError(
                 "Remote connections require remote path and sqliteBinaryPath"

ttnn_visualizer/sessions.py

@@ -11,7 +11,7 @@ from pathlib import Path
 from flask import request
 
 from ttnn_visualizer.exceptions import InvalidReportPath, InvalidProfilerPath
-from ttnn_visualizer.utils import get_report_path, get_profiler_path, get_npe_path
+from ttnn_visualizer.utils import get_profiler_path, get_performance_path, get_npe_path
 from ttnn_visualizer.models import (
     InstanceTable,
 )
@@ -25,31 +25,40 @@ from sqlalchemy.exc import SQLAlchemyError
 
 def update_existing_instance(
     session_data,
-    report_name,
-    profile_name,
+    profiler_name,
+    performance_name,
     npe_name,
     remote_connection,
-    remote_folder,
-    remote_profile_folder,
+    remote_profiler_folder,
+    remote_performance_folder,
     clear_remote,
 ):
     active_report = session_data.active_report or {}
 
-    if report_name:
-        active_report["report_name"] = report_name
-    if profile_name:
-        active_report["profile_name"] = profile_name
-    if npe_name:
+    # First ifs are explicit deletes and elifs are updates
+    if profiler_name == "":
+        active_report.pop("profiler_name", None)
+    elif profiler_name is not None:
+        active_report["profiler_name"] = profiler_name
+
+    if performance_name == "":
+        active_report.pop("performance_name", None)
+    elif performance_name is not None:
+
+        active_report["performance_name"] = performance_name
+    if npe_name == "":
+        active_report.pop("npe_name", None)
+    elif npe_name is not None:
         active_report["npe_name"] = npe_name
 
     session_data.active_report = active_report
 
     if remote_connection:
         session_data.remote_connection = remote_connection.model_dump()
-    if remote_folder:
-        session_data.remote_folder = remote_folder.model_dump()
-    if remote_profile_folder:
-        session_data.remote_profile_folder = remote_profile_folder.model_dump()
+    if remote_profiler_folder:
+        session_data.remote_profiler_folder = remote_profiler_folder.model_dump()
+    if remote_performance_folder:
+        session_data.remote_performance_folder = remote_performance_folder.model_dump()
 
     if clear_remote:
         clear_remote_data(session_data)
@@ -61,8 +70,8 @@ def update_existing_instance(
 
 def clear_remote_data(session_data):
     session_data.remote_connection = None
-    session_data.remote_folder = None
-    session_data.remote_profile_folder = None
+    session_data.remote_profiler_folder = None
+    session_data.remote_performance_folder = None
 
 
 def handle_sqlalchemy_error(error):
@@ -82,16 +91,16 @@ def commit_and_log_session(session_data, instance_id):
 def update_paths(
     session_data, active_report, remote_connection
 ):
-    if active_report.get("profile_name"):
-        session_data.profiler_path = get_profiler_path(
-            profile_name=active_report["profile_name"],
+    if active_report.get("performance_name"):
+        session_data.performance_path = get_performance_path(
+            performance_name=active_report["performance_name"],
             current_app=current_app,
             remote_connection=remote_connection,
         )
 
-    if active_report.get("report_name"):
-        session_data.report_path = get_report_path(
-            active_report=active_report,
+    if active_report.get("profiler_name"):
+        session_data.profiler_path = get_profiler_path(
+            profiler_name=active_report["profiler_name"],
             current_app=current_app,
             remote_connection=remote_connection,
         )
@@ -105,41 +114,41 @@ def update_paths(
 
 def create_new_instance(
     instance_id,
-    report_name,
-    profile_name,
+    profiler_name,
+    performance_name,
     npe_name,
     remote_connection,
-    remote_folder,
-    remote_profile_folder,
+    remote_profiler_folder,
+    remote_performance_folder,
     clear_remote,
 ):
     active_report = {}
-    if report_name:
-        active_report["report_name"] = report_name
-    if profile_name:
-        active_report["profile_name"] = profile_name
+    if profiler_name:
+        active_report["profiler_name"] = profiler_name
+    if performance_name:
+        active_report["performance_name"] = performance_name
     if npe_name:
         active_report["npe_name"] = npe_name
 
     if clear_remote:
         remote_connection = None
-        remote_folder = None
-        remote_profile_folder = None
+        remote_profiler_folder = None
+        remote_performance_folder = None
 
     session_data = InstanceTable(
         instance_id=instance_id,
         active_report=active_report,
-        report_path=get_report_path(
-            active_report,
+        profiler_path=get_profiler_path(
+            active_report["profiler_name"],
             current_app=current_app,
             remote_connection=remote_connection,
         ),
         remote_connection=(
             remote_connection.model_dump() if remote_connection else None
         ),
-        remote_folder=remote_folder.model_dump() if remote_folder else None,
-        remote_profile_folder=(
-            remote_profile_folder.model_dump() if remote_profile_folder else None
+        remote_profiler_folder=remote_profiler_folder.model_dump() if remote_profiler_folder else None,
+        remote_performance_folder=(
+            remote_performance_folder.model_dump() if remote_performance_folder else None
         ),
     )
     db.session.add(session_data)
@@ -148,12 +157,12 @@ def create_new_instance(
 
 def update_instance(
     instance_id,
-    report_name=None,
-    profile_name=None,
+    profiler_name=None,
+    performance_name=None,
     npe_name=None,
     remote_connection=None,
-    remote_folder=None,
-    remote_profile_folder=None,
+    remote_profiler_folder=None,
+    remote_performance_folder=None,
     clear_remote=False,
 ):
     try:
@@ -162,23 +171,23 @@ def update_instance(
         if session_data:
             update_existing_instance(
                 session_data,
-                report_name,
-                profile_name,
+                profiler_name,
+                performance_name,
                 npe_name,
                 remote_connection,
-                remote_folder,
-                remote_profile_folder,
+                remote_profiler_folder,
+                remote_performance_folder,
                 clear_remote,
             )
         else:
             session_data = create_new_instance(
                 instance_id,
-                report_name,
-                profile_name,
+                profiler_name,
+                performance_name,
                 npe_name,
                 remote_connection,
-                remote_folder,
-                remote_profile_folder,
+                remote_profiler_folder,
+                remote_performance_folder,
                 clear_remote,
             )
 
@@ -192,11 +201,11 @@ def update_instance(
 
 def get_or_create_instance(
     instance_id,
-    report_name=None,
-    profile_name=None,
+    profiler_name=None,
+    performance_name=None,
     npe_name=None,
     remote_connection=None,
-    remote_folder=None,
+    remote_profiler_folder=None,
 ):
     """
     Retrieve an existing tab session or create a new one if it doesn't exist.
@@ -212,20 +221,20 @@ def get_or_create_instance(
                 instance_id=instance_id,
                 active_report={},
                 remote_connection=None,
-                remote_folder=None,
+                remote_profiler_folder=None,
             )
             db.session.add(session_data)
             db.session.commit()
 
         # Update the session if any new data is provided
-        if report_name or profile_name or npe_name or remote_connection or remote_folder:
+        if profiler_name or performance_name or npe_name or remote_connection or remote_profiler_folder:
             update_instance(
                 instance_id=instance_id,
-                report_name=report_name,
-                profile_name=profile_name,
+                profiler_name=profiler_name,
+                performance_name=performance_name,
                 npe_name=npe_name,
                 remote_connection=remote_connection,
-                remote_folder=remote_folder,
+                remote_profiler_folder=remote_profiler_folder,
             )
 
         # Query again to get the updated session data
@@ -270,30 +279,30 @@ def create_random_instance_id():
     return ''.join(random.choices(string.ascii_lowercase + string.digits, k=10))
 
 
-def create_instance_from_local_paths(report_path, profiler_path):
-    _report_path = Path(report_path) if report_path else None
+def create_instance_from_local_paths(profiler_path, performance_path):
     _profiler_path = Path(profiler_path) if profiler_path else None
+    _performance_path = Path(performance_path) if performance_path else None
 
-    if _report_path and (not _report_path.exists() or not _report_path.is_dir()):
+    if _profiler_path and (not _profiler_path.exists() or not _profiler_path.is_dir()):
         raise InvalidReportPath()
 
-    if _profiler_path and (not _profiler_path.exists() or not _profiler_path.is_dir()):
+    if _performance_path and (not _performance_path.exists() or not _performance_path.is_dir()):
         raise InvalidProfilerPath()
 
-    report_name = _report_path.parts[-1] if _report_path and len(_report_path.parts) > 2 else ""
-    profile_name = _profiler_path.parts[-1] if _profiler_path and len(_profiler_path.parts) > 2 else ""
+    profiler_name = _profiler_path.parts[-1] if _profiler_path and len(_profiler_path.parts) > 2 else ""
+    performance_name = _performance_path.parts[-1] if _performance_path and len(_performance_path.parts) > 2 else ""
     session_data = InstanceTable(
         instance_id=create_random_instance_id(),
         active_report={
-            "report_name": report_name,
-            "profile_name": profile_name,
+            "profiler_name": profiler_name,
+            "performance_name": performance_name,
             "npe_name": None,
         },
-        report_path=f"{_report_path}/db.sqlite" if report_path else None,
-        profiler_path=profiler_path if profiler_path else None,
+        profiler_path=f"{_profiler_path}/db.sqlite" if profiler_path else None,
+        performance_path=performance_path if performance_path else None,
         remote_connection=None,
-        remote_folder=None,
-        remote_profile_folder=None,
+        remote_profiler_folder=None,
+        remote_performance_folder=None,
     )
     db.session.add(session_data)
     db.session.commit()

ttnn_visualizer/settings.py

@@ -18,10 +18,13 @@ class DefaultConfig(object):
     PRINT_ENV = True
 
     # Path Settings
+    DB_VERSION = "0.29.0"  # App version when DB schema last changed
     REPORT_DATA_DIRECTORY = Path(__file__).parent.absolute().joinpath("data")
-    DB_VERSION = "0.26.0"  # App version when DB schema last changed
     LOCAL_DATA_DIRECTORY = Path(REPORT_DATA_DIRECTORY).joinpath("local")
     REMOTE_DATA_DIRECTORY = Path(REPORT_DATA_DIRECTORY).joinpath("remote")
+    PROFILER_DIRECTORY_NAME = "profiler-reports"
+    PERFORMANCE_DIRECTORY_NAME = "performance-reports"
+    NPE_DIRECTORY_NAME = "npe-reports"
     APPLICATION_DIR = os.path.abspath(os.path.join(__file__, "..", os.pardir))
     STATIC_ASSETS_DIR = Path(APPLICATION_DIR).joinpath("ttnn_visualizer", "static")
     SEND_FILE_MAX_AGE_DEFAULT = 0