pollen-smart-api 3.145.1__py3-none-any.whl

pollen_smart_api-3.145.1.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: pollen-smart-api
+Version: 3.145.1
+Summary: A Python client for the Pollen Smart 3 platform API
+Author: Pollen Metrology
+Author-email: contact@pollen-metrology.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: Other/Proprietary License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Requires-Dist: numpy <3,>=1.26
+Requires-Dist: opencv-contrib-python-headless <6,>=4.8
+Requires-Dist: pandas <4,>=2.2
+Requires-Dist: jsonschema ~=4.1
+Requires-Dist: typeguard ~=2.13
+Requires-Dist: requests ~=2.26
+Requires-Dist: types-requests ~=2.30
+Requires-Dist: python-dateutil ~=2.8
+Requires-Dist: uritools ~=4.0
+Requires-Dist: websocket-client ~=1.6
+

pollen_smart_api-3.145.1.dist-info/RECORD

@@ -0,0 +1,39 @@
+smapi/AbstractRestApi.py,sha256=xBkP7TuP6_-8lJlDzeKkfE82_NhGGNwGIA85YSAD3vU,9786
+smapi/AnalysisResultsRestApi.py,sha256=y5tYFUZUpNAKMoyKmPUl-EgXtQqMwetcif6SQqaIzwM,13149
+smapi/ChartRestApi.py,sha256=iDR2efg7ZGv0_lNYxEEx-xQVLFnSzOHxVXRJ4QkRb_Y,21949
+smapi/ClassificationRestApi.py,sha256=mVGRbP_OgyxTK6OOR62G2uZi1AqUY17VClWIK9erfIw,12448
+smapi/DataReference.py,sha256=TbeSPb5sCMrGOQKSkovwJJ-9qHEYD4eoe2gD3eY7fDY,4948
+smapi/DataTablesRestApi.py,sha256=9Cx7DhX2YIkYKwfolt--YvLETQCbV3bBLyg36SagGC4,7108
+smapi/EntitiesRestApi.py,sha256=dsDSI6gkY1F1LQ4HvzZvQMJurwrePRok9J0yZmStjdA,21402
+smapi/Error.py,sha256=p_Bm8UPlLT_cyeEW-AZpmw3kx0Eiqi-VyfTmFBnOU_4,3641
+smapi/FigureError.py,sha256=Ng6ZS24mmBi4dbhR4b4iZJ8zUJNU4INqqJowhhYSXto,40607
+smapi/FigureRestApi.py,sha256=uL0G8di44EKIh02mE09fGNR78kaxFv1gNr9l0VqA1oE,101324
+smapi/FileLoadersRestApi.py,sha256=_sG0eKnkV0VLiUnU6Odn2uEOHAiFeXS1fkdhGMBDoBI,7707
+smapi/FilesRestApi.py,sha256=C1-RGTRXIb96Zt9CKx-tM8HpqA4owzvYBtCuUKi6Btk,18594
+smapi/FolderRestApi.py,sha256=1_4QA9eqnBkJCh1BYtUbC_88Rr2Snrs6xe18SuTZ9eQ,13035
+smapi/ImagesRestApi.py,sha256=ntZtWlZ8m-22hPUAOUoZY9TOjt4IDsnI7UbHsM_cZDs,19198
+smapi/LicenseRestApi.py,sha256=H23OUDQ9SroDZdbrOK3vxDVY7tBO1T5901Vhv5cmev0,6305
+smapi/MeasurementResultsRestApi.py,sha256=nb7IfyDXm_9qBE8lDByNgunfl0ad7Yozli0OGpR7x10,10851
+smapi/MeasurementsRestApi.py,sha256=VmlyHwTP2D52YFskVoGBw1t4ypiWpUr0wJdw6zy2QiI,7151
+smapi/NegativeExamples.py,sha256=5vTSw4ij5HjjIrkmFRiCRfur3ndoNhm4MO5MdntWipY,4244
+smapi/PipelineExecutionPreviewsRestApi.py,sha256=8qM9bA5B-trLTW4kU6q0RuEvTAgUikqW4oAwNCi5hgw,2871
+smapi/PipelineExecutionRestApi.py,sha256=1I58CjnRpP9agIa3JJ5rZ-iAvBkbMNNivTMEXb4B1gU,77188
+smapi/PipelineExecutionforErrorTest.py,sha256=gu32-duFhPCvB-gvs_lJrgWHQkfSBzdWusuyYFk5nlU,27266
+smapi/PipelineRestApi.py,sha256=QcB1DI04eSz8PvKhzD6do5Z1iz54esqP9OeNV6zfD5Q,13309
+smapi/PlatformRestApi.py,sha256=sIDMPqh0NaoZU17WXOvrgz0MedkNsF3KbUK23CDp8TU,1853
+smapi/PluginRestApi.py,sha256=qOZ3I22sOXfHNQ4NAvLK5hBTeBV2LeBQVa42RBqppqA,10019
+smapi/RestApi.py,sha256=9M5bX731x0yWn9l1Z2NHIC0JExWlryLZ-MXy1uDJEE4,4761
+smapi/RestSession.py,sha256=D_ZlcXknetUOslGbBOtcyTIdJZa34fe3IO_sVC-HCV8,11056
+smapi/RestWebsocket.py,sha256=3wCXnge3vbRKlvOMuoWwqZvPThwhoznmiKD8IR-lJp8,8974
+smapi/SettingsRestApi.py,sha256=jHX5gdIrN5SUVi48o53dqYlsv6ZvxNozN56IVWzypRk,4766
+smapi/SignalRestApi.py,sha256=sIqdQUNScGlDpcC5reSBp_jne1wIJFa6N_Udr9Op53g,6979
+smapi/TrainingDataset.py,sha256=3p3fmsci6LdQryfBLgO2bhRK8k_Iw_M1CI5sIGEyMMM,11816
+smapi/UsersRestApi.py,sha256=x8Z_Fd4tqE5D_y-AzEMjrxFnV9jOOG_XUZTzFAucJp0,9803
+smapi/Utility.py,sha256=4iCdVzIR0lmn2fmOVQVVHYyozqe-zcX0jwzcRRPWH9I,8751
+smapi/WorkflowExecutionRestApi.py,sha256=5cWRbu3UlOXR3EIwAR7OIdF5qIVdHLBw7xxuO6u5OZk,14511
+smapi/WorkflowRestApi.py,sha256=GQhVSo2bgWHC3L2SvThkxRYf7Zaf98t8Qlxq6YFvnyM,21807
+smapi/__init__.py,sha256=rAMAcRdKP8fMbH1Dpql6iEoxMzaQLf2fyoFJ2K4cd5A,437
+pollen_smart_api-3.145.1.dist-info/METADATA,sha256=NZ6bOJ3ftypWYgFqXLeoY43_O8vrt7SPNeiffd5F1c4,713
+pollen_smart_api-3.145.1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+pollen_smart_api-3.145.1.dist-info/top_level.txt,sha256=-SBL2oeVNMe4PovQFzjVboFyQZcHSjsLTQjXyWV2yNg,6
+pollen_smart_api-3.145.1.dist-info/RECORD,,

