Upload folder using huggingface_hub

CHANGELOG.md

@@ -1,5 +1,40 @@
 # trackio
 
+## 0.10.0
+
+### Features
+
+- [#305](https://github.com/gradio-app/trackio/pull/305) [`e64883a`](https://github.com/gradio-app/trackio/commit/e64883a51f7b8b93f7d48b8afe55acdb62238b71) - bump to gradio 6.0, make `trackio` compatible, and fix related issues.  Thanks @abidlabs!
+
+## 0.9.1
+
+### Features
+
+- [#344](https://github.com/gradio-app/trackio/pull/344) [`7e01024`](https://github.com/gradio-app/trackio/commit/7e010241d9a34794e0ce0dc19c1a6f0cf94ba856) - Avoid redundant calls to /whoami-v2.  Thanks @Wauplin!
+
+## 0.9.0
+
+### Features
+
+- [#343](https://github.com/gradio-app/trackio/pull/343) [`51bea30`](https://github.com/gradio-app/trackio/commit/51bea30f2877adff8e6497466d3a799400a0a049) - Sync offline projects to Hugging Face spaces.  Thanks @candemircan!
+- [#341](https://github.com/gradio-app/trackio/pull/341) [`4fd841f`](https://github.com/gradio-app/trackio/commit/4fd841fa190e15071b02f6fba7683ef4f393a654) - Adds a basic UI test to `trackio`.  Thanks @abidlabs!
+- [#339](https://github.com/gradio-app/trackio/pull/339) [`011d91b`](https://github.com/gradio-app/trackio/commit/011d91bb6ae266516fd250a349285670a8049d05) - Allow customzing the trackio color palette.  Thanks @abidlabs!
+
+## 0.8.1
+
+### Features
+
+- [#336](https://github.com/gradio-app/trackio/pull/336) [`5f9f51d`](https://github.com/gradio-app/trackio/commit/5f9f51dac8677f240d7c42c3e3b2660a22aee138) - Support a list of `Trackio.Image` in a `trackio.Table` cell.  Thanks @abidlabs!
+
+## 0.8.0
+
+### Features
+
+- [#331](https://github.com/gradio-app/trackio/pull/331) [`2c02d0f`](https://github.com/gradio-app/trackio/commit/2c02d0fd0a5824160528782402bb0dd4083396d5) - Truncate table string values that are greater than 250 characters (configuirable via env variable).  Thanks @abidlabs!
+- [#324](https://github.com/gradio-app/trackio/pull/324) [`50b2122`](https://github.com/gradio-app/trackio/commit/50b2122e7965ac82a72e6cb3b7d048bc10a2a6b1) - Add log y-axis functionality to UI.  Thanks @abidlabs!
+- [#326](https://github.com/gradio-app/trackio/pull/326) [`61dc1f4`](https://github.com/gradio-app/trackio/commit/61dc1f40af2f545f8e70395ddf0dbb8aee6b60d5) - Fix: improve table rendering for metrics in Trackio Dashboard.  Thanks @vigneshwaran!
+- [#328](https://github.com/gradio-app/trackio/pull/328) [`6857cbb`](https://github.com/gradio-app/trackio/commit/6857cbbe557a59a4642f210ec42566d108294e63) - Support trackio.Table with trackio.Image columns.  Thanks @abidlabs!
+
 ## 0.7.0
 
 ### Features

__init__.py

@@ -1,4 +1,3 @@
-import hashlib
 import json
 import logging
 import os
@@ -7,20 +6,20 @@ import webbrowser
 from pathlib import Path
 from typing import Any
 
-from gradio.blocks import BUILT_IN_THEMES
-from gradio.themes import Default as DefaultTheme
 from gradio.themes import ThemeClass
+from gradio.utils import TupleNoPrint
 from gradio_client import Client
 from huggingface_hub import SpaceStorage
 
 from trackio import context_vars, deploy, utils
+from trackio.deploy import sync
 from trackio.histogram import Histogram
 from trackio.imports import import_csv, import_tf_events
 from trackio.media import TrackioAudio, TrackioImage, TrackioVideo
 from trackio.run import Run
 from trackio.sqlite_storage import SQLiteStorage
 from trackio.table import Table
-from trackio.ui.main import demo
+from trackio.ui.main import CSS, HEAD, demo
 from trackio.utils import TRACKIO_DIR, TRACKIO_LOGO_DIR
 
 logging.getLogger("httpx").setLevel(logging.WARNING)
@@ -41,6 +40,8 @@ __all__ = [
     "log",
     "finish",
     "show",
+    "sync",
+    "delete_project",
     "import_csv",
     "import_tf_events",
     "Image",
@@ -140,7 +141,9 @@ def init(
     if url is None:
         if space_id is None:
             _, url, share_url = demo.launch(
-                show_api=False,
+                css=CSS,
+                head=HEAD,
+                footer_links=["gradio", "settings"],
                 inline=False,
                 quiet=True,
                 prevent_thread_lock=True,
@@ -169,7 +172,7 @@ def init(
             if utils.is_in_notebook() and embed:
                 base_url = share_url + "/" if share_url else url
                 full_url = utils.get_full_url(
-                    base_url, project=project, write_token=demo.write_token
+                    base_url, project=project, write_token=demo.write_token, footer=True
                 )
                 utils.embed_url_in_notebook(full_url)
             else:
@@ -261,10 +264,59 @@ def finish():
     run.finish()
 
 
+def delete_project(project: str, force: bool = False) -> bool:
+    """
+    Deletes a project by removing its local SQLite database.
+
+    Args:
+        project (`str`):
+            The name of the project to delete.
+        force (`bool`, *optional*, defaults to `False`):
+            If `True`, deletes the project without prompting for confirmation.
+            If `False`, prompts the user to confirm before deleting.
+
+    Returns:
+        `bool`: `True` if the project was deleted, `False` otherwise.
+    """
+    db_path = SQLiteStorage.get_project_db_path(project)
+
+    if not db_path.exists():
+        print(f"* Project '{project}' does not exist.")
+        return False
+
+    if not force:
+        response = input(
+            f"Are you sure you want to delete project '{project}'? "
+            f"This will permanently delete all runs and metrics. (y/N): "
+        )
+        if response.lower() not in ["y", "yes"]:
+            print("* Deletion cancelled.")
+            return False
+
+    try:
+        db_path.unlink()
+
+        for suffix in ("-wal", "-shm"):
+            sidecar = Path(str(db_path) + suffix)
+            if sidecar.exists():
+                sidecar.unlink()
+
+        print(f"* Project '{project}' has been deleted.")
+        return True
+    except Exception as e:
+        print(f"* Error deleting project '{project}': {e}")
+        return False
+
+
 def show(
     project: str | None = None,
+    *,
     theme: str | ThemeClass | None = None,
     mcp_server: bool | None = None,
+    footer: bool = True,
+    color_palette: list[str] | None = None,
+    open_browser: bool = True,
+    block_thread: bool | None = None,
 ):
     """
     Launches the Trackio dashboard.
@@ -284,31 +336,32 @@ def show(
             functions will be added as MCP tools. If `None` (default behavior), then the
             `GRADIO_MCP_SERVER` environment variable will be used to determine if the
             MCP server should be enabled (which is `"True"` on Hugging Face Spaces).
+        footer (`bool`, *optional*, defaults to `True`):
+            Whether to show the Gradio footer. When `False`, the footer will be hidden.
+            This can also be controlled via the `footer` query parameter in the URL.
+        color_palette (`list[str]`, *optional*):
+            A list of hex color codes to use for plot lines. If not provided, the
+            `TRACKIO_COLOR_PALETTE` environment variable will be used (comma-separated
+            hex codes), or if that is not set, the default color palette will be used.
+            Example: `['#FF0000', '#00FF00', '#0000FF']`
+        open_browser (`bool`, *optional*, defaults to `True`):
+            If `True` and not in a notebook, a new browser tab will be opened with the dashboard.
+            If `False`, the browser will not be opened.
+        block_thread (`bool`, *optional*):
+            If `True`, the main thread will be blocked until the dashboard is closed.
+            If `None` (default behavior), then the main thread will not be blocked if the
+            dashboard is launched in a notebook, otherwise the main thread will be blocked.
+
+        Returns:
+            `app`: The Gradio app object corresponding to the dashboard launched by Trackio.
+            `url`: The local URL of the dashboard.
+            `share_url`: The public share URL of the dashboard.
+            `full_url`: The full URL of the dashboard including the write token (will use the public share URL if launched publicly, otherwise the local URL).
     """
-    theme = theme or os.environ.get("TRACKIO_THEME", DEFAULT_THEME)
+    if color_palette is not None:
+        os.environ["TRACKIO_COLOR_PALETTE"] = ",".join(color_palette)
 
-    if theme != DEFAULT_THEME:
-        # TODO: It's a little hacky to reproduce this theme-setting logic from Gradio Blocks,
-        # but in Gradio 6.0, the theme will be set in `launch()` instead, which means that we
-        # will be able to remove this code.
-        if isinstance(theme, str):
-            if theme.lower() in BUILT_IN_THEMES:
-                theme = BUILT_IN_THEMES[theme.lower()]
-            else:
-                try:
-                    theme = ThemeClass.from_hub(theme)
-                except Exception as e:
-                    warnings.warn(f"Cannot load {theme}. Caught Exception: {str(e)}")
-                    theme = DefaultTheme()
-        if not isinstance(theme, ThemeClass):
-            warnings.warn("Theme should be a class loaded from gradio.themes")
-            theme = DefaultTheme()
-        demo.theme: ThemeClass = theme
-        demo.theme_css = theme._get_theme_css()
-        demo.stylesheets = theme._stylesheets
-        theme_hasher = hashlib.sha256()
-        theme_hasher.update(demo.theme_css.encode("utf-8"))
-        demo.theme_hash = theme_hasher.hexdigest()
+    theme = theme or os.environ.get("TRACKIO_THEME", DEFAULT_THEME)
 
     _mcp_server = (
         mcp_server
@@ -316,24 +369,33 @@ def show(
         else os.environ.get("GRADIO_MCP_SERVER", "False") == "True"
     )
 
-    _, url, share_url = demo.launch(
-        show_api=_mcp_server,
+    app, url, share_url = demo.launch(
+        css=CSS,
+        head=HEAD,
+        footer_links=["gradio", "settings"] + (["api"] if _mcp_server else []),
         quiet=True,
         inline=False,
         prevent_thread_lock=True,
         favicon_path=TRACKIO_LOGO_DIR / "trackio_logo_light.png",
         allowed_paths=[TRACKIO_LOGO_DIR, TRACKIO_DIR],
         mcp_server=_mcp_server,
+        theme=theme,
     )
 
     base_url = share_url + "/" if share_url else url
     full_url = utils.get_full_url(
-        base_url, project=project, write_token=demo.write_token
+        base_url, project=project, write_token=demo.write_token, footer=footer
     )
 
     if not utils.is_in_notebook():
         print(f"* Trackio UI launched at: {full_url}")
-        webbrowser.open(full_url)
-        utils.block_main_thread_until_keyboard_interrupt()
+        if open_browser:
+            webbrowser.open(full_url)
+        block_thread = block_thread if block_thread is not None else True
     else:
         utils.embed_url_in_notebook(full_url)
+        block_thread = block_thread if block_thread is not None else False
+
+    if block_thread:
+        utils.block_main_thread_until_keyboard_interrupt()
+    return TupleNoPrint((demo, url, share_url, full_url))

cli.py

@@ -1,6 +1,6 @@
 import argparse
 
-from trackio import show
+from trackio import show, sync
 
 
 def main():
@@ -24,11 +24,67 @@ def main():
         action="store_true",
         help="Enable MCP server functionality. The Trackio dashboard will be set up as an MCP server and certain functions will be exposed as MCP tools.",
     )
+    ui_parser.add_argument(
+        "--footer",
+        action="store_true",
+        default=True,
+        help="Show the Gradio footer. Use --no-footer to hide it.",
+    )
+    ui_parser.add_argument(
+        "--no-footer",
+        dest="footer",
+        action="store_false",
+        help="Hide the Gradio footer.",
+    )
+    ui_parser.add_argument(
+        "--color-palette",
+        required=False,
+        help="Comma-separated list of hex color codes for plot lines (e.g. '#FF0000,#00FF00,#0000FF'). If not provided, the TRACKIO_COLOR_PALETTE environment variable will be used, or the default palette if not set.",
+    )
+
+    sync_parser = subparsers.add_parser(
+        "sync",
+        help="Sync a local project's database to a Hugging Face Space. If the Space does not exist, it will be created.",
+    )
+    sync_parser.add_argument(
+        "--project", required=True, help="The name of the local project."
+    )
+    sync_parser.add_argument(
+        "--space-id",
+        required=True,
+        help="The Hugging Face Space ID where the project will be synced (e.g. username/space_id).",
+    )
+    sync_parser.add_argument(
+        "--private",
+        action="store_true",
+        help="Make the Hugging Face Space private if creating a new Space. By default, the repo will be public unless the organization's default is private. This value is ignored if the repo already exists.",
+    )
+    sync_parser.add_argument(
+        "--force",
+        action="store_true",
+        help="Overwrite the existing database without prompting for confirmation.",
+    )
 
     args = parser.parse_args()
 
     if args.command == "show":
-        show(args.project, args.theme, args.mcp_server)
+        color_palette = None
+        if args.color_palette:
+            color_palette = [color.strip() for color in args.color_palette.split(",")]
+        show(
+            project=args.project,
+            theme=args.theme,
+            mcp_server=args.mcp_server,
+            footer=args.footer,
+            color_palette=color_palette,
+        )
+    elif args.command == "sync":
+        sync(
+            project=args.project,
+            space_id=args.space_id,
+            private=args.private,
+            force=args.force,
+        )
     else:
         parser.print_help()
 

deploy.py

@@ -14,6 +14,7 @@ from requests import HTTPError
 
 import trackio
 from trackio.sqlite_storage import SQLiteStorage
+from trackio.utils import preprocess_space_and_dataset_ids
 
 SPACE_HOST_URL = "https://{user_name}-{space_name}.hf.space/"
 SPACE_URL = "https://huggingface.co/spaces/{space_id}"
@@ -154,6 +155,8 @@ trackio.show()"""
     if theme := os.environ.get("TRACKIO_THEME"):
         huggingface_hub.add_space_variable(space_id, "TRACKIO_THEME", theme)
 
+    huggingface_hub.add_space_variable(space_id, "GRADIO_MCP_SERVER", "True")
+
 
 def create_space_if_not_exists(
     space_id: str,
@@ -229,30 +232,75 @@ def wait_until_space_exists(
     Args:
         space_id: The ID of the Space to wait for.
     """
+    hf_api = huggingface_hub.HfApi()
     delay = 1
-    for _ in range(10):
+    for _ in range(30):
         try:
-            Client(space_id, verbose=False)
+            hf_api.space_info(space_id)
             return
-        except (ReadTimeout, ValueError):
+        except (huggingface_hub.utils.HfHubHTTPError, ReadTimeout):
             time.sleep(delay)
-            delay = min(delay * 2, 30)
+            delay = min(delay * 2, 60)
     raise TimeoutError("Waiting for space to exist took longer than expected")
 
 
-def upload_db_to_space(project: str, space_id: str) -> None:
+def upload_db_to_space(project: str, space_id: str, force: bool = False) -> None:
     """
-    Uploads the database of a local Trackio project to a Hugging Face Space.
+    Uploads the database of a local Trackio project to a Hugging Face Space. It
+    uses the Gradio Client to upload since we do not want to trigger a new build
+    of the Space, which would happen if we used `huggingface_hub.upload_file`.
 
     Args:
         project: The name of the project to upload.
         space_id: The ID of the Space to upload to.
+        force: If True, overwrite existing database without prompting. If False, prompt for confirmation.
     """
     db_path = SQLiteStorage.get_project_db_path(project)
-    client = Client(space_id, verbose=False)
+    client = Client(space_id, verbose=False, httpx_kwargs={"timeout": 90})
+
+    if not force:
+        try:
+            existing_projects = client.predict(api_name="/get_all_projects")
+            if project in existing_projects:
+                response = input(
+                    f"Database for project '{project}' already exists on Space '{space_id}'. "
+                    f"Overwrite it? (y/N): "
+                )
+                if response.lower() not in ["y", "yes"]:
+                    print("* Upload cancelled.")
+                    return
+        except Exception as e:
+            print(f"* Warning: Could not check if project exists on Space: {e}")
+            print("* Proceeding with upload...")
+
     client.predict(
         api_name="/upload_db_to_space",
         project=project,
         uploaded_db=handle_file(db_path),
         hf_token=huggingface_hub.utils.get_token(),
     )
+
+
+def sync(
+    project: str, space_id: str, private: bool | None = None, force: bool = False
+) -> None:
+    """
+    Syncs a local Trackio project's database to a Hugging Face Space.
+    If the Space does not exist, it will be created.
+
+    Args:
+        project (`str`): The name of the project to upload.
+        space_id (`str`): The ID of the Space to upload to (e.g., `"username/space_id"`).
+        private (`bool`, *optional*):
+            Whether to make the Space private. If None (default), the repo will be
+            public unless the organization's default is private. This value is ignored
+            if the repo already exists.
+        force (`bool`, *optional*, defaults to `False`):
+            If `True`, overwrite the existing database without prompting for confirmation.
+            If `False`, prompt the user before overwriting an existing database.
+    """
+    space_id, _ = preprocess_space_and_dataset_ids(space_id, None)
+    create_space_if_not_exists(space_id, private=private)
+    wait_until_space_exists(space_id)
+    upload_db_to_space(project, space_id, force=force)
+    print(f"Synced successfully to space: {SPACE_URL.format(space_id=space_id)}")

imports.py

@@ -14,6 +14,7 @@ def import_csv(
     space_id: str | None = None,
     dataset_id: str | None = None,
     private: bool | None = None,
+    force: bool = False,
 ) -> None:
     """
     Imports a CSV file into a Trackio project. The CSV file must contain a `"step"`
@@ -143,7 +144,7 @@ def import_csv(
             space_id=space_id, dataset_id=dataset_id, private=private
         )
         deploy.wait_until_space_exists(space_id=space_id)
-        deploy.upload_db_to_space(project=project, space_id=space_id)
+        deploy.upload_db_to_space(project=project, space_id=space_id, force=force)
         print(
             f"* View dashboard by going to: {deploy.SPACE_URL.format(space_id=space_id)}"
         )
@@ -156,6 +157,7 @@ def import_tf_events(
     space_id: str | None = None,
     dataset_id: str | None = None,
     private: bool | None = None,
+    force: bool = False,
 ) -> None:
     """
     Imports TensorFlow Events files from a directory into a Trackio project. Each
@@ -296,7 +298,7 @@ def import_tf_events(
             space_id, dataset_id=dataset_id, private=private
         )
         deploy.wait_until_space_exists(space_id)
-        deploy.upload_db_to_space(project, space_id)
+        deploy.upload_db_to_space(project, space_id, force=force)
         print(
             f"* View dashboard by going to: {deploy.SPACE_URL.format(space_id=space_id)}"
         )

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "trackio",
-	"version": "0.7.0",
+	"version": "0.10.0",
 	"description": "",
 	"python": "true"
 }

run.py

@@ -12,6 +12,7 @@ from trackio.media import TrackioMedia
 from trackio.sqlite_storage import SQLiteStorage
 from trackio.table import Table
 from trackio.typehints import LogEntry, UploadEntry
+from trackio.utils import _get_default_namespace
 
 BATCH_SEND_INTERVAL = 0.5
 
@@ -62,16 +63,13 @@ class Run:
     def _get_username(self) -> str | None:
         """Get the current HuggingFace username if logged in, otherwise None."""
         try:
-            who = huggingface_hub.whoami()
-            return who["name"] if who else None
+            return _get_default_namespace()
         except Exception:
             return None
 
     def _batch_sender(self):
         """Send batched logs every BATCH_SEND_INTERVAL."""
         while not self._stop_flag.is_set() or len(self._queued_logs) > 0:
-            # If the stop flag has been set, then just quickly send all
-            # the logs and exit.
             if not self._stop_flag.is_set():
                 time.sleep(BATCH_SEND_INTERVAL)
 
@@ -112,36 +110,60 @@ class Run:
 
         self._batch_sender()
 
-    def _process_media(self, metrics, step: int | None) -> dict:
+    def _queue_upload(self, file_path, step: int | None):
+        """Queue a media file for upload to space."""
+        upload_entry: UploadEntry = {
+            "project": self.project,
+            "run": self.name,
+            "step": step,
+            "uploaded_file": handle_file(file_path),
+        }
+        with self._client_lock:
+            self._queued_uploads.append(upload_entry)
+
+    def _process_media(self, value: TrackioMedia, step: int | None) -> dict:
         """
         Serialize media in metrics and upload to space if needed.
         """
-        serializable_metrics = {}
-        if not step:
-            step = 0
-        for key, value in metrics.items():
-            if isinstance(value, TrackioMedia):
-                value._save(self.project, self.name, step)
-                serializable_metrics[key] = value._to_dict()
-                if self._space_id:
-                    # Upload local media when deploying to space
-                    upload_entry: UploadEntry = {
-                        "project": self.project,
-                        "run": self.name,
-                        "step": step,
-                        "uploaded_file": handle_file(value._get_absolute_file_path()),
-                    }
-                    with self._client_lock:
-                        self._queued_uploads.append(upload_entry)
-            else:
-                serializable_metrics[key] = value
-        return serializable_metrics
+        value._save(self.project, self.name, step)
+        if self._space_id:
+            self._queue_upload(value._get_absolute_file_path(), step)
+        return value._to_dict()
 
-    @staticmethod
-    def _replace_tables(metrics):
-        for k, v in metrics.items():
-            if isinstance(v, (Table, Histogram)):
-                metrics[k] = v._to_dict()
+    def _scan_and_queue_media_uploads(self, table_dict: dict, step: int | None):
+        """
+        Scan a serialized table for media objects and queue them for upload to space.
+        """
+        if not self._space_id:
+            return
+
+        table_data = table_dict.get("_value", [])
+        for row in table_data:
+            for value in row.values():
+                if isinstance(value, dict) and value.get("_type") in [
+                    "trackio.image",
+                    "trackio.video",
+                    "trackio.audio",
+                ]:
+                    file_path = value.get("file_path")
+                    if file_path:
+                        from trackio.utils import MEDIA_DIR
+
+                        absolute_path = MEDIA_DIR / file_path
+                        self._queue_upload(absolute_path, step)
+                elif isinstance(value, list):
+                    for item in value:
+                        if isinstance(item, dict) and item.get("_type") in [
+                            "trackio.image",
+                            "trackio.video",
+                            "trackio.audio",
+                        ]:
+                            file_path = item.get("file_path")
+                            if file_path:
+                                from trackio.utils import MEDIA_DIR
+
+                                absolute_path = MEDIA_DIR / file_path
+                                self._queue_upload(absolute_path, step)
 
     def log(self, metrics: dict, step: int | None = None):
         renamed_keys = []
@@ -159,9 +181,16 @@ class Run:
             warnings.warn(f"Reserved keys renamed: {renamed_keys} → '__{{key}}'")
 
         metrics = new_metrics
-        Run._replace_tables(metrics)
-
-        metrics = self._process_media(metrics, step)
+        for key, value in metrics.items():
+            if isinstance(value, Table):
+                metrics[key] = value._to_dict(
+                    project=self.project, run=self.name, step=step
+                )
+                self._scan_and_queue_media_uploads(metrics[key], step)
+            elif isinstance(value, Histogram):
+                metrics[key] = value._to_dict()
+            elif isinstance(value, TrackioMedia):
+                metrics[key] = self._process_media(value, step)
         metrics = utils.serialize_values(metrics)
 
         config_to_log = None
@@ -184,7 +213,6 @@ class Run:
         """Cleanup when run is finished."""
         self._stop_flag.set()
 
-        # Wait for the batch sender to finish before joining the client thread.
         time.sleep(2 * BATCH_SEND_INTERVAL)
 
         if self._client_thread is not None:

table.py

@@ -1,18 +1,27 @@
+import os
 from typing import Any, Literal
 
 from pandas import DataFrame
 
+try:
+    from trackio.media.media import TrackioMedia
+    from trackio.utils import MEDIA_DIR
+except ImportError:
+    from media.media import TrackioMedia
+    from utils import MEDIA_DIR
+
 
 class Table:
     """
-    Initializes a Table object.
+    Initializes a Table object. Tables can be used to log tabular data including images, numbers, and text.
 
     Args:
         columns (`list[str]`, *optional*):
             Names of the columns in the table. Optional if `data` is provided. Not
             expected if `dataframe` is provided. Currently ignored.
         data (`list[list[Any]]`, *optional*):
-            2D row-oriented array of values.
+            2D row-oriented array of values. Each value can be: a number, a string (treated as Markdown and truncated if too long),
+             or a `Trackio.Image` or list of `Trackio.Image` objects.
         dataframe (`pandas.`DataFrame``, *optional*):
             DataFrame object used to create the table. When set, `data` and `columns`
             arguments are ignored.
@@ -40,14 +49,115 @@ class Table:
     ):
         # TODO: implement support for columns, dtype, optional, allow_mixed_types, and log_mode.
         # for now (like `rows`) they are included for API compat but don't do anything.
-
         if dataframe is None:
-            self.data = data
+            self.data = DataFrame(data) if data is not None else DataFrame()
         else:
-            self.data = dataframe.to_dict(orient="records")
+            self.data = dataframe
+
+    def _has_media_objects(self, dataframe: DataFrame) -> bool:
+        """Check if dataframe contains any TrackioMedia objects or lists of TrackioMedia objects."""
+        for col in dataframe.columns:
+            if dataframe[col].apply(lambda x: isinstance(x, TrackioMedia)).any():
+                return True
+            if (
+                dataframe[col]
+                .apply(
+                    lambda x: isinstance(x, list)
+                    and len(x) > 0
+                    and isinstance(x[0], TrackioMedia)
+                )
+                .any()
+            ):
+                return True
+        return False
+
+    def _process_data(self, project: str, run: str, step: int = 0):
+        """Convert dataframe to dict format, processing any TrackioMedia objects if present."""
+        df = self.data
+        if not self._has_media_objects(df):
+            return df.to_dict(orient="records")
+
+        processed_df = df.copy()
+        for col in processed_df.columns:
+            for idx in processed_df.index:
+                value = processed_df.at[idx, col]
+                if isinstance(value, TrackioMedia):
+                    value._save(project, run, step)
+                    processed_df.at[idx, col] = value._to_dict()
+                if (
+                    isinstance(value, list)
+                    and len(value) > 0
+                    and isinstance(value[0], TrackioMedia)
+                ):
+                    [v._save(project, run, step) for v in value]
+                    processed_df.at[idx, col] = [v._to_dict() for v in value]
+
+        return processed_df.to_dict(orient="records")
+
+    @staticmethod
+    def to_display_format(table_data: list[dict]) -> list[dict]:
+        """Convert stored table data to display format for UI rendering. Note
+        that this does not use the self.data attribute, but instead uses the
+        table_data parameter, which is is what the UI receives.
+
+        Args:
+            table_data: List of dictionaries representing table rows (from stored _value)
+
+        Returns:
+            Table data with images converted to markdown syntax and long text truncated.
+        """
+        truncate_length = int(os.getenv("TRACKIO_TABLE_TRUNCATE_LENGTH", "250"))
+
+        def convert_image_to_markdown(image_data: dict) -> str:
+            relative_path = image_data.get("file_path", "")
+            caption = image_data.get("caption", "")
+            absolute_path = MEDIA_DIR / relative_path
+            return f'<img src="/gradio_api/file={absolute_path}" alt="{caption}" />'
+
+        processed_data = []
+        for row in table_data:
+            processed_row = {}
+            for key, value in row.items():
+                if isinstance(value, dict) and value.get("_type") == "trackio.image":
+                    processed_row[key] = convert_image_to_markdown(value)
+                elif (
+                    isinstance(value, list)
+                    and len(value) > 0
+                    and isinstance(value[0], dict)
+                    and value[0].get("_type") == "trackio.image"
+                ):
+                    # This assumes that if the first item is an image, all items are images. Ok for now since we don't support mixed types in a single cell.
+                    processed_row[key] = (
+                        '<div style="display: flex; gap: 10px;">'
+                        + "".join([convert_image_to_markdown(item) for item in value])
+                        + "</div>"
+                    )
+                elif isinstance(value, str) and len(value) > truncate_length:
+                    truncated = value[:truncate_length]
+                    full_text = value.replace("<", "&lt;").replace(">", "&gt;")
+                    processed_row[key] = (
+                        f'<details style="display: inline;">'
+                        f'<summary style="display: inline; cursor: pointer;">{truncated}…<span><em>(truncated, click to expand)</em></span></summary>'
+                        f'<div style="margin-top: 10px; padding: 10px; background: #f5f5f5; border-radius: 4px; max-height: 400px; overflow: auto;">'
+                        f'<pre style="white-space: pre-wrap; word-wrap: break-word; margin: 0;">{full_text}</pre>'
+                        f"</div>"
+                        f"</details>"
+                    )
+                else:
+                    processed_row[key] = value
+            processed_data.append(processed_row)
+        return processed_data
+
+    def _to_dict(self, project: str, run: str, step: int = 0):
+        """Convert table to dictionary representation.
 
-    def _to_dict(self):
+        Args:
+            project: Project name for saving media files
+            run: Run name for saving media files
+            step: Step number for saving media files
+        """
+        data = self._process_data(project, run, step)
         return {
             "_type": self.TYPE,
-            "_value": self.data,
+            "_value": data,
         }

ui/fns.py

@@ -1,6 +1,7 @@
 """Shared functions for the Trackio UI."""
 
 import os
+from functools import lru_cache
 
 import gradio as gr
 import huggingface_hub as hf
@@ -82,6 +83,7 @@ def update_navbar_value(project_dd, request: gr.Request):
     )
 
 
+@lru_cache(maxsize=32)
 def check_hf_token_has_write_access(hf_token: str | None) -> None:
     """
     Checks to see if the provided hf_token is valid and has write access to the Space
@@ -137,6 +139,7 @@ def check_hf_token_has_write_access(hf_token: str | None) -> None:
             )
 
 
+@lru_cache(maxsize=32)
 def check_oauth_token_has_write_access(oauth_token: str | None) -> None:
     """
     Checks to see if the oauth token provided via Gradio's OAuth is valid and has write access

ui/main.py

@@ -99,6 +99,18 @@ def get_runs(project) -> list[str]:
     return SQLiteStorage.get_runs(project)
 
 
+def upload_db_to_space(
+    project: str, uploaded_db: gr.FileData, hf_token: str | None
+) -> None:
+    """
+    Uploads the database of a local Trackio project to a Hugging Face Space.
+    """
+    fns.check_hf_token_has_write_access(hf_token)
+    db_project_path = SQLiteStorage.get_project_db_path(project)
+    os.makedirs(os.path.dirname(db_project_path), exist_ok=True)
+    shutil.copy(uploaded_db["path"], db_project_path)
+
+
 def get_available_metrics(project: str, runs: list[str]) -> list[str]:
     """Get all available metrics across all runs for x-axis selection."""
     if not project or not runs:
@@ -162,9 +174,10 @@ def extract_media(logs: list[dict]) -> dict[str, list[MediaData]]:
 def load_run_data(
     project: str | None,
     run: str | None,
-    smoothing_granularity: int,
-    x_axis: str,
-    log_scale: bool = False,
+    smoothing_granularity: int = 0,
+    x_axis: str = "step",
+    log_scale_x: bool = False,
+    log_scale_y: bool = False,
 ) -> tuple[pd.DataFrame, dict]:
     if not project or not run:
         return None, None
@@ -189,13 +202,26 @@ def load_run_data(
     else:
         x_column = x_axis
 
-    if log_scale and x_column in df.columns:
+    if log_scale_x and x_column in df.columns:
         x_vals = df[x_column]
         if (x_vals <= 0).any():
             df[x_column] = np.log10(np.maximum(x_vals, 0) + 1)
         else:
             df[x_column] = np.log10(x_vals)
 
+    if log_scale_y:
+        numeric_cols = df.select_dtypes(include="number").columns
+        y_cols = [
+            c for c in numeric_cols if c not in utils.RESERVED_KEYS and c != x_column
+        ]
+        for y_col in y_cols:
+            if y_col in df.columns:
+                y_vals = df[y_col]
+                if (y_vals <= 0).any():
+                    df[y_col] = np.log10(np.maximum(y_vals, 0) + 1)
+                else:
+                    df[y_col] = np.log10(y_vals)
+
     if smoothing_granularity > 0:
         numeric_cols = df.select_dtypes(include="number").columns
         numeric_cols = [c for c in numeric_cols if c not in utils.RESERVED_KEYS]
@@ -271,22 +297,6 @@ def toggle_timer(cb_value):
         return gr.Timer(active=False)
 
 
-def upload_db_to_space(
-    project: str, uploaded_db: gr.FileData, hf_token: str | None
-) -> None:
-    """
-    Uploads the database of a local Trackio project to a Hugging Face Space.
-    """
-    fns.check_hf_token_has_write_access(hf_token)
-    db_project_path = SQLiteStorage.get_project_db_path(project)
-    if os.path.exists(db_project_path):
-        raise gr.Error(
-            f"Trackio database file already exists for project {project}, cannot overwrite."
-        )
-    os.makedirs(os.path.dirname(db_project_path), exist_ok=True)
-    shutil.copy(uploaded_db["path"], db_project_path)
-
-
 def bulk_upload_media(uploads: list[UploadEntry], hf_token: str | None) -> None:
     """
     Uploads media files to a Trackio dashboard. Each entry in the list is a tuple of the project, run, and media file to be uploaded.
@@ -548,7 +558,7 @@ def create_media_section(media_by_run: dict[str, dict[str, list[MediaData]]]):
                                             )
 
 
-css = """
+CSS = """
 #run-cb .wrap { gap: 2px; }
 #run-cb .wrap label {
     line-height: 1;
@@ -603,9 +613,13 @@ css = """
     gap: 0.25em;
     margin-bottom: 0.25em;
 }
+
+.tab-like-container {
+    visibility: hidden;
+}
 """
 
-javascript = """
+HEAD = """
 <script>
 function setCookie(name, value, days) {
     var expires = "";
@@ -631,6 +645,7 @@ function getCookie(name) {
 (function() {
     const urlParams = new URLSearchParams(window.location.search);
     const writeToken = urlParams.get('write_token');
+    const footerParam = urlParams.get('footer');
     
     if (writeToken) {
         setCookie('trackio_write_token', writeToken, 7);
@@ -646,6 +661,12 @@ function getCookie(name) {
             window.history.replaceState({}, document.title, newUrl);
         }
     }
+    
+    if (footerParam === 'false') {
+        const style = document.createElement('style');
+        style.textContent = 'footer { display: none !important; }';
+        document.head.appendChild(style);
+    }
 })();
 </script>
 """
@@ -653,7 +674,7 @@ function getCookie(name) {
 
 gr.set_static_paths(paths=[utils.MEDIA_DIR])
 
-with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
+with gr.Blocks(title="Trackio Dashboard") as demo:
     with gr.Sidebar(open=False) as sidebar:
         logo_urls = utils.get_logo_urls()
         logo = gr.Markdown(
@@ -698,7 +719,8 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
             choices=["step", "time"],
             value="step",
         )
-        log_scale_cb = gr.Checkbox(label="Log scale X-axis", value=False)
+        log_scale_x_cb = gr.Checkbox(label="Log scale X-axis", value=False)
+        log_scale_y_cb = gr.Checkbox(label="Log scale Y-axis", value=False)
         metric_filter_tb = gr.Textbox(
             label="Metric Filter (regex)",
             placeholder="e.g., loss|ndcg@10|gpu",
@@ -726,7 +748,7 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
             smoothing_slider,
         ],
         queue=False,
-        api_name=False,
+        api_visibility="private",
     )
     gr.on(
         [demo.load],
@@ -734,7 +756,7 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         outputs=project_dd,
         show_progress="hidden",
         queue=False,
-        api_name=False,
+        api_visibility="private",
     )
     gr.on(
         [timer.tick],
@@ -742,14 +764,14 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         inputs=[project_dd, run_tb, run_selection_state, selected_runs_from_url],
         outputs=[run_cb, run_tb, run_selection_state],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
     )
     gr.on(
         [timer.tick],
         fn=lambda: gr.Dropdown(info=fns.get_project_info()),
         outputs=[project_dd],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
     )
     gr.on(
         [demo.load, project_dd.change],
@@ -758,34 +780,34 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         outputs=[run_cb, run_tb, run_selection_state],
         show_progress="hidden",
         queue=False,
-        api_name=False,
+        api_visibility="private",
     ).then(
         fn=update_x_axis_choices,
         inputs=[project_dd, run_selection_state],
         outputs=x_axis_dd,
         show_progress="hidden",
         queue=False,
-        api_name=False,
+        api_visibility="private",
     ).then(
         fn=generate_embed,
         inputs=[project_dd, metric_filter_tb, run_selection_state],
         outputs=[embed_code],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     ).then(
         fns.update_navbar_value,
         inputs=[project_dd],
         outputs=[navbar],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     ).then(
         fn=fns.get_group_by_fields,
         inputs=[project_dd],
         outputs=[run_group_by_dd],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
 
@@ -796,7 +818,7 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         outputs=x_axis_dd,
         show_progress="hidden",
         queue=False,
-        api_name=False,
+        api_visibility="private",
     )
     gr.on(
         [metric_filter_tb.change, run_cb.change],
@@ -804,7 +826,7 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         inputs=[project_dd, metric_filter_tb, run_selection_state],
         outputs=embed_code,
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
 
@@ -820,7 +842,7 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         inputs=[run_group_by_dd],
         outputs=[run_cb, grouped_runs_panel],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
 
@@ -828,28 +850,28 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         fn=toggle_timer,
         inputs=realtime_cb,
         outputs=timer,
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
     run_cb.input(
         fn=fns.handle_run_checkbox_change,
         inputs=[run_cb, run_selection_state],
         outputs=run_selection_state,
-        api_name=False,
+        api_visibility="private",
         queue=False,
     ).then(
         fn=generate_embed,
         inputs=[project_dd, metric_filter_tb, run_selection_state],
         outputs=embed_code,
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
     run_tb.input(
         fn=refresh_runs,
         inputs=[project_dd, run_tb, run_selection_state],
         outputs=[run_cb, run_tb, run_selection_state],
-        api_name=False,
+        api_visibility="private",
         queue=False,
         show_progress="hidden",
     )
@@ -911,7 +933,7 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         inputs=[project_dd],
         outputs=last_steps,
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
     )
 
     @gr.render(
@@ -922,7 +944,8 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
             smoothing_slider.change,
             x_lim.change,
             x_axis_dd.change,
-            log_scale_cb.change,
+            log_scale_x_cb.change,
+            log_scale_y_cb.change,
             metric_filter_tb.change,
         ],
         inputs=[
@@ -932,7 +955,8 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
             metrics_subset,
             x_lim,
             x_axis_dd,
-            log_scale_cb,
+            log_scale_x_cb,
+            log_scale_y_cb,
             metric_filter_tb,
         ],
         show_progress="hidden",
@@ -945,7 +969,8 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         metrics_subset,
         x_lim_value,
         x_axis,
-        log_scale,
+        log_scale_x,
+        log_scale_y,
         metric_filter,
     ):
         dfs = []
@@ -954,7 +979,7 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
 
         for run in runs:
             df, media_by_key = load_run_data(
-                project, run, smoothing_granularity, x_axis, log_scale
+                project, run, smoothing_granularity, x_axis, log_scale_x, log_scale_y
             )
             if df is not None:
                 dfs.append(df)
@@ -1058,13 +1083,13 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
                                     y_title=metric_name.split("/")[-1],
                                     color=color,
                                     color_map=color_map,
+                                    colors_in_legend=original_runs,
                                     title=metric_name,
                                     key=f"plot-{metric_idx}",
                                     preserved_by_key=None,
+                                    buttons=["fullscreen", "export"],
                                     x_lim=updated_x_lim,
-                                    show_fullscreen_button=True,
                                     min_width=400,
-                                    show_export_button=True,
                                 )
                                 plot.select(
                                     update_x_lim,
@@ -1123,13 +1148,13 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
                                             y_title=metric_name.split("/")[-1],
                                             color=color,
                                             color_map=color_map,
+                                            colors_in_legend=original_runs,
                                             title=metric_name,
                                             key=f"plot-{metric_idx}",
                                             preserved_by_key=None,
+                                            buttons=["fullscreen", "export"],
                                             x_lim=updated_x_lim,
-                                            show_fullscreen_button=True,
                                             min_width=400,
-                                            show_export_button=True,
                                         )
                                         plot.select(
                                             update_x_lim,
@@ -1145,59 +1170,113 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
         if media_by_run and any(any(media) for media in media_by_run.values()):
             create_media_section(media_by_run)
 
+    @gr.render(
+        triggers=[
+            demo.load,
+            run_cb.change,
+            last_steps.change,
+            metric_filter_tb.change,
+        ],
+        inputs=[
+            project_dd,
+            run_cb,
+            metrics_subset,
+            metric_filter_tb,
+        ],
+        show_progress="hidden",
+        queue=False,
+    )
+    def update_tables(
+        project,
+        runs,
+        metrics_subset_value,
+        metric_filter,
+    ):
+        dfs = []
+        for run in runs:
+            df, _ = load_run_data(project, run)
+            if df is not None:
+                dfs.append(df)
+        master_df = pd.concat(dfs, ignore_index=True) if dfs else pd.DataFrame()
+
         table_cols = master_df.select_dtypes(include="object").columns
         table_cols = [c for c in table_cols if c not in utils.RESERVED_KEYS]
-        if metrics_subset:
-            table_cols = [c for c in table_cols if c in metrics_subset]
+        if metrics_subset_value:
+            table_cols = [c for c in table_cols if c in metrics_subset_value]
         if metric_filter and metric_filter.strip():
             table_cols = filter_metrics_by_regex(list(table_cols), metric_filter)
+        table_cols = [
+            c
+            for c in table_cols
+            if not (metric_df := master_df.dropna(subset=[c])).empty
+            and isinstance(first_value := metric_df[c].iloc[0], dict)
+            and first_value.get("_type") == Table.TYPE
+        ]
 
-        actual_table_count = sum(
-            1
-            for metric_name in table_cols
-            if not (metric_df := master_df.dropna(subset=[metric_name])).empty
-            and isinstance(value := metric_df[metric_name].iloc[-1], dict)
-            and value.get("_type") == Table.TYPE
-        )
-
-        if actual_table_count > 0:
-            with gr.Accordion(f"tables ({actual_table_count})", open=True):
+        if len(table_cols) > 0:
+            with gr.Accordion(f"tables ({len(table_cols)})", open=True):
                 with gr.Row(key="row"):
                     for metric_idx, metric_name in enumerate(table_cols):
                         metric_df = master_df.dropna(subset=[metric_name])
                         if not metric_df.empty:
-                            value = metric_df[metric_name].iloc[-1]
+                            value = metric_df[metric_name]
+                            first_value = value.iloc[0]
                             if (
-                                isinstance(value, dict)
-                                and "_type" in value
-                                and value["_type"] == Table.TYPE
+                                isinstance(first_value, dict)
+                                and "_type" in first_value
+                                and first_value["_type"] == Table.TYPE
                             ):
                                 try:
-                                    df = pd.DataFrame(value["_value"])
-                                    gr.DataFrame(
-                                        df,
-                                        label=f"{metric_name} (latest)",
-                                        key=f"table-{metric_idx}",
-                                        wrap=True,
-                                    )
+                                    with gr.Column():
+                                        s = gr.Slider(
+                                            value=len(value),
+                                            minimum=1,
+                                            maximum=len(value),
+                                            step=1,
+                                            container=False,
+                                            visible=len(value) > 1,
+                                        )
+                                        processed_data = Table.to_display_format(
+                                            value.iloc[-1]["_value"]
+                                        )
+                                        df = pd.DataFrame(processed_data)
+                                        table = gr.DataFrame(
+                                            df,
+                                            label=f"{metric_name} (index {len(value)})",
+                                            key=f"table-{metric_idx}",
+                                            wrap=True,
+                                            datatype="markdown",
+                                            preserved_by_key=None,
+                                        )
+
+                                        def get_table_at_index(index: int):
+                                            value = metric_df[metric_name]
+                                            processed_data = Table.to_display_format(
+                                                value.iloc[index - 1]["_value"]
+                                            )
+                                            df_ = pd.DataFrame(processed_data)
+                                            return gr.Dataframe(
+                                                df_,
+                                                label=f"{metric_name} (index {index})",
+                                            )
+
+                                        s.input(
+                                            get_table_at_index,
+                                            inputs=s,
+                                            outputs=table,
+                                            show_progress="hidden",
+                                        )
                                 except Exception as e:
                                     gr.Warning(
                                         f"Column {metric_name} failed to render as a table: {e}"
                                     )
 
-        # Display histograms
         histogram_cols = set(master_df.columns) - {
             "run",
             "step",
             "timestamp",
             "data_type",
         }
-        if metrics_subset:
-            histogram_cols = [c for c in histogram_cols if c in metrics_subset]
-        if metric_filter and metric_filter.strip():
-            histogram_cols = filter_metrics_by_regex(
-                list(histogram_cols), metric_filter
-            )
 
         actual_histogram_count = sum(
             1
@@ -1338,7 +1417,7 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
                                 run_cb,
                             ],
                             show_progress="hidden",
-                            api_name=False,
+                            api_visibility="private",
                             queue=False,
                         )
 
@@ -1352,7 +1431,7 @@ with gr.Blocks(title="Trackio Dashboard", css=css, head=javascript) as demo:
                             ],
                             outputs=[run_selection_state, group_cb, run_cb],
                             show_progress="hidden",
-                            api_name=False,
+                            api_visibility="private",
                             queue=False,
                         )
 

ui/run_detail.py

@@ -73,13 +73,13 @@ with gr.Blocks() as run_detail_page:
         outputs=[project_dd, run_dd],
         show_progress="hidden",
         queue=False,
-        api_name=False,
+        api_visibility="private",
     ).then(
         fns.update_navbar_value,
         inputs=[project_dd],
         outputs=[navbar],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
 
@@ -89,6 +89,6 @@ with gr.Blocks() as run_detail_page:
         inputs=[project_dd, run_dd],
         outputs=[run_details, run_config],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )

ui/runs.py

@@ -200,14 +200,14 @@ with gr.Blocks() as run_page:
         outputs=project_dd,
         show_progress="hidden",
         queue=False,
-        api_name=False,
+        api_visibility="private",
     )
     gr.on(
         [timer.tick],
         fn=lambda: gr.Dropdown(info=fns.get_project_info()),
         outputs=[project_dd],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
     )
     gr.on(
         [project_dd.change],
@@ -215,14 +215,14 @@ with gr.Blocks() as run_page:
         inputs=[project_dd],
         outputs=[runs_table],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     ).then(
         fns.update_navbar_value,
         inputs=[project_dd],
         outputs=[navbar],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
 
@@ -232,7 +232,7 @@ with gr.Blocks() as run_page:
         inputs=[],
         outputs=[delete_run_btn, runs_table, allow_deleting_runs],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
     gr.on(
@@ -241,7 +241,7 @@ with gr.Blocks() as run_page:
         inputs=[allow_deleting_runs, runs_table],
         outputs=[delete_run_btn],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
     gr.on(
@@ -254,7 +254,7 @@ with gr.Blocks() as run_page:
         inputs=None,
         outputs=[delete_run_btn, confirm_btn, cancel_btn],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
     gr.on(
@@ -267,7 +267,7 @@ with gr.Blocks() as run_page:
         inputs=None,
         outputs=[delete_run_btn, confirm_btn, cancel_btn],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )
     gr.on(
@@ -276,6 +276,6 @@ with gr.Blocks() as run_page:
         inputs=[allow_deleting_runs, runs_table, project_dd],
         outputs=[runs_table],
         show_progress="hidden",
-        api_name=False,
+        api_visibility="private",
         queue=False,
     )

utils.py

@@ -3,6 +3,7 @@ import os
 import re
 import time
 from datetime import datetime, timezone
+from functools import lru_cache
 from pathlib import Path
 from typing import TYPE_CHECKING
 
@@ -144,7 +145,7 @@ def generate_readable_name(used_names: list[str], space_id: str | None = None) -
     If space_id is provided, generates username-timestamp format instead.
     """
     if space_id is not None:
-        username = huggingface_hub.whoami()["name"]
+        username = _get_default_namespace()
         timestamp = int(time.time())
         return f"{username}-{timestamp}"
     adjectives = [
@@ -418,10 +419,10 @@ def preprocess_space_and_dataset_ids(
     space_id: str | None, dataset_id: str | None
 ) -> tuple[str | None, str | None]:
     if space_id is not None and "/" not in space_id:
-        username = huggingface_hub.whoami()["name"]
+        username = _get_default_namespace()
         space_id = f"{username}/{space_id}"
     if dataset_id is not None and "/" not in dataset_id:
-        username = huggingface_hub.whoami()["name"]
+        username = _get_default_namespace()
         dataset_id = f"{username}/{dataset_id}"
     if space_id is not None and dataset_id is None:
         dataset_id = f"{space_id}-dataset"
@@ -465,26 +466,39 @@ def format_timestamp(timestamp_str):
         return "Unknown"
 
 
-COLOR_PALETTE = [
+DEFAULT_COLOR_PALETTE = [
+    "#A8769B",
+    "#E89957",
     "#3B82F6",
-    "#EF4444",
     "#10B981",
-    "#F59E0B",
+    "#EF4444",
     "#8B5CF6",
+    "#14B8A6",
+    "#F59E0B",
     "#EC4899",
     "#06B6D4",
-    "#84CC16",
-    "#F97316",
-    "#6366F1",
 ]
 
 
-def get_color_mapping(runs: list[str], smoothing: bool) -> dict[str, str]:
+def get_color_palette() -> list[str]:
+    """Get the color palette from environment variable or use default."""
+    env_palette = os.environ.get("TRACKIO_COLOR_PALETTE")
+    if env_palette:
+        return [color.strip() for color in env_palette.split(",")]
+    return DEFAULT_COLOR_PALETTE
+
+
+def get_color_mapping(
+    runs: list[str], smoothing: bool, color_palette: list[str] | None = None
+) -> dict[str, str]:
     """Generate color mapping for runs, with transparency for original data when smoothing is enabled."""
+    if color_palette is None:
+        color_palette = get_color_palette()
+
     color_map = {}
 
     for i, run in enumerate(runs):
-        base_color = COLOR_PALETTE[i % len(COLOR_PALETTE)]
+        base_color = color_palette[i % len(color_palette)]
 
         if smoothing:
             color_map[run] = base_color + "4D"
@@ -802,11 +816,15 @@ def deserialize_values(metrics):
     return result
 
 
-def get_full_url(base_url: str, project: str | None, write_token: str) -> str:
+def get_full_url(
+    base_url: str, project: str | None, write_token: str, footer: bool = True
+) -> str:
     params = []
     if project:
         params.append(f"project={project}")
     params.append(f"write_token={write_token}")
+    if not footer:
+        params.append("footer=false")
     return base_url + "?" + "&".join(params)
 
 
@@ -852,3 +870,17 @@ def get_space() -> str | None:
 def ordered_subset(items: list[str], subset: list[str] | None) -> list[str]:
     subset_set = set(subset or [])
     return [item for item in items if item in subset_set]
+
+
+def _get_default_namespace() -> str:
+    """Get the default namespace (username).
+
+    This function uses caching to avoid repeated API calls to /whoami-v2.
+    """
+    token = huggingface_hub.get_token()
+    return _cached_whoami(token)["name"]
+
+
+@lru_cache(maxsize=32)
+def _cached_whoami(token: str | None) -> dict:
+    return huggingface_hub.whoami(token=token)