hydroserverpy 0.4.0__py3-none-any.whl → 0.5.0b1__py3-none-any.whl

hydroserverpy/core/endpoints/data_loaders.py

@@ -1,93 +0,0 @@
-import json
-from typing import Union, List, TYPE_CHECKING
-from uuid import UUID
-from hydroserverpy.core.endpoints.base import HydroServerEndpoint, expand_docstring
-from hydroserverpy.core.endpoints.data_sources import DataSourceEndpoint
-from hydroserverpy.core.schemas import DataLoader, DataSource
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.service import HydroServer
-
-
-class DataLoaderEndpoint(HydroServerEndpoint):
-    """
-    An endpoint for interacting with DataLoader entities in the HydroServer service.
-
-    :ivar _model: The model class associated with this endpoint, set to `DataLoader`.
-    :ivar _api_route: The base route of the API, derived from the service.
-    :ivar _endpoint_route: The specific route of the endpoint, set to `'data-loaders'`.
-    """
-
-    def __init__(self, service: "HydroServer") -> None:
-        """
-        Initialize the DataLoaderEndpoint.
-
-        :param service: The HydroServer service instance to use for requests.
-        :type service: HydroServer
-        """
-
-        super().__init__(service)
-        self._model = DataLoader
-        self._api_route = self._service.api_route
-        self._endpoint_route = "data-loaders"
-
-    def list(self) -> List[DataLoader]:
-        """
-        Retrieve a collection of data loaders owned by the logged-in user.
-        """
-
-        return super()._get()
-
-    @expand_docstring(include_uid=True)
-    def get(self, uid: Union[UUID, str]) -> DataLoader:
-        """
-        Retrieve a data loader owned by the logged-in user.
-        """
-
-        return super()._get(uid)
-
-    @expand_docstring(model=DataLoader)
-    def create(self, **kwargs) -> DataLoader:
-        """
-        Create a new data loader in HydroServer.
-        """
-
-        return super()._post(**kwargs)
-
-    @expand_docstring(model=DataLoader, include_uid=True)
-    def update(self, uid: Union[UUID, str], **kwargs) -> DataLoader:
-        """
-        Update an existing data loader in HydroServer.
-        """
-
-        return super()._patch(uid=uid, **kwargs)
-
-    @expand_docstring(include_uid=True)
-    def delete(self, uid: Union[UUID, str]) -> None:
-        """
-        Delete an existing data loader in HydroServer.
-        """
-
-        super()._delete(uid=uid)
-
-    def list_data_sources(self, uid: Union[UUID, str]) -> List[DataSource]:
-        """
-        Retrieve a list of data source entities associated with a specific data loader.
-
-        :param uid: The unique identifier of the data loader.
-        :type uid: Union[UUID, str]
-        :returns: A list of data sour instances associated with the data loader.
-        :rtype: List[DataSource]
-        """
-
-        response = getattr(self._service, "_request")(
-            "get",
-            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/data-sources",
-        )
-
-        endpoint = DataSourceEndpoint(self._service)
-
-        return [
-            DataSource(_endpoint=endpoint, _uid=UUID(str(entity.pop("id"))), **entity)
-            for entity in json.loads(response.content)
-        ]

hydroserverpy/core/endpoints/data_sources.py