pollen_smart_api-3.145.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pollen_smart_api-3.145.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+smapi

smapi/AbstractRestApi.py

@@ -0,0 +1,260 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------------------------- #
+#                                  Pollen Metrology PUBLIC PYTHON SDK                               #
+# ------------------------------------------------------------------------------------------------- #
+# [2014-2024] Pollen Metrology
+# All Rights Reserved.
+#
+# NOTICE:  All information contained herein is, and remains the property of Pollen Metrology.
+# The intellectual and technical concepts contained herein are  proprietary to Pollen Metrology and
+# may be covered by French, European and/or Foreign Patents, patents in process, and are protected
+# by trade secret or copyright law.
+# Dissemination of this information or reproduction of this material is strictly forbidden unless
+# prior written permission is obtained from Pollen Metrology.
+# ------------------------------------------------------------------------------------------------- #
+
+from __future__ import annotations
+
+from abc import ABC
+from typing import Dict, Any, Optional, Union
+
+import requests as req
+from requests.auth import HTTPBasicAuth
+from typeguard import typechecked
+
+from .Error import HttpError
+from .Utility import ConnectionInformation
+
+# ================================================================================================= #
+
+
+@typechecked
+class AbstractRestApi(ABC):
+    """Base class for all smapi RestApi classes.
+
+    This class provides access to low-level HTTP communication functions for interacting with Smart3 REST API.
+    """
+
+    __slots__ = ("connexion", "apiVersion")
+
+    @typechecked
+    class LowLevel(object):
+        """Low-level HTTP communication"""
+
+        __slots__ = ("api",)
+
+        def __init__(self, abstractApi: "AbstractRestApi"):
+            self.api: AbstractRestApi = abstractApi
+
+        def get(self, entrypoint: str) -> Union[bytes, Dict, bool]:
+            """Sends a GET request to the specified entrypoint."""
+            return self.api._get(entrypoint)
+
+        def delete(self, entrypoint: str) -> Union[bytes, Dict, bool]:
+            """Sends a DELETE request to the specified entrypoint."""
+            return self.api._delete(entrypoint)
+
+        def put(self, entrypoint: str, **kwargs: Any) -> Union[bytes, Dict, bool]:
+            """Sends a PUT request to the specified entrypoint with the provided payload."""
+            return self.api._put(entrypoint, payload=kwargs)
+
+        def post(self, entrypoint: str, **kwargs: Any) -> Union[bytes, Dict, bool]:
+            """Sends a POST request to the specified entrypoint with optional payload, files, and parameters."""
+            return self.api._post(entrypoint, payload=kwargs)
+
+    def __init__(self, connexion: ConnectionInformation, apiVersion: str = "api/1.0"):
+        #: Current connection information including session ID and authentication details.
+        self.connexion: ConnectionInformation = connexion
+        #: Version of the REST API being accessed, default is "api/1.0".
+        self.apiVersion: str = apiVersion
+
+    @property
+    def __auth_cookie(self) -> Dict[str, str]:
+        return dict(sessionId=str(self.connexion.session_id))
+
+    def __url(self, entrypoint: str) -> str:
+        return f"{self.connexion.root_uri}/{self.apiVersion}/{entrypoint}"
+
+    @property
+    def ll(self) -> LowLevel:
+        return AbstractRestApi.LowLevel(self)
+
+    @staticmethod
+    def __check_and_return(
+        response: req.Response, as_binary: bool = False
+    ) -> Union[bytes, Dict, bool]:
+        if response.status_code != req.codes.ok:
+            raise HttpError(response)
+        if as_binary:
+            return response.content
+        if len(response.content) == 0:
+            return True
+        return response.json()
+
+    def _get(self, entrypoint: str, params: Optional[Dict] = None) -> Union[bytes, Dict, bool]:
+        result: req.Response
+        if self.connexion.session_id is not None:
+            result = req.get(
+                url=self.__url(entrypoint),
+                params=params or dict(),
+                cookies=self.__auth_cookie,
+                timeout=self.connexion.timeout,
+            )
+        else:
+            result = req.get(
+                url=self.__url(entrypoint),
+                params=params or dict(),
+                auth=HTTPBasicAuth(
+                    self.connexion.basic_auth_username,
+                    self.connexion.basic_auth_password,
+                ),
+                timeout=self.connexion.timeout,
+            )
+        return AbstractRestApi.__check_and_return(result)
+
+    def _get_binary(self, entrypoint: str) -> Union[bytes, Dict, bool]:
+        result: req.Response
+        if self.connexion.session_id is not None:
+            result = req.get(
+                url=self.__url(entrypoint),
+                cookies=self.__auth_cookie,
+                timeout=self.connexion.timeout,
+            )
+        else:
+            result = req.get(
+                url=self.__url(entrypoint),
+                auth=HTTPBasicAuth(
+                    self.connexion.basic_auth_username,
+                    self.connexion.basic_auth_password,
+                ),
+                timeout=self.connexion.timeout,
+            )
+
+        return AbstractRestApi.__check_and_return(result, as_binary=True)
+
+    def _post_and_return_binary(
+        self, entrypoint: str, payload: Optional[Dict] = None
+    ) -> Union[bytes, Dict, bool]:
+        result: req.Response
+        if self.connexion.session_id is not None:
+            result = req.post(
+                url=self.__url(entrypoint),
+                json=payload,
+                cookies=self.__auth_cookie,
+                timeout=self.connexion.timeout,
+            )
+        else:
+            result = req.post(
+                url=self.__url(entrypoint),
+                json=payload,
+                auth=HTTPBasicAuth(
+                    self.connexion.basic_auth_username,
+                    self.connexion.basic_auth_password,
+                ),
+                timeout=self.connexion.timeout,
+            )
+
+        return AbstractRestApi.__check_and_return(result, as_binary=True)
+
+    def _post(
+        self,
+        entrypoint: str,
+        payload: Optional[Dict] = None,
+        files: Optional[Dict] = None,
+        parameters: Optional[Dict] = None,
+    ) -> Union[bytes, Dict, bool]:
+        result: req.Response
+        if self.connexion.session_id is not None:
+            result = req.post(
+                url=self.__url(entrypoint),
+                json=payload,
+                files=files,
+                params=parameters,
+                cookies=self.__auth_cookie,
+                timeout=self.connexion.timeout,
+            )
+        else:
+            result = req.post(
+                url=self.__url(entrypoint),
+                json=payload,
+                files=files,
+                params=parameters,
+                auth=HTTPBasicAuth(
+                    self.connexion.basic_auth_username,
+                    self.connexion.basic_auth_password,
+                ),
+                timeout=self.connexion.timeout,
+            )
+
+        return AbstractRestApi.__check_and_return(result)
+
+    def _put(
+        self, entrypoint: str, payload: Dict, parameters: Optional[Dict] = None
+    ) -> Union[bytes, Dict, bool]:
+        result: req.Response
+        if self.connexion.session_id is not None:
+            result = req.put(
+                url=self.__url(entrypoint),
+                json=payload,
+                params=parameters,
+                cookies=self.__auth_cookie,
+                timeout=self.connexion.timeout,
+            )
+        else:
+            result = req.put(
+                url=self.__url(entrypoint),
+                json=payload,
+                params=parameters,
+                auth=HTTPBasicAuth(
+                    self.connexion.basic_auth_username,
+                    self.connexion.basic_auth_password,
+                ),
+                timeout=self.connexion.timeout,
+            )
+
+        return AbstractRestApi.__check_and_return(result)
+
+    def _delete(self, entrypoint: str, payload: Optional[Dict] = None) -> Union[bytes, Dict, bool]:
+        result: req.Response
+        if payload is None:
+            if self.connexion.session_id is not None:
+                result = req.delete(
+                    url=self.__url(entrypoint),
+                    cookies=self.__auth_cookie,
+                    timeout=self.connexion.timeout,
+                )
+            else:
+                result = req.delete(
+                    url=self.__url(entrypoint),
+                    auth=HTTPBasicAuth(
+                        self.connexion.basic_auth_username,
+                        self.connexion.basic_auth_password,
+                    ),
+                    timeout=self.connexion.timeout,
+                )
+
+            return AbstractRestApi.__check_and_return(result)
+
+        else:
+            if self.connexion.session_id is not None:
+                result = req.delete(
+                    url=self.__url(entrypoint),
+                    json=payload,
+                    cookies=self.__auth_cookie,
+                    timeout=self.connexion.timeout,
+                )
+            else:
+                result = req.delete(
+                    url=self.__url(entrypoint),
+                    json=payload,
+                    auth=HTTPBasicAuth(
+                        self.connexion.basic_auth_username,
+                        self.connexion.basic_auth_password,
+                    ),
+                    timeout=self.connexion.timeout,
+                )
+
+            return AbstractRestApi.__check_and_return(result)
+
+
+# ================================================================================================= #

