cometx 3.6.7__tar.gz → 3.6.8__tar.gz

{cometx-3.6.7 → cometx-3.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cometx
-Version: 3.6.7
+Version: 3.6.8
 Summary: Python tools for Comet
 Home-page: https://github.com/comet-ml/cometx/
 Author: cometx development team

{cometx-3.6.7 → cometx-3.6.8}/cometx/_version.py

@@ -12,5 +12,5 @@
 #  the express permission of Comet ML Inc.
 # *******************************************************
 
-version_info = (3, 6, 7)
+version_info = (3, 6, 8)
 __version__ = ".".join(map(str, version_info))

{cometx-3.6.7 → cometx-3.6.8}/cometx/utils.py

@@ -304,6 +304,77 @@ def get_unit_label_plural(unit):
     return labels.get(unit, unit.capitalize() + "s")
 
 
+def resolve_workspace(workspace=None, api=None):
+    """
+    Return a workspace name, falling back to the account's default.
+
+    Args:
+        workspace: (str, optional) a workspace name; returned unchanged if given
+        api: (API, optional) an API instance to reuse; one is created if omitted
+
+    Returns: the given workspace, the configured default workspace, or -- if
+        neither is set and the account has exactly one workspace -- that one.
+
+    Raises:
+        ValueError: if no workspace was given, no default is configured, and the
+            account has several workspaces to choose between.
+    """
+    if workspace:
+        return workspace
+
+    if api is None:
+        from .api import API
+
+        api = API()
+
+    configured = api.get_default_workspace()
+    if configured:
+        return configured
+
+    workspaces = api.get_workspaces()
+    if len(workspaces) == 1:
+        return workspaces[0]
+
+    raise ValueError(
+        "Unable to pick a workspace: several are available -- %s"
+        % ", ".join(sorted(workspaces))
+    )
+
+
+def get_project_url(workspace, project_name, api=None):
+    """
+    Return the URL of a project in the Comet UI.
+
+    Args:
+        workspace: (str) the workspace name
+        project_name: (str) the project name
+        api: (API, optional) an API instance to reuse; one is created if omitted
+
+    Returns: the project's URL, on whichever server the API is configured for.
+    """
+    if api is None:
+        from .api import API
+
+        api = API()
+
+    return "%s/%s/%s" % (api.server_url.rstrip("/"), workspace, project_name)
+
+
+def get_first_experiment(api, workspace, project_name):
+    """
+    Return one APIExperiment from a project, for code that just needs an example.
+
+    Args:
+        api: (API) an API instance
+        workspace: (str) the workspace name
+        project_name: (str) the project name
+
+    Returns: the project's first APIExperiment, or None if the project is empty.
+    """
+    experiments = api.get_experiments(workspace, project_name)
+    return experiments[0] if experiments else None
+
+
 def remove_extra_slashes(path):
     if path:
         if path.startswith("/"):

cometx-3.6.8/cometx/views.py

@@ -0,0 +1,877 @@
+# -*- coding: utf-8 -*-
+# ****************************************
+#                              __
+#   _________  ____ ___  ___  / /__  __
+#  / ___/ __ \/ __ `__ \/ _ \/ __/ |/_/
+# / /__/ /_/ / / / / / /  __/ /__>  <
+# \___/\____/_/ /_/ /_/\___/\__/_/|_|
+#
+#
+#  Copyright (c) 2026 Cometx Development
+#      Team. All rights reserved.
+# ****************************************
+"""
+cometx.views -- a builder library for Comet dashboard Views.
+
+Views are the saved dashboards and per-experiment chart layouts in the Comet UI.
+This module builds them programmatically: import the panel factories, compose
+them into ``Section`` objects, and hand the result to ``build_view()`` (project
+dashboards) or ``build_experiment_view()`` (per-experiment views).
+
+    from cometx.views import Section, build_view, line_panel, scalar_panel
+
+    view = build_view(
+        "My Dashboard",
+        sections=[
+            Section("At a glance", [scalar_panel("accuracy", aggregation="max")]),
+            Section("Curves", [line_panel(["loss", "val_loss"], smoothing=0.6)]),
+        ],
+    )
+    API().create_view(workspace, project_name, view)
+
+The Comet SDK exposes four functions for working with saved dashboard views:
+
+    API.get_views(workspace, project_name)      -> list[View]
+    API.create_view(workspace, project_name, v) -> View     (project-level)
+    APIExperiment.get_views()                   -> list[View]
+    APIExperiment.create_view(view)             -> View     (experiment-level)
+
+A ``View`` is mostly a carrier for the dashboard's serialized layout state, and
+the interesting content lives in ``view.v3`` -- a dict of *sections*, each
+holding *panels* plus a grid *layout*. This module provides typed-ish factories
+for every panel type the dashboard supports, plus ``build_view()`` to assemble
+sections into a ``View`` that the Comet UI renders correctly.
+
+Schema notes (derived from views saved by the Comet UI):
+
+  v3 = {
+    "layout": [],              # legacy mirror of section[0]; safe to leave empty
+    "globalConfig": {...},     # dashboard-wide x-axis / smoothing / sampling
+    "sections": [
+        {"id": "aB3xY9", "title": "Metrics", "autogenerated": False,
+         "expanded": True, "panels": [ ... ], "layout": [ ... ]},
+    ],
+    "autoGenerate": False,     # True lets Comet append auto panels for new metrics
+    "isPersonalView": False,
+  }
+
+  chart_state ("dashboardChartState") is the pre-sections legacy format: the
+  same panel dicts bucketed by type. We emit it alongside v3 for compatibility
+  with older backends and with code that reads the legacy field.
+
+  query_state ("experimentQueryState") holds the filter/segment state.
+  table_state ("reactGridTableState") holds the experiment table config.
+
+Experiment-level views (the chart-template scope, written by
+``APIExperiment.create_view``) use a *different* envelope: the sections live in
+``view.v2["panels"]`` and the display settings sit at the top of ``v2``, with
+``v3`` unused. ``build_view`` targets the project scope and
+``build_experiment_view`` the experiment scope; sections and panels are
+identical between the two.
+
+Nothing here calls the network; ``build_view`` returns a plain ``View`` that you
+pass to ``API.create_view`` or ``APIExperiment.create_view``.
+"""
+
+import json
+import random
+import string
+from typing import Any, Dict, List, Optional, Sequence, Union
+
+from comet_ml.api_objects.view import View
+
+__all__ = [
+    "new_id",
+    "Section",
+    "build_view",
+    "build_experiment_view",
+    "line_panel",
+    "bar_panel",
+    "scatter_panel",
+    "parallel_panel",
+    "scalar_panel",
+    "image_panel",
+    "data_panel",
+    "custom_panel",
+    "python_panel",
+    "legend_key",
+    "global_config",
+    "table_state",
+    "query_state",
+    "rule",
+    "any_of",
+    "all_of",
+    "describe_view",
+]
+
+# The dashboard grid is 6 units wide. A panel with w=2 is one third of a row.
+GRID_WIDTH = 6
+
+_ID_ALPHABET = string.ascii_letters + string.digits
+
+
+def new_id(length: int = 6) -> str:
+    """Return a random id in the same style the UI generates ('F5ReNw')."""
+    return "".join(random.choice(_ID_ALPHABET) for _ in range(length))
+
+
+# ---------------------------------------------------------------------------
+# Legend keys
+# ---------------------------------------------------------------------------
+
+
+def legend_key(
+    value: str = "Name", label: Optional[str] = None, source: str = "log_other"
+) -> Dict[str, Any]:
+    """One entry of a chart's ``selectedLegendKeys``.
+
+    Common combinations:
+        legend_key("Name")                                  # experiment name
+        legend_key("experimentTags", "Tags", "tags")        # tags
+        legend_key("learning_rate", source="params")        # a hyperparameter
+    """
+    return {"value": value, "label": label or value, "source": source}
+
+
+DEFAULT_LEGEND = [legend_key("Name")]
+
+
+# ---------------------------------------------------------------------------
+# Panel factories. Each returns a v3 panel dict with a fresh chartId.
+# ---------------------------------------------------------------------------
+
+
+def line_panel(
+    y: Union[str, Sequence[str]],
+    x: str = "step",
+    name: str = "",
+    smoothing: float = 0,
+    transform_y: Optional[str] = None,
+    outliers: str = "show",
+    sample_size: int = 100,
+    legend: Optional[List[Dict[str, Any]]] = None,
+    locked: bool = False,
+) -> Dict[str, Any]:
+    """A line chart of one or more metrics over an x-axis.
+
+    Args:
+        y: metric name, or a list of metric names to overlay in one chart.
+        x: "step", "duration", "epoch", "wall", or any logged metric name.
+        transform_y: None, "log", "ln", "sqrt" -- y-axis transform.
+        smoothing: 0..1 exponential smoothing factor.
+        outliers: "show" or "hide".
+        sample_size: max points fetched per curve.
+        locked: True pins this panel's config against dashboard-level changes.
+    """
+    metric_names = [y] if isinstance(y, str) else list(y)
+    return {
+        "chartType": "line",
+        "chartId": new_id(),
+        "chartName": name,
+        "selectedXAxis": x,
+        "selectedYAxis": metric_names[0],
+        "selectedOutliers": outliers,
+        "selectedLegendKeys": legend or DEFAULT_LEGEND,
+        "transformX": None,
+        "transformY": transform_y,
+        "smoothingX": 0,
+        "smoothingY": smoothing,
+        "metricName": "",
+        "metricNames": metric_names,
+        "locked": locked,
+        "sampleSize": sample_size,
+    }
+
+
+def bar_panel(
+    metric: str,
+    name: str = "",
+    aggregation: str = "last",
+    orientation: str = "v",
+    plot_type: str = "BAR",
+    group_by_aggregation: Optional[str] = None,
+    legend: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    """A bar chart of one metric, one bar per experiment.
+
+    Args:
+        aggregation: how to reduce a metric's history to one number --
+            "last", "min", "max", "average", "sum".
+        orientation: "v" (vertical bars) or "h".
+        plot_type: "BAR", "BOX", or "VIOLIN".
+        group_by_aggregation: if set (e.g. "mean"), bars are grouped and
+            aggregated instead of one-per-experiment.
+    """
+    return {
+        "chartType": "bar",
+        "chartId": new_id(),
+        "chartName": name,
+        "selectedXAxis": metric,
+        "metricName": metric,
+        "aggregationX": aggregation,
+        "orientation": orientation,
+        "plotType": plot_type,
+        "grouping": {
+            "enabled": group_by_aggregation is not None,
+            "plotType": plot_type,
+            "aggregation": group_by_aggregation or "mean",
+        },
+        "customRange": {"x": {"min": "", "max": ""}, "y": {"min": "", "max": ""}},
+        "selectedLegendKeys": legend or DEFAULT_LEGEND,
+    }
+
+
+def scatter_panel(
+    x: str,
+    y: str,
+    z: Optional[str] = None,
+    name: str = "",
+    aggregation: str = "last",
+    metrics: Optional[List[str]] = None,
+    params: Optional[List[str]] = None,
+    outliers: str = "show",
+    sample_size: int = 100,
+    legend: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    """A 2D or 3D scatter plot; one point per experiment.
+
+    Axes may be metric names or hyperparameter names. Pass ``z`` for a 3D plot.
+    ``metrics``/``params`` declare which of the axes are metrics vs params; when
+    omitted every axis is treated as a metric.
+    """
+    axes = [a for a in (x, y, z) if a]
+    panel = {
+        "chartType": "scatter",
+        "chartId": new_id(),
+        "chartName": name,
+        "selectedXAxis": x,
+        "selectedYAxis": y,
+        "selectedOutliers": outliers,
+        "sampleSize": sample_size,
+        "selectedLegendKeys": legend or DEFAULT_LEGEND,
+        "aggregationX": aggregation,
+        "aggregationY": aggregation,
+        "metrics": metrics if metrics is not None else [],
+        "params": params or [],
+        "metricName": "",
+        "metricNames": axes if metrics is None else metrics,
+        "annotations": {
+            "MIN_Y": {"name": "MIN_Y", "label": "Min y-values", "checked": False},
+            "MAX_Y": {"name": "MAX_Y", "label": "Max y-values", "checked": False},
+            "AVG_Y": {"name": "AVG_Y", "label": "Avg y-values", "checked": False},
+        },
+        "customRange": {"x": {"min": "", "max": ""}, "y": {"min": "", "max": ""}},
+        "legendMode": "auto",
+        "locked": False,
+        "fromChart": False,
+    }
+    if z:
+        panel["selectedZAxis"] = z
+        panel["aggregationZ"] = aggregation
+    return panel
+
+
+def parallel_panel(
+    params: Sequence[str],
+    metrics: Sequence[str] = (),
+    target: str = "",
+    name: str = "",
+    precision: str = ".3f",
+) -> Dict[str, Any]:
+    """A parallel-coordinates chart -- the standard hyperparameter sweep view.
+
+    Args:
+        params: hyperparameter names, drawn as axes left to right.
+        metrics: metric names, drawn as the right-most axes.
+        target: which axis colors the lines (usually a metric, e.g. "loss").
+    """
+    return {
+        "chartType": "parallel",
+        "chartId": new_id(),
+        "chartName": name,
+        "params": list(params),
+        "metrics": list(metrics),
+        "selectedTargetVariable": target or (list(metrics)[0] if metrics else ""),
+        "selectedDecimalPrecision": precision,
+        "locked": False,
+    }
+
+
+def scalar_panel(
+    metric: str,
+    aggregation: str = "last",
+    name: str = "",
+    precision: int = 3,
+    description: Optional[str] = None,
+) -> Dict[str, Any]:
+    """A single big-number tile.
+
+    Args:
+        aggregation: "last", "min", "max", "average", "sum".
+        description: subtitle. Defaults to Comet's generated wording.
+    """
+    return {
+        "chartType": "scalar",
+        "chartId": new_id(),
+        "chartName": name,
+        "metricName": metric,
+        "paramName": "",
+        "aggregation": aggregation,
+        "precision": precision,
+        "description": description
+        or "The %s value of %s metric" % (aggregation, metric),
+        "isCustomDescription": description is not None,
+        "isNumber": True,
+        "locked": False,
+    }
+
+
+def image_panel(
+    images: Sequence[str] = (),
+    step: Optional[int] = None,
+    name: str = "",
+    experiments_count: int = 25,
+) -> Dict[str, Any]:
+    """An image-grid panel showing logged images across experiments.
+
+    Args:
+        images: logged image file names to display. Empty means "all".
+        step: pin the grid to one step; None follows the dashboard.
+    """
+    return {
+        "chartType": "image",
+        "chartId": new_id(),
+        "chartName": name,
+        "images": list(images),
+        "step": step,
+        "experimentsCount": experiments_count,
+    }
+
+
+def data_panel(
+    file_name: str,
+    name: str = "",
+    axis: int = 0,
+    join_type: str = "outer",
+    experiments_count: int = 25,
+) -> Dict[str, Any]:
+    """A table panel rendering a logged tabular asset (e.g. a .csv).
+
+    Args:
+        file_name: the logged asset's file name, as passed to log_table().
+        axis: 0 concatenates rows across experiments, 1 concatenates columns.
+        join_type: "outer" or "inner", when combining across experiments.
+    """
+    return {
+        "chartType": "data",
+        "chartId": new_id(),
+        "chartName": name,
+        "fileName": file_name,
+        "index": None,
+        "hasData": True,
+        "experimentsCount": experiments_count,
+        "axis": axis,
+        "joinType": join_type,
+        "columnFilters": None,
+        "columnState": None,
+    }
+
+
+def custom_panel(
+    instance_id: str,
+    instance_name: str = "",
+    name: str = "",
+    default_config: str = "",
+) -> Dict[str, Any]:
+    """A JavaScript custom panel from the Panel gallery.
+
+    ``instance_id``/``instance_name`` identify an existing panel instance and
+    cannot be invented -- copy them off a panel already on a dashboard (scan
+    existing views with ``get_views()``) or from the panel's URL in the UI.
+    """
+    panel = {
+        "chartType": "custom",
+        "chartId": new_id(),
+        "instanceId": instance_id,
+        "instanceName": instance_name,
+    }
+    if name:
+        panel["chartName"] = name
+    if default_config:
+        panel["defaultConfig"] = default_config
+    return panel
+
+
+def python_panel(
+    template_id: str,
+    revision_id: str = "",
+    name: str = "",
+    code_version: str = "",
+) -> Dict[str, Any]:
+    """A Python panel (a saved Python panel template rendered server-side).
+
+    Like ``custom_panel``, the ids refer to an existing saved panel template.
+    """
+    return {
+        "chartType": "python",
+        "chartId": new_id(),
+        "chartName": name,
+        "templateId": template_id,
+        "revisionId": revision_id,
+        "codeVersion": code_version,
+        "code": None,
+        "locked": False,
+    }
+
+
+# Every legacy chart_state bucket, so older readers see a well-formed dict.
+_LEGACY_BUCKETS = [
+    "line",
+    "scatter",
+    "bar",
+    "parallel",
+    "scalar",
+    "image",
+    "data",
+    "custom",
+    "video",
+    "pcd",
+    "curves",
+    "python",
+    "autoGeneratedMetrics",
+    "autoGeneratedCurve",
+    "autoGeneratedImage",
+    "autoGeneratedDataframe",
+]
+
+
+# ---------------------------------------------------------------------------
+# Sections
+# ---------------------------------------------------------------------------
+
+
+class Section:
+    """A titled, collapsible group of panels on a dashboard.
+
+    Args:
+        title: the section header shown in the UI.
+        panels: panel dicts from the factories above.
+        columns: panels per row (1, 2, 3, or 6). Panels flow left to right.
+        expanded: whether the section starts open.
+        height: row height in grid units (1 is the UI default, max 3).
+    """
+
+    def __init__(
+        self,
+        title: str,
+        panels: Sequence[Dict[str, Any]] = (),
+        columns: int = 3,
+        expanded: bool = True,
+        height: int = 1,
+    ):
+        if GRID_WIDTH % columns:
+            raise ValueError("columns must divide %d evenly" % GRID_WIDTH)
+        self.title = title
+        self.panels = list(panels)
+        self.columns = columns
+        self.expanded = expanded
+        self.height = height
+        self.id = new_id()
+
+    def add(self, *panels: Dict[str, Any]) -> "Section":
+        """Append panels; returns self so calls can be chained."""
+        self.panels.extend(panels)
+        return self
+
+    def layout(self) -> List[Dict[str, Any]]:
+        """Compute the react-grid-layout entries for this section's panels."""
+        width = GRID_WIDTH // self.columns
+        entries = []
+        for index, panel in enumerate(self.panels):
+            entries.append(
+                {
+                    "i": panel["chartId"],
+                    "x": (index % self.columns) * width,
+                    "y": (index // self.columns) * self.height,
+                    "w": width,
+                    "h": self.height,
+                    "minW": 2,
+                    "maxH": 3,
+                    "moved": False,
+                    "static": False,
+                }
+            )
+        return entries
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "autogenerated": False,
+            "expanded": self.expanded,
+            "panels": self.panels,
+            "layout": self.layout(),
+        }
+
+
+# ---------------------------------------------------------------------------
+# Dashboard-level state
+# ---------------------------------------------------------------------------
+
+
+def global_config(
+    x_axis: str = "step",
+    smoothing: float = 0,
+    transform_y: Optional[str] = None,
+    outliers: str = "show",
+    sample_size: int = 100,
+) -> Dict[str, Any]:
+    """Dashboard-wide defaults applied to every non-``locked`` panel."""
+    return {
+        "selectedXAxis": x_axis,
+        "transformY": transform_y,
+        "smoothingY": smoothing,
+        "selectedOutliers": outliers,
+        "sampleSize": sample_size,
+    }
+
+
+def table_state(
+    columns: Sequence[str] = (),
+    sort_by: Optional[str] = None,
+    descending: bool = True,
+    page_size: int = 25,
+    decimals: int = 6,
+    visible: bool = True,
+    column_width: int = 150,
+) -> str:
+    """Serialize the experiment-table configuration (``reactGridTableState``).
+
+    Args:
+        columns: column ids, in display order. Metric and parameter names work
+            directly; UI columns include "Name", "duration", "experimentTags",
+            "end_server_timestamp", "user_name".
+        sort_by: column to sort on.
+    """
+    fixed = ["pinned", "singleExperimentBtn", "isVisibleOnDashboard"]
+    ordered = fixed + [c for c in columns if c not in fixed]
+    state = {
+        "columnGrouping": [],
+        "columnOrders": ordered,
+        "columnSorting": (
+            [{"columnName": sort_by, "direction": "desc" if descending else "asc"}]
+            if sort_by
+            else []
+        ),
+        "columnWidths": [
+            {"columnName": c, "width": column_width} for c in ordered if c not in fixed
+        ],
+        "decimalsPrecision": decimals,
+        "expandedGroups": [],
+        "isVisible": visible,
+        "pageSize": page_size,
+        "selection": [],
+        "hiddenExperiments": [],
+    }
+    return json.dumps(state)
+
+
+def rule(
+    field: str,
+    operator: str,
+    value: Any,
+    source: str = "metrics",
+    type_: Optional[str] = None,
+) -> Dict[str, Any]:
+    """One filter condition.
+
+    Args:
+        field: metric / parameter / column name.
+        operator: "greater", "less", "equal", "not_equal", "contains",
+            "not_contains", "is_not_empty", "begins_with".
+        source: "metrics", "params", "log_other", "tags", "metadata".
+        type_: value type -- inferred from ``value`` when omitted
+            ("double", "string", "boolean").
+    """
+    if type_ is None:
+        if isinstance(value, bool):
+            type_ = "boolean"
+        elif isinstance(value, (int, float)):
+            type_ = "double"
+        else:
+            type_ = "string"
+    return {
+        "type": type_,
+        "field": field,
+        "source": source,
+        "value": value,
+        "operator": operator,
+    }
+
+
+def all_of(*rules: Dict[str, Any]) -> Dict[str, Any]:
+    """AND-group of rules; use as one branch inside ``query_state``."""
+    return {"condition": "AND", "rules": list(rules)}
+
+
+def any_of(*groups: Dict[str, Any]) -> Dict[str, Any]:
+    """OR of AND-groups -- the shape the filter builder produces."""
+    return {"condition": "OR", "rules": list(groups) or [all_of()]}
+
+
+def query_state(
+    rules_tree: Optional[Dict[str, Any]] = None, segment_id: str = ""
+) -> str:
+    """Serialize the filter state (``experimentQueryState``).
+
+    Example:
+        query_state(any_of(all_of(rule("accuracy", "greater", 0.9))))
+    """
+    return json.dumps(
+        {
+            "activeSegment": {"segment_id": segment_id},
+            "rulesTree": rules_tree or any_of(),
+            "filters": [],
+        }
+    )
+
+
+# ---------------------------------------------------------------------------
+# Assembly
+# ---------------------------------------------------------------------------
+
+
+def build_view(
+    name: str,
+    sections: Sequence[Section],
+    filters: Optional[str] = None,
+    table: Optional[str] = None,
+    config: Optional[Dict[str, Any]] = None,
+    auto_generate: bool = False,
+    personal: bool = False,
+) -> View:
+    """Assemble sections into a ``View`` ready for ``create_view``.
+
+    Args:
+        name: the view's display name.
+        sections: ``Section`` objects, top to bottom.
+        filters: output of ``query_state()``, or None for no filtering.
+        table: output of ``table_state()``, or None to keep the UI default.
+        config: output of ``global_config()``.
+        auto_generate: True lets Comet append auto-generated panels for
+            newly logged metrics underneath your sections.
+        personal: mark the view as personal (visible only to you).
+
+    Returns:
+        A ``View``. Pass it to ``API.create_view(workspace, project, view)`` or
+        ``APIExperiment.create_view(view)``.
+    """
+    section_dicts = [s.to_dict() for s in sections]
+    all_panels = [p for s in section_dicts for p in s["panels"]]
+
+    v3 = {
+        "layout": [],  # legacy top-level mirror; sections carry the real layout
+        "globalConfig": config or global_config(),
+        "sections": section_dicts,
+        "autoGenerate": auto_generate,
+        "isPersonalView": personal,
+    }
+
+    charts: Dict[str, Any] = {bucket: [] for bucket in _LEGACY_BUCKETS}
+    for panel in all_panels:
+        charts.setdefault(panel["chartType"], []).append(panel)
+    charts["numberOfCharts"] = len(all_panels)
+
+    return View(
+        name=name,
+        chart_state=json.dumps({"charts": charts, "layout": None}),
+        query_state=filters if filters is not None else query_state(),
+        table_state=table,
+        v2={
+            "toggles": {
+                "DASHBOARD_TOGGLE": {"toggleId": "DASHBOARD_TOGGLE", "isToggled": True},
+                "EXPERIMENT_TABLE_TOGGLE": {
+                    "toggleId": "EXPERIMENT_TABLE_TOGGLE",
+                    "isToggled": True,
+                },
+            }
+        },
+        v3=v3,
+    )
+
+
+def build_experiment_view(
+    name: str,
+    sections: Sequence[Section],
+    x_axis: str = "step",
+    smoothing: float = 0,
+    transform_y: Optional[str] = None,
+    sample_size: int = 100,
+    auto_generate: bool = False,
+    auto_refresh: bool = True,
+    media_sort_by: str = "name",
+    media_order: str = "desc",
+    group_media: bool = False,
+) -> View:
+    """Assemble sections into a ``View`` for ``APIExperiment.create_view``.
+
+    Experiment-scoped views are stored in the chart-template tables, which use a
+    different envelope than project dashboards: everything lives under ``v2``
+    (sections inside ``v2["panels"]``), and the per-tab display settings for
+    images / text / audio / histograms / confusion matrices sit alongside them.
+
+    Args:
+        name: the view's display name.
+        sections: ``Section`` objects -- the same ones ``build_view`` takes.
+        x_axis: "step", "duration", "wall", or "epoch".
+        smoothing: 0..1 curve smoothing applied to every chart.
+        transform_y: None, "log", "ln", "sqrt".
+        sample_size: max points fetched per curve.
+        auto_generate: let Comet append auto panels for new metrics.
+        auto_refresh: refresh the view while the run is live.
+        media_sort_by / media_order / group_media: sorting of the image, audio
+            and text tabs.
+
+    Returns:
+        A ``View`` to pass to ``APIExperiment.create_view(view)``. Do not set
+        ``experiment_key`` -- ``create_view`` stamps it on for you.
+    """
+    media = {"groupBy": group_media, "orderBy": media_order, "sortBy": media_sort_by}
+    v2 = {
+        "template_name": name,
+        "x_axis": x_axis,
+        "smoothing": smoothing,
+        "transformY": transform_y,
+        "sampleSize": sample_size,
+        "entire_row_charts": False,
+        "charts": [],  # legacy per-experiment chart list; sections supersede it
+        "outliers": {"percentile": 0, "isVisible": True},
+        "panels": {
+            "version": 5,
+            "sections": [s.to_dict() for s in sections],
+            "panels": [],
+            "layout": [],
+            "compareXAxis": x_axis,
+            "autoGenerate": auto_generate,
+            "isAutoRefreshEnabled": auto_refresh,
+        },
+        "autoGeneratedDraft": False,
+        "deleteAutogenerated": False,
+        "projectName": "",
+        "project_id": "",
+        "metricColors": [],
+        "metricColorsV2": {
+            "singleExperiment": {
+                "isSingleExperimentColor": False,
+                "colors": [],
+                "singleExperimentColor": False,
+            }
+        },
+        "lastUpdate": 0,
+        "layout": [],
+        "images": dict(media),
+        "audio": dict(media),
+        "text": {
+            "groupBy": group_media,
+            "orderBy": media_order,
+            "sortBy": "step",
+            "fullHeightToggle": False,
+            "step": -1,
+        },
+        "confusionMatrix": {
+            "assetsIds": [],
+            "compareAssetsIds": [],
+            "cellValue": "Counts",
+            "colorDistribution": "Equal",
+        },
+        "histogram": {
+            "groupBy": group_media,
+            "ignoreOutliers": 0.1,
+            "maxSteps": 50,
+            "orderBy": media_order,
+            "sortBy": "name",
+        },
+        "metrics": {"decimalsPrecision": None},
+        "hyperParams": {"decimalsPrecision": None},
+        "otherParams": {"decimalsPrecision": None},
+    }
+    return View(name=name, v2=v2)
+
+
+# ---------------------------------------------------------------------------
+# Inspection
+# ---------------------------------------------------------------------------
+
+
+def describe_view(view: View, indent: str = "") -> str:
+    """Render a human-readable outline of a View's sections and panels."""
+    lines = ["%s%s" % (indent, view.name)]
+    meta = []
+    if view.view_source:
+        meta.append(view.view_source)
+    if view.template_id:
+        meta.append("id=%s" % view.template_id)
+    if view.experiment_key:
+        meta.append("experiment=%s" % view.experiment_key[:8])
+    if view.project_default:
+        meta.append("project default")
+    if meta:
+        lines.append("%s  [%s]" % (indent, ", ".join(meta)))
+
+    sections = None
+    if isinstance(view.v3, dict):
+        sections = view.v3.get("sections")
+    if not sections and isinstance(view.v2, dict):
+        # Experiment-scoped view: sections live under v2["panels"].
+        sections = (view.v2.get("panels") or {}).get("sections")
+    if sections:
+        for section in sections:
+            flag = " (auto)" if section.get("autogenerated") else ""
+            lines.append("%s  - section %r%s" % (indent, section.get("title"), flag))
+            for panel in section.get("panels", []):
+                lines.append("%s      * %s" % (indent, _panel_label(panel)))
+    else:
+        # Older view: read the legacy bucketed chart_state.
+        try:
+            charts = json.loads(view.chart_state or "{}").get("charts", {})
+        except ValueError:
+            charts = {}
+        panels = [p for v in charts.values() if isinstance(v, list) for p in v]
+        if panels:
+            lines.append("%s  - (legacy chart_state, no sections)" % indent)
+            for panel in panels:
+                lines.append("%s      * %s" % (indent, _panel_label(panel)))
+        else:
+            lines.append("%s  - (no panels)" % indent)
+
+    try:
+        tree = json.loads(view.query_state or "{}").get("rulesTree", {})
+    except ValueError:
+        tree = {}
+    conditions = [r for group in tree.get("rules", []) for r in group.get("rules", [])]
+    for condition in conditions:
+        lines.append(
+            "%s  filter: %s %s %r"
+            % (
+                indent,
+                condition.get("field"),
+                condition.get("operator"),
+                condition.get("value"),
+            )
+        )
+    return "\n".join(lines)
+
+
+def _panel_label(panel: Dict[str, Any]) -> str:
+    kind = panel.get("chartType", "?")
+    name = panel.get("chartName") or panel.get("instanceName") or ""
+    detail = (
+        panel.get("metricNames")
+        or panel.get("metricName")
+        or panel.get("fileName")
+        or panel.get("images")
+        or panel.get("params")
+        or ""
+    )
+    label = "%-9s %s" % (kind, name)
+    return "%s  %s" % (label.rstrip(), detail) if detail else label.rstrip()

{cometx-3.6.7 → cometx-3.6.8}/cometx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cometx
-Version: 3.6.7
+Version: 3.6.8
 Summary: Python tools for Comet
 Home-page: https://github.com/comet-ml/cometx/
 Author: cometx development team

{cometx-3.6.7 → cometx-3.6.8}/cometx.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ cometx/magics.py
 cometx/optimizer.py
 cometx/panel_utils.py
 cometx/utils.py
+cometx/views.py
 cometx.egg-info/PKG-INFO
 cometx.egg-info/SOURCES.txt
 cometx.egg-info/dependency_links.txt