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

hydroserverpy/core/endpoints/things.py

@@ -1,240 +0,0 @@
-import json
-from typing import Union, List, IO, 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 Thing, Datastream, Tag, Photo, Archive
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.service import HydroServer
-
-
-class ThingEndpoint(HydroServerEndpoint):
-    """
-    An endpoint for interacting with thing entities in the HydroServer service.
-
-    :ivar _model: The model class associated with this endpoint, set to `Thing`.
-    :ivar _api_route: The base route of the API, derived from the service.
-    :ivar _endpoint_route: The specific route of the endpoint, set to `'things'`.
-    """
-
-    def __init__(self, service: 'HydroServer'):
-        """
-        Initialize the ThingEndpoint.
-
-        :param service: The HydroServer service instance to use for requests.
-        :type service: HydroServer
-        """
-
-        super().__init__(service)
-        self._model = Thing
-        self._api_route = self._service.api_route
-        self._endpoint_route = 'things'
-
-    def list(self, owned_only: bool = False, primary_owned_only: bool = False) -> List[Thing]:
-        """
-        Retrieve a collection of things owned by the logged-in user.
-
-        :param owned_only: Only list things owned by the logged-in user.
-        :param primary_owned_only: Only list things 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]) -> Thing:
-        """
-        Retrieve a thing owned by the logged-in user.
-        """
-
-        return super()._get(uid)
-
-    @expand_docstring(model=Thing)
-    def create(self, **kwargs) -> Thing:
-        """
-        Create a new thing in HydroServer.
-        """
-
-        return super()._post(**kwargs)
-
-    @expand_docstring(model=Thing, include_uid=True)
-    def update(self, uid: Union[UUID, str], **kwargs) -> Thing:
-        """
-        Update an existing thing in HydroServer.
-        """
-
-        return super()._patch(uid=uid, **kwargs)
-
-    @expand_docstring(include_uid=True)
-    def delete(self, uid: Union[UUID, str]) -> None:
-        """
-        Delete an existing thing in HydroServer.
-        """
-
-        super()._delete(uid=uid)
-
-    def list_datastreams(self, uid: Union[UUID, str]) -> List[Datastream]:
-        """
-        List all datastreams associated with a specific thing.
-
-        :param uid: The unique identifier of the thing.
-        :type uid: UUID or str
-        :returns: A list of datastream instances.
-        :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)
-        ]
-
-    def list_tags(self, uid: Union[UUID, str]) -> List[Tag]:
-        """
-        List all tags associated with a specific thing.
-
-        :param uid: The unique identifier of the thing.
-        :type uid: UUID or str
-        :returns: A list of tag instances.
-        :rtype: List[Tag]
-        """
-
-        response = getattr(self._service, '_request')(
-            'get', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags'
-        )
-
-        return [Tag(_uid=UUID(str(entity.pop('id'))), **entity) for entity in json.loads(response.content)]
-
-    def create_tag(self, uid: Union[UUID, str], key: str, value: str) -> Tag:
-        """
-        Create a new tag for a specific thing.
-
-        :param uid: The unique identifier of the thing.
-        :type uid: UUID or str
-        :param key: The key of the tag.
-        :type key: str
-        :param value: The value of the tag.
-        :type value: str
-        :returns: The created tag instance.
-        :rtype: Tag
-        """
-
-        response = getattr(self._service, '_request')(
-            'post', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags',
-            headers={'Content-type': 'application/json'},
-            data=Tag(key=key, value=value).json(exclude_unset=True, by_alias=True),
-        )
-        entity = json.loads(response.content)
-
-        return Tag(_uid=UUID(str(entity.pop('id'))), **entity)
-
-    def update_tag(self, uid: Union[UUID, str], tag_uid: Union[UUID, str], value: str) -> Tag:
-        """
-        Update an existing tag for a specific thing.
-
-        :param uid: The unique identifier of the thing.
-        :type uid: UUID or str
-        :param tag_uid: The unique identifier of the tag.
-        :type tag_uid: UUID or str
-        :param value: The new value for the tag.
-        :type value: str
-        :returns: The updated tag instance.
-        :rtype: Tag
-        """
-
-        response = getattr(self._service, '_request')(
-            'patch', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags/{str(tag_uid)}',
-            headers={'Content-type': 'application/json'},
-            data=json.dumps({'value': str(value)}),
-        )
-        entity = json.loads(response.content)
-
-        return Tag(_uid=UUID(str(entity.pop('id'))), **entity)
-
-    def delete_tag(self, uid: Union[UUID, str], tag_uid: Union[UUID, str]) -> None:
-        """
-        Delete a tag from a specific thing.
-
-        :param uid: The unique identifier of the thing.
-        :type uid: UUID or str
-        :param tag_uid: The unique identifier of the tag.
-        :type tag_uid: UUID or str
-        """
-
-        getattr(self._service, '_request')(
-            'delete', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/tags/{str(tag_uid)}'
-        )
-
-    def list_photos(self, uid: Union[UUID, str]) -> List[Photo]:
-        """
-        List all photos associated with a specific thing.
-
-        :param uid: The unique identifier of the thing.
-        :type uid: UUID or str
-        :returns: A list of photo instances.
-        :rtype: List[Photo]
-        """
-
-        response = getattr(self._service, '_request')(
-            'get', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/photos'
-        )
-
-        return [Photo(_uid=UUID(str(entity.pop('id'))), **entity) for entity in json.loads(response.content)]
-
-    def upload_photo(self, uid: Union[UUID, str], file: IO) -> List[Photo]:
-        """
-        Upload a new photo to a specific thing.
-
-        :param uid: The unique identifier of the thing.
-        :type uid: UUID or str
-        :param file: The file-like object representing the photo to upload.
-        :type file: IO
-        :returns: A list of photo instances created by the upload.
-        :rtype: List[Photo]
-        """
-
-        response = getattr(self._service, '_request')(
-            'post', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/photos',
-            files={'files': file}
-        )
-
-        return [Photo(_uid=UUID(str(entity.pop('id'))), **entity) for entity in json.loads(response.content)]
-
-    def delete_photo(self, uid: Union[UUID, str], photo_uid: Union[UUID, str]) -> None:
-        """
-        Delete a photo from a specific thing.
-
-        :param uid: The unique identifier of the thing.
-        :type uid: UUID or str
-        :param photo_uid: The unique identifier of the photo.
-        :type photo_uid: UUID or str
-        """
-
-        getattr(self._service, '_request')(
-            'delete', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/photos/{str(photo_uid)}'
-        )
-
-    def get_archive(self, uid: Union[UUID, str]) -> Archive:
-        """
-        Retrieve the archive associated with a specific thing.
-
-        :param uid: The unique identifier of the thing.
-        :type uid: UUID or str
-        :returns: The archive instance associated with the thing.
-        :rtype: Archive
-        """
-
-        response = getattr(self._service, '_request')(
-            'get', f'{self._api_route}/data/{self._endpoint_route}/{str(uid)}/archive'
-        )
-        entity = json.loads(response.content)
-
-        return Archive(_uid=UUID(str(entity.pop('id'))), **entity)