smapi/AnalysisResultsRestApi.py

@@ -0,0 +1,322 @@
+# -*- coding: utf-8 -*-
+# ------------------------------------------------------------------------------------------------- #
+#                                  Pollen Metrology PUBLIC PYTHON SDK                               #
+# ------------------------------------------------------------------------------------------------- #
+# [2014-2024] Pollen Metrology
+# All Rights Reserved.
+#
+# NOTICE:  All information contained herein is, and remains the property of Pollen Metrology.
+# The intellectual and technical concepts contained herein are  proprietary to Pollen Metrology and
+# may be covered by French, European and/or Foreign Patents, patents in process, and are protected
+# by trade secret or copyright law.
+# Dissemination of this information or reproduction of this material is strictly forbidden unless
+# prior written permission is obtained from Pollen Metrology.
+# ------------------------------------------------------------------------------------------------- #
+
+from typing import List, Dict, Union, Optional
+from uuid import UUID
+
+from typeguard import typechecked
+
+from .AbstractRestApi import AbstractRestApi
+from .ChartRestApi import ChartInformation
+from .DataReference import DataReference
+
+# ================================================================================================= #
+
+
+@typechecked
+class Analysis(DataReference):
+    """Analysis result.
+
+    This class represents an analysis result, including entities, relationships, masks,
+    messages, tables, charts, and metadata. It provides methods to compare analysis results and
+    to create instances from dictionaries.
+    """
+
+    __slots__ = (
+        "entities",
+        "relationships",
+        "masks",
+        "messages",
+        "tables",
+        "charts",
+        "metadata",
+        "created_at",
+        "updated_at",
+    )
+
+    def __init__(self, attributes: Dict, relationships: Dict, identifier: Optional[str] = None):
+        """Initializes the Analysis object with attributes and relationships.
+
+        Args:
+            attributes (Dict): A dictionary containing attributes of the analysis.
+            relationships (Dict): A dictionary containing relationships of the analysis.
+            identifier (Optional[str]): An optional identifier for the analysis.
+        """
+        super(Analysis, self).__init__(identifier)
+
+        #: List of entities in the analysis results.
+        self.entities: Optional[List[Dict]] = attributes.get("entities", [])
+        #: List of image masks in the analysis results.
+        self.masks: Optional[Dict] = attributes.get("masks")
+        #: List of messages displayed in the bottom panel for the analysis results.
+        self.messages: Optional[List[Dict]] = attributes.get("messages")
+        #: Relationships of the analysis results. Can be identifiers of image or folder.
+        self.relationships: Optional[Dict] = relationships.get("id")
+        #: List of tables in the analysis results.
+        self.tables: Optional[List[Dict]] = attributes.get("tables")
+        #: List of charts in the analysis results.
+        self.charts: List[ChartInformation] = [
+            ChartInformation(**c) for c in attributes.get("charts") or list()
+        ]
+        #: Additional metadata related to the analysis results.
+        self.metadata: Optional[List[Dict]] = attributes.get("metadata")
+        #: Timestamp when the analysis result was created (ISO 8601 format).
+        self.created_at: Optional[str] = attributes.get("createdAt")
+        #: Timestamp when the analysis result was last updated (ISO 8601 format).
+        self.updated_at: Optional[str] = attributes.get("updatedAt")
+
+    def __repr__(self) -> str:
+        return str(self.identifier)
+
+    @staticmethod
+    def data_from_dictionary_internal(dictionary: Dict) -> "Analysis":
+        if "id" not in dictionary or "attributes" not in dictionary:
+            raise RuntimeError("Unable to create the analysis result information !")
+
+        return Analysis(
+            identifier=dictionary.get("id"),
+            attributes=dictionary.get("attributes"),
+            relationships=dictionary.get("relationships"),
+        )
+
+    def measurements_equivalent(
+        self, meas0: List[dict], meas1: List[dict], uuidMap: Dict[UUID, UUID]
+    ) -> bool:
+        """Compares two sets of measurements for equivalence.
+
+        Args:
+            meas0 (List[dict]): The first set of measurements.
+            meas1 (List[dict]): The second set of measurements.
+            uuidMap (Dict[UUID, UUID]): A mapping of UUIDs for comparison.
+
+        Returns:
+            bool: True if the measurements are equivalent, False otherwise.
+        """
+        for m0, m1 in zip(meas0, meas1):
+            if set(m0.keys()) != set(m1.keys()):
+                return False
+
+            for k, v in m0.items():
+                if k == "value" and v is not None:
+                    if isinstance(v, float) or isinstance(v, int):
+                        if round(v, 9) != round(m1[k], 9):
+                            return False
+                    elif isinstance(v, dict) and "x" in v and "y" in v:
+                        g_value: bool = (
+                            round(v["x"][0]),
+                            round(v["x"][1]),
+                            round(v["y"][0]),
+                            round(v["y"][1]),
+                        ) == (
+                            round(m1[k]["x"][0]),
+                            round(m1[k]["x"][1]),
+                            round(m1[k]["y"][0]),
+                            round(m1[k]["y"][1]),
+                        )
+                        if not g_value:
+                            return False
+                elif k == "id" or k == "geometry1Id" or k == "geometry2Id":
+                    if uuidMap[UUID(m0[k])] != UUID(m1[k]):
+                        return False
+                elif k == "values":
+                    self.measurements_equivalent(v, m1[k], uuidMap)
+                else:
+                    if v != m1[k]:
+                        return False
+        return True
+
+    def equivalent(self, other, uuidMap: Dict[UUID, UUID]) -> bool:
+        """Checks if two Analysis objects are equivalent.
+
+        Args:
+            other (Analysis): Another Analysis object to compare.
+            uuidMap (Dict[UUID, UUID]): A mapping of UUIDs for comparison.
+
+        Returns:
+            bool: True if the two Analysis objects are equivalent, False otherwise.
+        """
+        if self.entities or other.entities:
+            for e0, e1 in zip(self.entities, other.entities):
+                for k, _ in e0.items():
+                    if k == "id" and e0[k] == e1[k]:
+                        return False
+                    elif k == "classifications" and e0[k] is not None and e0[k] == e1[k]:
+                        return False
+                    elif k == "figures":
+                        for f0, f1 in zip(e0[k], e1[k]):
+                            equivalent: bool = (
+                                f0["controlPoints"] == f1["controlPoints"]
+                                and f0.get("metadata", dict()) == f1.get("metadata", dict())
+                                and f0["name"] == f1["name"]
+                                and f0["type"] == f1["type"]
+                                and f0["id"] != f1["id"]
+                            )
+                            if not equivalent:
+                                return False
+
+                            if f0.get("measurements") or f1.get("measurements"):
+                                equivalent: bool = self.measurements_equivalent(
+                                    f0.get("measurements"), f1.get("measurements"), uuidMap
+                                )
+                                if not equivalent:
+                                    return False
+
+                    elif k not in ("id", "figures", "classifications") and e0[k] != e1[k]:
+                        return False
+
+        if self.masks:
+            if not other.masks:
+                return False
+
+            for k, v in self.masks.items():
+                if isinstance(v, str) and v == other.masks[k]:
+                    return False
+                elif not isinstance(v, str) and self.masks[k] != other.masks[k]:
+                    return False
+
+        gdata: bool = (
+            self.messages,
+            self.metadata,
+            self.tables,
+        ) == (
+            other.messages,
+            other.metadata,
+            other.tables,
+        )
+        if not gdata:
+            return False
+
+        for ch0, ch1 in zip(self.charts, other.charts):
+            if not ch0.equivalent(ch1, uuidMap):
+                return False
+
+        return self.identifier != other.identifier
+
+    @classmethod
+    def type(cls: type) -> str:
+        """Return the string "AnalysisResults"."""
+        return "AnalysisResults"
+
+
+# ------------------------------------------------------------------------------------------------- #
+# ------------------------------------------------------------------------------------------------- #
+
+
+@typechecked
+class AnalysisResultsRestApi(AbstractRestApi):
+    """AnalysisResults REST API.
+
+    This class provides methods to interact with the AnalysisResults REST API, allowing
+    retrieval, deletion, and update of analysis results.
+    """
+
+    def all(self) -> List[Analysis]:
+        """Get all analysis results.
+
+        Returns:
+            List[Analysis]: The list of all analysis results.
+        """
+        data: Dict = self._get(entrypoint="analysisResults")
+        return Analysis.data_from_dictionary(data)
+
+    def get(self, identifier: Union[UUID, str]) -> Analysis:
+        """Get a specific analysis result.
+
+        Args:
+            identifier (Union[UUID, str]): The identifier of the analysis result to retrieve.
+
+        Returns:
+            Analysis: The requested analysis result.
+        """
+        data: Dict = self._get(entrypoint=f"analysisResults/{str(identifier)}")
+        return Analysis.data_from_dictionary(data)
+
+    def get_for_image(self, image_identifier: Union[UUID, str]) -> List[Analysis]:
+        """Get all analysis results for an image.
+
+        Args:
+            image_identifier (Union[UUID, str]): The identifier of the image.
+
+        Returns:
+            List[Analysis]: A list of analysis results related to the specified image.
+        """
+        data: Dict = self._get(entrypoint=f"analysisResults?filter[image]={str(image_identifier)}")
+        return Analysis.data_from_dictionary(data)
+
+    def get_for_folder(self, folder_identifier: Union[UUID, str]) -> List[Analysis]:
+        """Get all analysis results for a folder.
+
+        Args:
+            folder_identifier (Union[UUID, str]): The identifier of the folder.
+
+        Returns:
+            List[Analysis]: A list of analysis results related to the specified folder.
+        """
+        data: Dict = self._get(entrypoint=f"analysisResults?filter[folder]={str(folder_identifier)}")
+        return Analysis.data_from_dictionary(data)
+
+    def get_for_input(self, identifiers: List[Union[UUID, str]]) -> List[Analysis]:
+        """Get the analysis results related to the list of inputs given in parameters.
+
+        Args:
+            identifiers (List[Union[UUID, str]]): A list of input identifiers.
+
+        Returns:
+            List[Analysis]: A list of analysis results related to the specified inputs.
+        """
+        data: Dict = self._get(
+            entrypoint=f"analysisResults?filter[*]={','.join([str(identifier) for identifier in identifiers])}"
+        )
+        return Analysis.data_from_dictionary(data)
+
+    def delete(self, identifiers: List[Union[UUID, str]]) -> List[DataReference]:
+        """Delete a specific analysis result.
+
+        Args:
+            identifiers (List[Union[UUID, str]]): A list of identifiers for the analysis results to delete.
+
+        Returns:
+            List[DataReference]: A list of references to the deleted analysis results.
+        """
+        payload: Dict = dict(
+            data=[dict(id=str(identifier), type=Analysis.type()) for identifier in identifiers]
+        )
+        data: Dict = self._delete(entrypoint="analysisResults", payload=payload)
+        return Analysis.reference_from_dictionary(data)
+
+    def update(self, analysis_results: List[Analysis]) -> List[Analysis]:
+        """Update metadata of analysis results.
+
+        Args:
+            analysis_results (List[Analysis]): A list of Analysis objects to update.
+
+        Returns:
+            List[Analysis]: A list of updated Analysis objects.
+        """
+        payload: Dict = dict(
+            data=[
+                dict(
+                    id=str(analysis_result.identifier),
+                    type=Analysis.type(),
+                    attributes=dict(metadata=analysis_result.metadata),
+                )
+                for analysis_result in analysis_results
+            ]
+        )
+        data: Dict = self._put(entrypoint="analysisResults", payload=payload)
+        return Analysis.data_from_dictionary(data)
+
+
+# ================================================================================================= #