wizata-dsapi 2.1.0.dev16__tar.gz → 2.1.0.dev18__tar.gz

{wizata_dsapi-2.1.0.dev16 → wizata_dsapi-2.1.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.1.0.dev16
+Version: 2.1.0.dev18
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

wizata_dsapi-2.1.0.dev18/wizata_dsapi/plot.py

@@ -0,0 +1,104 @@
+import uuid
+from .api_dto import ApiDto
+
+
+class Plot(ApiDto):
+    """
+    A plot is a definition of a Plotly figure that can be stored and shared on Wizata.
+    :ivar plot_id: The UUID of the plot. None for a deployed plot, which is addressed
+        by ``key`` instead — see below.
+    :ivar name: A simple name helping the user identifying the plot.
+    :ivar figure: Plotly figure defining the plot itself.
+    :ivar key: DEV-6026 — the deterministic identity of a DEPLOYED plot,
+        ``<pipeline key>/<twin key>/<plot script>.<input dataframe>``. An experiment
+        plot is one blob per execution addressed by ``plot_id`` and fetched with
+        ``GET /plots/<id>/``; a deployed plot is one blob per (pipeline, twin, plot
+        step) that is overwritten, so it has no uuid at all. `plot_id` is deliberately
+        left None in that case rather than minted and dropped: a uuid that looks
+        addressable via ``GET /plots/<id>`` but is not would be its own trap. Note the
+        identity is the plot STEP — its script and input dataframe, both from the
+        pipeline definition — and not ``name``, which stays the display label, so
+        relabelling a chart cannot orphan its blob.
+    """
+
+    @classmethod
+    def route(cls):
+        return "plots"
+
+    @classmethod
+    def from_dict(cls, data):
+        obj = Plot()
+        obj.from_json(data)
+        return obj
+
+    def __init__(self, plot_id=None, name=None, figure=None, key=None):
+        # A keyed (deployed) plot gets NO uuid — see the `key` note on the class.
+        # Every other plot keeps minting one, so nothing that existed changes.
+        if plot_id is not None:
+            self.plot_id = plot_id
+        elif key is not None:
+            self.plot_id = None
+        else:
+            self.plot_id = uuid.uuid4()
+        self.name = name
+        self.figure = figure
+        self.key = key
+
+    def api_id(self) -> str:
+        """
+        Id of the plot (plot_id)
+        :return: string formatted UUID of the plot, None for a deployed plot — it is
+            not a backend entity, so there is no id to send.
+        """
+        if self.plot_id is None:
+            return None
+        return str(self.plot_id).upper()
+
+    def endpoint(self) -> str:
+        """
+        Name of the endpoints used to manipulate plots.
+        :return: Endpoint name.
+        """
+        return "Plots"
+
+    def from_json(self, obj):
+        """
+        Load the Plot entity from a dictionary representation of the Plot.
+        :param obj: Dict version of the Plot.
+        """
+        if "id" in obj.keys():
+            self.plot_id = uuid.UUID(obj["id"])
+        if "key" in obj.keys():
+            # A deployed plot: keyed, never uuid-addressed. Clearing plot_id undoes
+            # the uuid __init__ minted before from_json ran, so a round-tripped
+            # execution log does not grow a uuid that addresses nothing.
+            self.key = obj["key"]
+            self.plot_id = None
+        if "name" in obj.keys():
+            self.name = obj["name"]
+        if "figure" in obj.keys():
+            self.figure = obj["figure"]
+
+    def to_json(self, target: str = None):
+        """
+        Convert the plot to a dictionary compatible to JSON format.
+        :return: dictionary representation of the Plot object.
+        """
+        # A deployed plot carries its deterministic key and NO id. The execution log
+        # is what makes it traceable which run last wrote a plot, and `key` is what
+        # the deployed-plot endpoint reads — an "id" beside it would only invite a
+        # GET /plots/<id> that cannot answer.
+        if self.key is not None:
+            obj = {
+                "key": self.key
+            }
+        else:
+            obj = {
+                "id": str(self.plot_id)
+            }
+        if self.name is not None:
+            obj["name"] = self.name
+        if target is None or target != 'logs':
+            if self.figure is not None:
+                obj["figure"] = self.figure
+        return obj

wizata_dsapi-2.1.0.dev18/wizata_dsapi/version.py

@@ -0,0 +1 @@
+__version__ = "2.1.0.dev18"

{wizata_dsapi-2.1.0.dev16 → wizata_dsapi-2.1.0.dev18}/wizata_dsapi/wizata_dsapi_client.py

@@ -1124,7 +1124,12 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
             else:
                 raise ValueError('No plot has been fetch.')
         elif figure is not None:
-            return plotly.io.from_json(plot.figure)
+            # Read `figure`, not `plot.figure` — with only a figure passed there is no
+            # plot to read it from. A live plot's envelope carries the figure as the
+            # JSON string it was stored as, an experiment plot as a dict once decoded,
+            # and both must render.
+            return plotly.io.from_json(figure if isinstance(figure, str)
+                                       else json.dumps(figure))
         elif plot_id is not None:
             plot = self.get(Plot(plot_id=plot_id))
             if plot.figure is not None:
@@ -1156,6 +1161,90 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
         else:
             raise TypeError("execution must be an ExecutionLog")
 
+    @staticmethod
+    def _pipeline_ref(pipeline) -> str:
+        """
+        Path segment addressing a pipeline, from a key, a UUID or a Pipeline.
+
+        The live-plot route accepts both the key and the UUID, so a caller passes
+        whichever it already has. A Pipeline is asked for its key first: a deployed
+        plot is addressed by pipeline KEY everywhere else it appears (the blob path,
+        ExecutionLog.plots), so the key is the reference that matches what comes back.
+        """
+        if isinstance(pipeline, Pipeline):
+            reference = pipeline.key if pipeline.key is not None else pipeline.pipeline_id
+        else:
+            reference = pipeline
+        if reference is None:
+            raise ValueError("a pipeline key, UUID or Pipeline is required")
+        return urllib.parse.quote(str(reference), safe="")
+
+    def deployed_plots(self, pipeline, twin: str = None) -> list:
+        """
+        list a deployed pipeline's LIVE plots - what its deployments are currently
+        drawing, one per (twin, plot step).
+
+        A live plot is overwritten on every triggered run, so there is exactly one
+        current figure per plot and no history to page through. Fetch one with
+        :meth:`deployed_plot`. Experiment plots are elsewhere and unchanged - one blob
+        per execution, see :meth:`plots`.
+
+        :param pipeline: pipeline key, UUID or Pipeline - both references are accepted.
+        :param twin: hardware id, to list only that twin's plots.
+        :return: list of dict {pipelineKey, twin, script, dataframe, key, deploymentId,
+            produced, lastModified, size}. 'produced' is False when the definition has
+            this plot step but no run has written it yet.
+        """
+        response = self._process_request(
+            method="GET",
+            route=f"{Pipeline.route()}/{self._pipeline_ref(pipeline)}/plots/",
+            params={"twin": twin} if twin is not None else None
+        )
+        return response.json().get("results", [])
+
+    def deployed_plot(self,
+                      pipeline,
+                      script: str,
+                      dataframe: str,
+                      twin: str = None,
+                      shape: str = "figure") -> dict:
+        """
+        fetch one of a deployed pipeline's LIVE plots.
+
+        The plot step is identified by BOTH its script and its input dataframe - that
+        pair is the plot's identity, as :meth:`deployed_plots` lists it.
+
+        Returns the envelope, not the bare figure, because the provenance is the point:
+        a live plot is overwritten on every run and 'generatedAt' / 'executionId' say
+        which one wrote it. Render it with ``client.plot(figure=envelope["figure"])``.
+
+        :param pipeline: pipeline key, UUID or Pipeline - both references are accepted.
+        :param script: the plot step's script.
+        :param dataframe: the plot step's input dataframe.
+        :param twin: hardware id - required on a templated pipeline.
+        :param shape: 'figure' (default) for the stored Plotly figure, or 'data' for its
+            traces projected to 'series'.
+        :return: dict with {pipelineKey, twin, script, dataframe, name, executionId,
+            release, sha, imageId, generatedAt} plus 'figure', or 'series' and
+            'notProjected' when shape is 'data'.
+        """
+        if script is None or dataframe is None:
+            raise ValueError(
+                "script and dataframe are both parts of a plot's identity - pass both"
+            )
+        if shape not in ("figure", "data"):
+            raise ValueError(f"shape must be 'figure' or 'data', got {shape!r}")
+
+        params = {"script": script, "dataframe": dataframe, "format": shape}
+        if twin is not None:
+            params["twin"] = twin
+        response = self._process_request(
+            method="GET",
+            route=f"{Pipeline.route()}/{self._pipeline_ref(pipeline)}/plots/",
+            params=params
+        )
+        return response.json()
+
     def upload_model(self,
                      model_info: ModelInfo,
                      bytes_content = None):

{wizata_dsapi-2.1.0.dev16 → wizata_dsapi-2.1.0.dev18}/wizata_dsapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.1.0.dev16
+Version: 2.1.0.dev18
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

wizata_dsapi-2.1.0.dev16/wizata_dsapi/plot.py

@@ -1,70 +0,0 @@
-import uuid
-from .api_dto import ApiDto
-
-
-class Plot(ApiDto):
-    """
-    A plot is a definition of a Plotly figure that can be stored and shared on Wizata.
-    :ivar plot_id: The UUID of the plot.
-    :ivar name: A simple name helping the user identifying the plot.
-    :ivar figure: Plotly figure defining the plot itself.
-    """
-
-    @classmethod
-    def route(cls):
-        return "plots"
-
-    @classmethod
-    def from_dict(cls, data):
-        obj = Plot()
-        obj.from_json(data)
-        return obj
-
-    def __init__(self, plot_id=None, name=None, figure=None):
-        if plot_id is None:
-            self.plot_id = uuid.uuid4()
-        else:
-            self.plot_id = plot_id
-        self.name = name
-        self.figure = figure
-
-    def api_id(self) -> str:
-        """
-        Id of the plot (plot_id)
-        :return: string formatted UUID of the plot.
-        """
-        return str(self.plot_id).upper()
-
-    def endpoint(self) -> str:
-        """
-        Name of the endpoints used to manipulate plots.
-        :return: Endpoint name.
-        """
-        return "Plots"
-
-    def from_json(self, obj):
-        """
-        Load the Plot entity from a dictionary representation of the Plot.
-        :param obj: Dict version of the Plot.
-        """
-        if "id" in obj.keys():
-            self.plot_id = uuid.UUID(obj["id"])
-        if "name" in obj.keys():
-            self.name = obj["name"]
-        if "figure" in obj.keys():
-            self.figure = obj["figure"]
-
-    def to_json(self, target: str = None):
-        """
-        Convert the plot to a dictionary compatible to JSON format.
-        :return: dictionary representation of the Plot object.
-        """
-        obj = {
-            "id": str(self.plot_id)
-        }
-        if self.name is not None:
-            obj["name"] = self.name
-        if target is None or target != 'logs':
-            if self.figure is not None:
-                obj["figure"] = self.figure
-        return obj

wizata_dsapi-2.1.0.dev16/wizata_dsapi/version.py

@@ -1 +0,0 @@
-__version__ = "2.1.0.dev16"