hydroserverpy/core/endpoints/units.py

@@ -1,93 +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 Unit
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.service import HydroServer
-
-
-class UnitEndpoint(HydroServerEndpoint):
-    """
-    An endpoint for interacting with unit entities in the HydroServer service.
-
-    :ivar _model: The model class associated with this endpoint, set to `Unit`.
-    :ivar _api_route: The base route of the API, derived from the service.
-    :ivar _endpoint_route: The specific route of the endpoint, set to `'units'`.
-    """
-
-    def __init__(self, service: 'HydroServer'):
-        """
-        Initialize the UnitEndpoint.
-
-        :param service: The HydroServer service instance to use for requests.
-        :type service: HydroServer
-        """
-
-        super().__init__(service)
-        self._model = Unit
-        self._api_route = self._service.api_route
-        self._endpoint_route = 'units'
-
-    def list(
-            self,
-            include_owned: bool = True,
-            include_unowned: bool = True,
-            include_templates: bool = True
-    ) -> List[Unit]:
-        """
-        Retrieve a collection of units.
-
-        :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]) -> Unit:
-        """
-        Retrieve a unit owned by the logged-in user.
-        """
-
-        return super()._get(uid)
-
-    @expand_docstring(model=Unit)
-    def create(self, **kwargs) -> Unit:
-        """
-        Create a new unit in HydroServer.
-        """
-
-        return super()._post(**kwargs)
-
-    @expand_docstring(model=Unit, include_uid=True)
-    def update(self, uid: Union[UUID, str], **kwargs) -> Unit:
-        """
-        Update an existing unit in HydroServer.
-        """
-
-        return super()._patch(uid=uid, **kwargs)
-
-    @expand_docstring(include_uid=True)
-    def delete(self, uid: Union[UUID, str]) -> None:
-        """
-        Delete an existing unit in HydroServer.
-        """
-
-        super()._delete(uid=uid)

hydroserverpy/core/schemas/__init__.py

@@ -1,9 +0,0 @@
-from .data_loaders import DataLoader
-from .data_sources import DataSource
-from .datastreams import Datastream
-from .observed_properties import ObservedProperty
-from .processing_levels import ProcessingLevel
-from .result_qualifiers import ResultQualifier
-from .sensors import Sensor
-from .things import Thing, Tag, Photo, Archive
-from .units import Unit

hydroserverpy/core/schemas/base.py

@@ -1,117 +0,0 @@
-from pydantic import BaseModel, PrivateAttr, AliasGenerator, AliasChoices, computed_field
-from pydantic.alias_generators import to_camel
-from uuid import UUID
-from typing import Optional
-
-
-base_alias_generator = AliasGenerator(
-    serialization_alias=lambda field_name: to_camel(field_name),
-    validation_alias=lambda field_name: AliasChoices(to_camel(field_name), field_name),
-)
-
-
-class HydroServerBaseModel(BaseModel):
-    """
-    A base model for HydroServer entities that provides common attributes and functionality for HydroServer data.
-
-    :ivar _uid: A private attribute for storing the unique identifier (UUID) of the model.
-    """
-
-    _uid: Optional[UUID] = PrivateAttr()
-
-    def __init__(self, _uid: Optional[UUID] = None, **data):
-        """
-        Initialize a HydroServerBaseModel instance.
-
-        :param _uid: The unique identifier for the model.
-        :type _uid: Optional[UUID]
-        :param data: Additional attributes for the model.
-        """
-
-        super().__init__(**data)
-        self._uid = _uid
-
-    @computed_field
-    @property
-    def uid(self) -> Optional[UUID]:
-        """
-        The unique identifier (UUID) of the model.
-
-        :return: The UUID of the model.
-        :rtype: Optional[UUID]
-        """
-
-        return self._uid
-
-    class Config:
-        alias_generator = base_alias_generator
-        validate_assignment = True
-
-
-class HydroServerCoreModel(HydroServerBaseModel):
-    """
-    A core model for HydroServer entities that includes methods for data manipulation and persistence.
-
-    :ivar _original_data: A private attribute storing the original data used to initialize the model.
-    """
-
-    _original_data: Optional[dict] = PrivateAttr()
-
-    def __init__(self, _endpoint, _uid: Optional[UUID] = None, **data):
-        """
-        Initialize a HydroServerCoreModel instance.
-
-        :param _endpoint: The endpoint associated with the model.
-        :param _uid: The unique identifier for the model.
-        :type _uid: Optional[UUID]
-        :param data: Additional attributes for the model.
-        """
-
-        super().__init__(_uid=_uid, **data)
-        self._endpoint = _endpoint
-        self._original_data = self.dict(by_alias=False).copy()
-
-    @property
-    def _patch_data(self) -> dict:
-        """
-        Generate a dictionary of modified data that needs to be patched on the server.
-
-        :return: A dictionary of modified attributes.
-        :rtype: dict
-        """
-
-        return {
-            key: getattr(self, key) for key, value in self._original_data.items()
-            if hasattr(self, key) and getattr(self, key) != value
-        }
-
-    def refresh(self) -> None:
-        """
-        Refresh the model with the latest data from the server.
-        """
-
-        entity = self._endpoint.get(uid=self.uid).model_dump(exclude=['uid'])
-        self._original_data = entity.dict(by_alias=False, exclude=['uid'])
-        self.__dict__.update(self._original_data)
-
-    def save(self) -> None:
-        """
-        Save the current state of the model to the server by updating modified attributes.
-        """
-
-        if self._patch_data:
-            entity = self._endpoint.update(uid=self.uid, **self._patch_data)
-            self._original_data = entity.dict(by_alias=False, exclude=['uid'])
-            self.__dict__.update(self._original_data)
-
-    def delete(self) -> None:
-        """
-        Delete the model from the server.
-
-        :raises AttributeError: If the model's UID is not set.
-        """
-
-        if not self._uid:
-            raise AttributeError('This resource cannot be deleted: UID is not set.')
-        self._endpoint.delete(uid=self._uid)
-        self._uid = None

hydroserverpy/core/schemas/data_loaders.py

@@ -1,71 +0,0 @@
-from pydantic import BaseModel, Field
-from typing import Optional, List, TYPE_CHECKING
-from uuid import UUID
-from hydroserverpy.core.schemas.base import HydroServerCoreModel
-
-if TYPE_CHECKING:
-    from hydroserverpy.core.schemas.data_sources import DataSource
-
-
-class DataLoaderFields(BaseModel):
-    name: str = Field(
-        ..., strip_whitespace=True, max_length=255,
-        description='The name of the data loader.'
-    )
-
-
-class DataLoader(HydroServerCoreModel, DataLoaderFields):
-    """
-    A model representing a DataLoader, extending the core functionality of HydroServerCoreModel with additional
-    properties and methods.
-
-    :ivar _data_sources: A private attribute to cache the list of data sources associated with the DataLoader.
-    """
-
-    def __init__(self, _endpoint, _uid: Optional[UUID] = None, **data):
-        """
-        Initialize a DataLoader instance.
-
-        :param _endpoint: The endpoint associated with the data loader.
-        :type _endpoint: str
-        :param _uid: The unique identifier for the data loader.
-        :type _uid: Optional[UUID]
-        :param data: Additional attributes for the data loader.
-        """
-
-        super().__init__(_endpoint=_endpoint, _uid=_uid, **data)
-        self._data_sources = None
-
-    @property
-    def data_sources(self) -> List['DataSource']:
-        """
-        The data sources associated with the data loader. If not already cached, fetch the data sources from the server.
-
-        :return: A list of data sources associated with the data loader.
-        :rtype: List[DataSource]
-        """
-
-        if self._data_sources is None:
-            self._data_sources = self._endpoint.list_data_sources(uid=self.uid)
-
-        return self._data_sources
-
-    def refresh(self) -> None:
-        """
-        Refresh the data loader with the latest data from the server and update cached data sources.
-        """
-
-        entity = self._endpoint.get(uid=self.uid).model_dump(exclude=['uid'])
-        self._original_data = entity
-        self.__dict__.update(entity)
-        if self._data_sources is not None:
-            self._data_sources = self._endpoint.list_data_sources(uid=self.uid)
-
-    def load_observations(self) -> None:
-        """
-        Load observations data from a local file or a remote URL into HydroServer using all data sources associated with
-        this data loader.
-        """
-
-        for data_source in self.data_sources:
-            data_source.load_observations()