wandb 0.17.0rc1__py3-none-macosx_11_0_arm64.whl

wandb/apis/reports/v1/report.py

@@ -0,0 +1,268 @@
+import base64
+import inspect
+import json
+import re
+import urllib
+from copy import deepcopy
+from typing import List as LList
+
+from .... import __version__ as wandb_ver
+from .... import termlog, termwarn
+from ....sdk.lib import ipython
+from ...public import Api as PublicApi
+from ...public import RetryingClient
+from ._blocks import P, PanelGrid, UnknownBlock, WeaveBlock, block_mapping, weave_blocks
+from .mutations import UPSERT_VIEW, VIEW_REPORT
+from .runset import Runset
+from .util import Attr, Base, Block, coalesce, generate_name, nested_get, nested_set
+from .validators import OneOf, TypeValidator
+
+
+class Report(Base):
+    project: str = Attr(json_path="viewspec.project.name")
+    entity: str = Attr(json_path="viewspec.project.entityName")
+    title: str = Attr(json_path="viewspec.displayName")
+    description: str = Attr(json_path="viewspec.description")
+    width: str = Attr(
+        json_path="viewspec.spec.width",
+        validators=[OneOf(["readable", "fixed", "fluid"])],
+    )
+    blocks: list = Attr(
+        json_path="viewspec.spec.blocks",
+        validators=[TypeValidator(Block, how="keys")],
+    )
+
+    def __init__(
+        self,
+        project,
+        entity=None,
+        title="Untitled Report",
+        description="",
+        width="readable",
+        blocks=None,
+        _api=None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self._viewspec = self._default_viewspec()
+        self._orig_viewspec = deepcopy(self._viewspec)
+        self._api = PublicApi() if _api is None else _api
+
+        self.project = project
+        self.entity = coalesce(entity, self._api.default_entity, "")
+        self.title = title
+        self.description = description
+        self.width = width
+        self.blocks = coalesce(blocks, [])
+
+    @classmethod
+    def from_url(cls, url, api=None):
+        if api is None:
+            api = PublicApi()
+        report_id = cls._url_to_report_id(url)
+        r = api.client.execute(VIEW_REPORT, variable_values={"reportId": report_id})
+        viewspec = r["view"]
+        viewspec["spec"] = json.loads(viewspec["spec"])
+        return cls.from_json(viewspec)
+
+    @staticmethod
+    def _url_to_report_id(url):
+        path_msg = "Path must be `entity/project/reports/report_title--report_id`"
+        try:
+            report_path, *_ = url.split("?")
+            report_path = report_path.replace("---", "--")
+
+            if "--" not in report_path:
+                raise ValueError(path_msg)
+
+            *_, report_id = report_path.split("--")
+            if len(report_id) == 0:
+                raise ValueError("Invalid report id")
+
+            report_id = report_id.strip()
+
+            """
+                Server does not generate IDs with correct padding, so decode with default validate=False.
+                Then re-encode it with correct padding.
+                https://stackoverflow.com/questions/2941995/python-ignore-incorrect-padding-error-when-base64-decoding
+
+                Corresponding core app logic that strips the padding in url
+                https://github.com/wandb/core/blob/b563437c1f3237ec35b1fb388ac14abbab7b4279/frontends/app/src/util/url/shared.ts#L33-L78
+            """
+            report_id = base64.b64encode(base64.b64decode(report_id + "==")).decode(
+                "utf-8"
+            )
+
+        except ValueError as e:
+            raise ValueError(path_msg) from e
+        else:
+            return report_id
+
+    @blocks.getter
+    def blocks(self):
+        json_path = self._get_path("blocks")
+        block_specs = nested_get(self, json_path)
+        blocks = []
+        for bspec in block_specs:
+            cls = block_mapping.get(bspec["type"], UnknownBlock)
+            if cls is UnknownBlock:
+                termwarn(
+                    inspect.cleandoc(
+                        f"""
+                        UNKNOWN BLOCK DETECTED
+                            This can happen if we have added new blocks, but you are using an older version of the SDK.
+                            If your report is loading normally, you can safely ignore this message (but we recommend not touching UnknownBlock)
+                            If you think this is an error, please file a bug report including your SDK version ({wandb_ver}) and this spec ({bspec})
+                        """
+                    )
+                )
+            if cls is WeaveBlock:
+                for cls in weave_blocks:
+                    try:
+                        cls.from_json(bspec)
+                    except Exception:
+                        pass
+                    else:
+                        break
+            blocks.append(cls.from_json(bspec))
+        return blocks[1:-1]  # accounts for hidden p blocks
+
+    @blocks.setter
+    def blocks(self, new_blocks):
+        json_path = self._get_path("blocks")
+        new_block_specs = (
+            [P("").spec] + [b.spec for b in new_blocks] + [P("").spec]
+        )  # hidden p blocks
+        nested_set(self, json_path, new_block_specs)
+
+    @staticmethod
+    def _default_viewspec():
+        return {
+            "id": None,
+            "name": None,
+            "spec": {
+                "version": 5,
+                "panelSettings": {},
+                "blocks": [],
+                "width": "readable",
+                "authors": [],
+                "discussionThreads": [],
+                "ref": {},
+            },
+        }
+
+    @classmethod
+    def from_json(cls, viewspec):
+        obj = cls(project=viewspec["project"]["name"])
+        obj._viewspec = viewspec
+        obj._orig_viewspec = deepcopy(obj._viewspec)
+        return obj
+
+    @property
+    def viewspec(self):
+        return self._viewspec
+
+    @property
+    def modified(self) -> bool:
+        return self._viewspec != self._orig_viewspec
+
+    @property
+    def spec(self) -> dict:
+        return self._viewspec["spec"]
+
+    @property
+    def client(self) -> "RetryingClient":
+        return self._api.client
+
+    @property
+    def id(self) -> str:
+        return self._viewspec["id"]
+
+    @property
+    def name(self) -> str:
+        return self._viewspec["name"]
+
+    @property
+    def panel_grids(self) -> "LList[PanelGrid]":
+        return [b for b in self.blocks if isinstance(b, PanelGrid)]
+
+    @property
+    def runsets(self) -> "LList[Runset]":
+        return [rs for pg in self.panel_grids for rs in pg.runsets]
+
+    @property
+    def url(self) -> str:
+        title = re.sub(r"\W", "-", self.title)
+        title = re.sub(r"-+", "-", title)
+        title = urllib.parse.quote(title)
+        id = self.id.replace("=", "")
+        app_url = self._api.client.app_url
+        if not app_url.endswith("/"):
+            app_url = app_url + "/"
+        return f"{app_url}{self.entity}/{self.project}/reports/{title}--{id}"
+
+    def save(self, draft: bool = False, clone: bool = False) -> "Report":
+        if not self.modified:
+            termwarn("Report has not been modified")
+
+        # create project if not exists
+        projects = self._api.projects(self.entity)
+        is_new_project = True
+        for p in projects:
+            if p.name == self.project:
+                is_new_project = False
+                break
+
+        if is_new_project:
+            self._api.create_project(self.project, self.entity)
+
+        # All panel grids must have at least one runset
+        for pg in self.panel_grids:
+            if not pg.runsets:
+                pg.runsets = PanelGrid._default_runsets()
+
+        # Check runsets with `None` for project and replace with the report's project.
+        # We have to do this here because RunSets don't know about their report until they're added to it.
+        for rs in self.runsets:
+            rs.entity = coalesce(rs.entity, self._api.default_entity)
+            rs.project = coalesce(rs.project, self.project)
+
+        r = self._api.client.execute(
+            UPSERT_VIEW,
+            variable_values={
+                "id": None if clone or not self.id else self.id,
+                "name": generate_name() if clone or not self.name else self.name,
+                "entityName": self.entity,
+                "projectName": self.project,
+                "description": self.description,
+                "displayName": self.title,
+                "type": "runs/draft" if draft else "runs",
+                "spec": json.dumps(self.spec),
+            },
+        )
+
+        viewspec = r["upsertView"]["view"]
+        viewspec["spec"] = json.loads(viewspec["spec"])
+        if clone:
+            return Report.from_json(viewspec)
+        else:
+            self._viewspec["id"] = viewspec["id"]
+            self._viewspec["name"] = viewspec["name"]
+            return self
+
+    def to_html(self, height: int = 1024, hidden: bool = False) -> str:
+        """Generate HTML containing an iframe displaying this report."""
+        try:
+            url = self.url + "?jupyter=true"
+            style = f"border:none;width:100%;height:{height}px;"
+            prefix = ""
+            if hidden:
+                style += "display:none;"
+                prefix = ipython.toggle_button("report")
+            return prefix + f"<iframe src={url!r} style={style!r}></iframe>"
+        except AttributeError:
+            termlog("HTML repr will be available after you save the report!")
+
+    def _repr_html_(self) -> str:
+        return self.to_html()

wandb/apis/reports/v1/runset.py

@@ -0,0 +1,144 @@
+from typing import Any, Dict, Optional, TypeVar
+
+from ...public import Api as PublicApi
+from ...public import PythonMongoishQueryGenerator, QueryGenerator, Runs
+from .util import Attr, Base, coalesce, generate_name, nested_get, nested_set
+
+T = TypeVar("T")
+
+
+class Runset(Base):
+    entity: Optional[str] = Attr(json_path="spec.project.entityName")
+    project: Optional[str] = Attr(json_path="spec.project.name")
+    name: str = Attr(json_path="spec.name")
+    query: str = Attr(json_path="spec.search.query")
+    filters: dict = Attr(json_path="spec.filters")
+    groupby: list = Attr(json_path="spec.grouping")
+    order: list = Attr(json_path="spec.sort")
+
+    def __init__(
+        self,
+        entity=None,
+        project=None,
+        name="Run set",
+        query="",
+        filters=None,
+        groupby=None,
+        order=None,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self._spec = self._default_runset_spec()
+        self.query_generator = QueryGenerator()
+        self.pm_query_generator = PythonMongoishQueryGenerator(self)
+
+        self.entity = coalesce(entity, PublicApi().default_entity, "")
+        self.project = project  # If the project is None, it will be updated to the report's project on save.  See: Report.save
+        self.name = name
+        self.query = query
+        self.filters = coalesce(filters, self._default_filters())
+        self.groupby = coalesce(groupby, self._default_groupby())
+        self.order = coalesce(order, self._default_order())
+
+    @classmethod
+    def from_json(cls, spec: Dict[str, Any]) -> T:
+        """This has a custom implementation because sometimes runsets are missing the project field."""
+        obj = cls()
+        obj._spec = spec
+
+        project = spec.get("project")
+        if project:
+            obj.entity = project.get(
+                "entityName", coalesce(PublicApi().default_entity, "")
+            )
+            obj.project = project.get("name")
+        else:
+            obj.entity = coalesce(PublicApi().default_entity, "")
+            obj.project = None
+
+        return obj
+
+    @filters.getter
+    def filters(self):
+        json_path = self._get_path("filters")
+        filter_specs = nested_get(self, json_path)
+        return self.query_generator.filter_to_mongo(filter_specs)
+
+    @filters.setter
+    def filters(self, new_filters):
+        json_path = self._get_path("filters")
+        new_filter_specs = self.query_generator.mongo_to_filter(new_filters)
+        nested_set(self, json_path, new_filter_specs)
+
+    def set_filters_with_python_expr(self, expr):
+        self.filters = self.pm_query_generator.python_to_mongo(expr)
+        return self
+
+    @groupby.getter
+    def groupby(self):
+        json_path = self._get_path("groupby")
+        groupby_specs = nested_get(self, json_path)
+        cols = [self.query_generator.key_to_server_path(k) for k in groupby_specs]
+        return [self.pm_query_generator.back_to_front(c) for c in cols]
+
+    @groupby.setter
+    def groupby(self, new_groupby):
+        json_path = self._get_path("groupby")
+        cols = [self.pm_query_generator.front_to_back(g) for g in new_groupby]
+        new_groupby_specs = [self.query_generator.server_path_to_key(c) for c in cols]
+        nested_set(self, json_path, new_groupby_specs)
+
+    @order.getter
+    def order(self):
+        json_path = self._get_path("order")
+        order_specs = nested_get(self, json_path)
+        cols = self.query_generator.keys_to_order(order_specs)
+        return [c[0] + self.pm_query_generator.back_to_front(c[1:]) for c in cols]
+
+    @order.setter
+    def order(self, new_orders):
+        json_path = self._get_path("order")
+        cols = [o[0] + self.pm_query_generator.front_to_back(o[1:]) for o in new_orders]
+        new_order_specs = self.query_generator.order_to_keys(cols)
+        nested_set(self, json_path, new_order_specs)
+
+    @property
+    def _runs_config(self) -> dict:
+        return {k: v for run in self.runs for k, v in run.config.items()}
+
+    @property
+    def runs(self) -> Runs:
+        return PublicApi().runs(
+            path=f"{self.entity}/{self.project}", filters=self.filters
+        )
+
+    @staticmethod
+    def _default_filters():
+        return {"$or": [{"$and": []}]}
+
+    @staticmethod
+    def _default_groupby():
+        return []
+
+    @staticmethod
+    def _default_order():
+        return ["-CreatedTimestamp"]
+
+    @staticmethod
+    def _default_runset_spec():
+        return {
+            "id": generate_name(),
+            "runFeed": {
+                "version": 2,
+                "columnVisible": {"run:name": False},
+                "columnPinned": {},
+                "columnWidths": {},
+                "columnOrder": [],
+                "pageSize": 10,
+                "onlyShowSelected": False,
+            },
+            "enabled": True,
+            "selections": {"root": 1, "bounds": [], "tree": []},
+            "expandedRowAddresses": [],
+        }

wandb/apis/reports/v1/templates.py

@@ -0,0 +1,7 @@
+# flake8: noqa
+from ._templates import (
+    create_customer_landing_page,
+    create_enterprise_report,
+    create_example_footer,
+    create_example_header,
+)