@@ -1,93 +0,0 @@
-import json
-from typing import Union, List, TYPE_CHECKING
-from uuid import UUID
-from hydroserverpy.core.endpoints.base import HydroServerEndpoint, expand_docstring
-from hydroserverpy.core.endpoints.datastreams import DatastreamEndpoint
-from hydroserverpy.core.schemas import DataSource, Datastream
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.service import HydroServer
-
-
-class DataSourceEndpoint(HydroServerEndpoint):
-    """
-    An endpoint for interacting with data source entities in the HydroServer service.
-
-    :ivar _model: The model class associated with this endpoint, set to `DataSource`.
-    :ivar _api_route: The base route of the API, derived from the service.
-    :ivar _endpoint_route: The specific route of the endpoint, set to `'data-sources'`.
-    """
-
-    def __init__(self, service: "HydroServer") -> None:
-        """
-        Initialize the DataSourceEndpoint.
-
-        :param service: The HydroServer service instance to use for requests.
-        :type service: HydroServer
-        """
-
-        super().__init__(service)
-        self._model = DataSource
-        self._api_route = self._service.api_route
-        self._endpoint_route = "data-sources"
-
-    def list(self) -> List[DataSource]:
-        """
-        Retrieve a collection of data sources owned by the logged-in user.
-        """
-
-        return super()._get()
-
-    @expand_docstring(include_uid=True)
-    def get(self, uid: Union[UUID, str]) -> DataSource:
-        """
-        Retrieve a data source owned by the logged-in user.
-        """
-
-        return super()._get(uid)
-
-    @expand_docstring(model=DataSource)
-    def create(self, **kwargs) -> DataSource:
-        """
-        Create a new data source in HydroServer.
-        """
-
-        return super()._post(**kwargs)
-
-    @expand_docstring(model=DataSource, include_uid=True)
-    def update(self, uid: Union[UUID, str], **kwargs) -> DataSource:
-        """
-        Update an existing data source in HydroServer.
-        """
-
-        return super()._patch(uid=uid, **kwargs)
-
-    @expand_docstring(include_uid=True)
-    def delete(self, uid: Union[UUID, str]) -> None:
-        """
-        Delete an existing data source in HydroServer.
-        """
-
-        super()._delete(uid=uid)
-
-    def list_datastreams(self, uid: Union[UUID, str]) -> List[Datastream]:
-        """
-        Retrieve a list of datastream entities associated with a specific data source.
-
-        :param uid: The unique identifier of the data source.
-        :type uid: Union[UUID, str]
-        :returns: A list of datastream instances associated with the data source.
-        :rtype: List[Datastream]
-        """
-
-        response = getattr(self._service, "_request")(
-            "get",
-            f"{self._api_route}/data/{self._endpoint_route}/{str(uid)}/datastreams",
-        )
-
-        endpoint = DatastreamEndpoint(self._service)
-
-        return [
-            Datastream(_endpoint=endpoint, _uid=UUID(str(entity.pop("id"))), **entity)
-            for entity in json.loads(response.content)
-        ]

hydroserverpy/core/endpoints/datastreams.py

@@ -1,225 +0,0 @@
-import json
-import pandas as pd
-from typing import List, Union, TYPE_CHECKING
-from uuid import UUID
-from datetime import datetime
-from hydroserverpy.core.endpoints.base import HydroServerEndpoint, expand_docstring
-from hydroserverpy.core.schemas import Datastream
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.service import HydroServer
-
-
-class DatastreamEndpoint(HydroServerEndpoint):
-    """
-    An endpoint for interacting with datastream entities in the HydroServer service.
-
-    :ivar _model: The model class associated with this endpoint, set to `Datastream`.
-    :ivar _api_route: The base route of the API, derived from the service.
-    :ivar _endpoint_route: The specific route of the endpoint, set to `'datastreams'`.
-    """
-
-    def __init__(self, service) -> None:
-        """
-        Initialize the DatastreamEndpoint.
-
-        :param service: The HydroServer service instance to use for requests.
-        :type service: HydroServer
-        """
-
-        super().__init__(service)
-        self._model = Datastream
-        self._api_route = self._service.api_route
-        self._endpoint_route = "datastreams"
-
-    def list(
-        self, owned_only: bool = False, primary_owned_only: bool = False
-    ) -> List[Datastream]:
-        """
-        Retrieve a collection of datastreams owned by the logged-in user.
-
-        :param owned_only: Only list datastreams owned by the logged-in user.
-        :param primary_owned_only: Only list datastreams primary owned by the logged-in user.
-        """
-
-        return super()._get(
-            params={
-                "owned_only": owned_only,
-                "primary_owned_only": primary_owned_only,
-            }
-        )
-
-    @expand_docstring(include_uid=True)
-    def get(self, uid: Union[UUID, str]) -> Datastream:
-        """
-        Retrieve a datastream owned by the logged-in user.
-        """
-
-        return super()._get(uid)
-
-    @expand_docstring(model=Datastream)
-    def create(self, **kwargs) -> Datastream:
-        """
-        Create a new datastream in HydroServer.
-        """
-
-        return super()._post(**kwargs)
-
-    @expand_docstring(model=Datastream, include_uid=True)
-    def update(self, uid: Union[UUID, str], **kwargs) -> Datastream:
-        """
-        Update an existing datastream in HydroServer.
-        """
-
-        return super()._patch(uid=uid, **kwargs)
-
-    @expand_docstring(include_uid=True)
-    def delete(self, uid: Union[UUID, str]) -> None:
-        """
-        Delete an existing datastream in HydroServer.
-        """
-
-        super()._delete(uid=uid)
-
-    def get_observations(
-        self,
-        uid: Union[UUID, str],
-        start_time: datetime = None,
-        end_time: datetime = None,
-        page: int = 1,
-        page_size: int = 100000,
-        include_quality: bool = False,
-        fetch_all: bool = False,
-    ) -> pd.DataFrame:
-        """
-        Retrieve observations from a specific datastream.
-
-        :param uid: The unique identifier of the datastream.
-        :type uid: Union[UUID, str]
-        :param start_time: The start time for filtering observations.
-        :type start_time: datetime, optional
-        :param end_time: The end time for filtering observations.
-        :type end_time: datetime, optional
-        :param page: The page number to retrieve (used for pagination).
-        :type page: int, optional
-        :param page_size: The number of observations per page.
-        :type page_size: int, optional
-        :param include_quality: Whether to include quality information with each observation.
-        :type include_quality: bool, optional
-        :param fetch_all: Whether to fetch all observations (ignoring pagination).
-        :type fetch_all: bool, optional
-        :returns: A DataFrame containing the retrieved observations.
-        :rtype: pd.DataFrame
-        """
-
-        filters = []
-        if start_time:
-            filters.append(
-                f'phenomenonTime ge {start_time.strftime("%Y-%m-%dT%H:%M:%S%z")}'
-            )
-        if end_time:
-            filters.append(
-                f'phenomenonTime le {end_time.strftime("%Y-%m-%dT%H:%M:%S%z")}'
-            )
-
-        if fetch_all:
-            page = 1
-
-        observations = []
-
-        while True:
-            response = getattr(self._service, "_request")(
-                "get",
-                f"{self._api_route}/sensorthings/v1.1/Datastreams('{str(uid)}')/Observations",
-                params={
-                    "$resultFormat": "dataArray",
-                    "$select": f'phenomenonTime,result{",resultQuality" if include_quality else ""}',
-                    "$count": True,
-                    "$top": page_size,
-                    "$skip": (page - 1) * page_size,
-                    "$filter": " and ".join(filters) if filters else None,
-                },
-            )
-            response_content = json.loads(response.content)
-            data_array = (
-                response_content["value"][0]["dataArray"]
-                if response_content["value"]
-                else []
-            )
-            observations.extend(
-                [
-                    (
-                        [
-                            obs[0],
-                            obs[1],
-                            obs[2]["qualityCode"] if obs[2]["qualityCode"] else None,
-                            (
-                                obs[2]["resultQualifiers"]
-                                if obs[2]["resultQualifiers"]
-                                else None
-                            ),
-                        ]
-                        if include_quality
-                        else [obs[0], obs[1]]
-                    )
-                    for obs in data_array
-                ]
-            )
-            if not fetch_all or len(data_array) < page_size:
-                break
-            page += 1
-
-        columns = ["timestamp", "value"]
-        if include_quality:
-            columns.extend(["quality_code", "result_quality"])
-
-        data_frame = pd.DataFrame(observations, columns=columns)
-        data_frame["timestamp"] = pd.to_datetime(data_frame["timestamp"])
-
-        return data_frame
-
-    def load_observations(
-        self,
-        uid: Union[UUID, str],
-        observations: pd.DataFrame,
-    ) -> None:
-        """
-        Load observations to a specific datastream.
-
-        :param uid: The unique identifier of the datastream.
-        :type uid: Union[UUID, str]
-        :param observations: A DataFrame containing the observations to upload.
-        :type observations: pd.DataFrame
-        :returns: None
-        """
-
-        data_array = [
-            [
-                row["timestamp"].strftime("%Y-%m-%dT%H:%M:%S%z"),
-                row["value"],
-                (
-                    {
-                        "qualityCode": row.get("quality_code", None),
-                        "resultQualifiers": row.get("result_qualifiers", []),
-                    }
-                    if "quality_code" in row or "result_qualifiers" in row
-                    else {}
-                ),
-            ]
-            for _, row in observations.iterrows()
-        ]
-
-        getattr(self._service, "_request")(
-            "post",
-            f"{self._api_route}/sensorthings/v1.1/CreateObservations",
-            headers={"Content-type": "application/json"},
-            data=json.dumps(
-                [
-                    {
-                        "Datastream": {"@iot.id": str(uid)},
-                        "components": ["phenomenonTime", "result", "resultQuality"],
-                        "dataArray": data_array,
-                    }
-                ]
-            ),
-        )

hydroserverpy/core/endpoints/observed_properties.py

@@ -1,111 +0,0 @@
-from typing import Union, List, TYPE_CHECKING
-from uuid import UUID
-from hydroserverpy.core.endpoints.base import HydroServerEndpoint, expand_docstring
-from hydroserverpy.core.schemas import ObservedProperty
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.service import HydroServer
-
-
-class ObservedPropertyEndpoint(HydroServerEndpoint):
-    """
-    An endpoint for interacting with observed property entities in the HydroServer service.
-
-    :ivar _model: The model class associated with this endpoint, set to `ObservedProperty`.
-    :ivar _api_route: The base route of the API, derived from the service.
-    :ivar _endpoint_route: The specific route of the endpoint, set to `'observed-properties'`.
-    """
-
-    def __init__(self, service):
-        """
-        Initialize the ObservedPropertyEndpoint.
-
-        :param service: The HydroServer service instance to use for requests.
-        :type service: HydroServer
-        """
-
-        super().__init__(service)
-        self._model = ObservedProperty
-        self._api_route = self._service.api_route
-        self._endpoint_route = "observed-properties"
-
-    def list(
-        self,
-        include_owned: bool = True,
-        include_unowned: bool = True,
-        include_templates: bool = True,
-    ) -> List[ObservedProperty]:
-        """
-        Retrieve a collection of observed properties.
-
-        :param include_owned: Whether to include owned observed properties.
-        :param include_unowned: Whether to include unowned observed properties.
-        :param include_templates: Whether to include template observed properties.
-        """
-
-        if (
-            include_owned is True
-            and include_unowned is True
-            and include_templates is True
-        ):
-            owner = "anyUserOrNoUser"
-        elif (
-            include_owned is True
-            and include_unowned is True
-            and include_templates is False
-        ):
-            owner = "anyUser"
-        elif (
-            include_owned is True
-            and include_unowned is False
-            and include_templates is True
-        ):
-            owner = "currentUserOrNoUser"
-        elif (
-            include_owned is True
-            and include_unowned is False
-            and include_templates is False
-        ):
-            owner = "currentUser"
-        elif (
-            include_owned is False
-            and include_unowned is False
-            and include_templates is True
-        ):
-            owner = "noUser"
-        else:
-            return []
-
-        return super()._get(params={"owner": owner})
-
-    @expand_docstring(include_uid=True)
-    def get(self, uid: Union[UUID, str]) -> ObservedProperty:
-        """
-        Retrieve an observed property owned by the logged-in user.
-        """
-
-        return super()._get(uid)
-
-    @expand_docstring(model=ObservedProperty)
-    def create(self, **kwargs) -> ObservedProperty:
-        """
-        Create a new observed property in HydroServer.
-        """
-
-        return super()._post(**kwargs)
-
-    @expand_docstring(model=ObservedProperty, include_uid=True)
-    def update(self, uid: Union[UUID, str], **kwargs) -> ObservedProperty:
-        """
-        Update an existing observed property in HydroServer.
-        """
-
-        return super()._patch(uid=uid, **kwargs)
-
-    @expand_docstring(include_uid=True)
-    def delete(self, uid: Union[UUID, str]) -> None:
-        """
-        Delete an existing observed property in HydroServer.
-        """
-
-        super()._delete(uid=uid)

hydroserverpy/core/endpoints/processing_levels.py

@@ -1,111 +0,0 @@
-from typing import List, Union, TYPE_CHECKING
-from uuid import UUID
-from hydroserverpy.core.endpoints.base import HydroServerEndpoint, expand_docstring
-from hydroserverpy.core.schemas import ProcessingLevel
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.service import HydroServer
-
-
-class ProcessingLevelEndpoint(HydroServerEndpoint):
-    """
-    An endpoint for interacting with processing level entities in the HydroServer service.
-
-    :ivar _model: The model class associated with this endpoint, set to `ProcessingLevel`.
-    :ivar _api_route: The base route of the API, derived from the service.
-    :ivar _endpoint_route: The specific route of the endpoint, set to `'processing-levels'`.
-    """
-
-    def __init__(self, service):
-        """
-        Initialize the ProcessingLevelEndpoint.
-
-        :param service: The HydroServer service instance to use for requests.
-        :type service: HydroServer
-        """
-
-        super().__init__(service)
-        self._model = ProcessingLevel
-        self._api_route = self._service.api_route
-        self._endpoint_route = "processing-levels"
-
-    def list(
-        self,
-        include_owned: bool = True,
-        include_unowned: bool = True,
-        include_templates: bool = True,
-    ) -> List[ProcessingLevel]:
-        """
-        Retrieve a collection of processing levels.
-
-        :param include_owned: Whether to include owned observed properties.
-        :param include_unowned: Whether to include unowned observed properties.
-        :param include_templates: Whether to include template observed properties.
-        """
-
-        if (
-            include_owned is True
-            and include_unowned is True
-            and include_templates is True
-        ):
-            owner = "anyUserOrNoUser"
-        elif (
-            include_owned is True
-            and include_unowned is True
-            and include_templates is False
-        ):
-            owner = "anyUser"
-        elif (
-            include_owned is True
-            and include_unowned is False
-            and include_templates is True
-        ):
-            owner = "currentUserOrNoUser"
-        elif (
-            include_owned is True
-            and include_unowned is False
-            and include_templates is False
-        ):
-            owner = "currentUser"
-        elif (
-            include_owned is False
-            and include_unowned is False
-            and include_templates is True
-        ):
-            owner = "noUser"
-        else:
-            return []
-
-        return super()._get(params={"owner": owner})
-
-    @expand_docstring(include_uid=True)
-    def get(self, uid: Union[UUID, str]) -> ProcessingLevel:
-        """
-        Retrieve a processing level owned by the logged-in user.
-        """
-
-        return super()._get(uid)
-
-    @expand_docstring(model=ProcessingLevel)
-    def create(self, **kwargs) -> ProcessingLevel:
-        """
-        Create a new processing level in HydroServer.
-        """
-
-        return super()._post(**kwargs)
-
-    @expand_docstring(model=ProcessingLevel, include_uid=True)
-    def update(self, uid: Union[UUID, str], **kwargs) -> ProcessingLevel:
-        """
-        Update an existing processing level in HydroServer.
-        """
-
-        return super()._patch(uid=uid, **kwargs)
-
-    @expand_docstring(include_uid=True)
-    def delete(self, uid: Union[UUID, str]) -> None:
-        """
-        Delete an existing processing level in HydroServer.
-        """
-
-        super()._delete(uid=uid)