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

hydroserverpy/api/models/iam/collaborator.py

@@ -0,0 +1,34 @@
+from typing import Union, TYPE_CHECKING
+from uuid import UUID
+from pydantic import BaseModel
+
+if TYPE_CHECKING:
+    from hydroserverpy.api.models.iam.account import Account
+    from hydroserverpy.api.models.iam.role import Role
+
+
+class CollaboratorFields(BaseModel):
+    user: "Account"
+    role: "Role"
+    workspace_id: Union[UUID, str]
+
+
+class Collaborator(CollaboratorFields):
+    def __init__(self, _connection, **data):
+        super().__init__(**data)
+        self._connection = _connection
+
+    def edit_role(self, role: Union["Role", UUID, str]):
+        """Edit the role of this workspace collaborator."""
+
+        response = self._connection.workspaces.edit_collaborator_role(
+            uid=self.workspace_id, email=self.user.email, role=role
+        )
+        self.role = response.role
+
+    def remove(self):
+        """Remove this collaborator from the workspace."""
+
+        self._connection.workspaces.remove_collaborator(
+            uid=self.workspace_id, email=self.user.email
+        )

hydroserverpy/api/models/iam/role.py

@@ -0,0 +1,10 @@
+from typing import Optional, Union
+from uuid import UUID
+from pydantic import BaseModel, Field
+
+
+class Role(BaseModel):
+    uid: UUID = Field(..., alias="id")
+    name: str = Field(..., max_length=255)
+    description: str
+    workspace_id: Optional[Union[UUID, str]] = None

hydroserverpy/api/models/iam/workspace.py

@@ -0,0 +1,238 @@
+from typing import List, Union, Optional, TYPE_CHECKING
+from uuid import UUID
+from pydantic import BaseModel, Field, EmailStr
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import (
+        Role,
+        Collaborator,
+        Account,
+        Thing,
+        ObservedProperty,
+        Sensor,
+        Unit,
+        ProcessingLevel,
+        ResultQualifier,
+        Datastream,
+        OrchestrationSystem,
+        DataSource,
+        DataArchive,
+    )
+
+
+class WorkspaceFields(BaseModel):
+    name: str = Field(..., max_length=255)
+    is_private: bool
+    owner: "Account" = Field(..., json_schema_extra={"read_only": True})
+    collaborator_role: Optional["Role"] = None
+    pending_transfer_to: Optional["Account"] = None
+
+
+class Workspace(HydroServerModel, WorkspaceFields):
+    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
+        super().__init__(
+            _connection=_connection, _model_ref="workspaces", _uid=_uid, **data
+        )
+        self._roles = None
+        self._collaborators = None
+        self._things = None
+        self._observedproperties = None
+        self._processinglevels = None
+        self._resultqualifiers = None
+        self._units = None
+        self._sensors = None
+        self._datastreams = None
+        self._orchestrationsystems = None
+        self._datasources = None
+        self._dataarchives = None
+
+    @property
+    def roles(self) -> List["Role"]:
+        """The roles that can be assigned for this workspace."""
+
+        if self._roles is None:
+            self._roles = self._connection.workspaces.list_roles(uid=self.uid)
+
+        return self._roles
+
+    @property
+    def collaborators(self) -> List["Collaborator"]:
+        """The collaborators associated with this workspace."""
+
+        if self._collaborators is None:
+            self._collaborators = self._connection.workspaces.list_collaborators(
+                uid=self.uid
+            )
+
+        return self._collaborators
+
+    @property
+    def things(self) -> List["Thing"]:
+        """The things associated with this workspace."""
+
+        if self._things is None:
+            self._things = self._connection.things.list(workspace=self.uid)
+
+        return self._things
+
+    @property
+    def observedproperties(self) -> List["ObservedProperty"]:
+        """The observed properties associated with this workspace."""
+
+        if self._observedproperties is None:
+            self._observedproperties = self._connection.observedproperties.list(
+                workspace=self.uid
+            )
+
+        return self._observedproperties
+
+    @property
+    def processinglevels(self) -> List["ProcessingLevel"]:
+        """The processing levels associated with this workspace."""
+
+        if self._processinglevels is None:
+            self._processinglevels = self._connection.processinglevels.list(
+                workspace=self.uid
+            )
+
+        return self._processinglevels
+
+    @property
+    def resultqualifiers(self) -> List["ResultQualifier"]:
+        """The result qualifiers associated with this workspace."""
+
+        if self._resultqualifiers is None:
+            self._resultqualifiers = self._connection.resultqualifiers.list(
+                workspace=self.uid
+            )
+
+        return self._resultqualifiers
+
+    @property
+    def units(self) -> List["Unit"]:
+        """The units associated with this workspace."""
+
+        if self._units is None:
+            self._units = self._connection.units.list(workspace=self.uid)
+
+        return self._units
+
+    @property
+    def sensors(self) -> List["Sensor"]:
+        """The sensors associated with this workspace."""
+
+        if self._sensors is None:
+            self._sensors = self._connection.sensors.list(workspace=self.uid)
+
+        return self._sensors
+
+    @property
+    def datastreams(self) -> List["Datastream"]:
+        """The datastreams associated with this workspace."""
+
+        if self._datastreams is None:
+            self._datastreams = self._connection.datastreams.list(workspace=self.uid)
+
+        return self._datastreams
+
+    @property
+    def orchestrationsystems(self) -> List["OrchestrationSystem"]:
+        """The orchestration systems associated with this workspace."""
+
+        if self._orchestrationsystems is None:
+            self._orchestrationsystems = self._connection.orchestrationsystems.list(
+                workspace=self.uid
+            )
+
+        return self._orchestrationsystems
+
+    @property
+    def datasources(self) -> List["DataSource"]:
+        """The data sources associated with this workspace."""
+
+        if self._datasources is None:
+            self._datasources = self._connection.datasources.list(workspace=self.uid)
+
+        return self._datasources
+
+    @property
+    def dataarchives(self) -> List["DataArchive"]:
+        """The data archives associated with this workspace."""
+
+        if self._dataarchives is None:
+            self._dataarchives = self._connection.dataarchives.list(workspace=self.uid)
+
+        return self._dataarchives
+
+    def refresh(self) -> None:
+        """Refresh the workspace details from HydroServer."""
+
+        self._roles = None
+        self._collaborators = None
+        self._things = None
+        self._observedproperties = None
+        self._processinglevels = None
+        self._units = None
+        self._sensors = None
+        self._datastreams = None
+        super()._refresh()
+
+    def save(self):
+        """Save changes to this workspace to HydroServer."""
+
+        super()._save()
+
+    def delete(self):
+        """Delete this workspace from HydroServer."""
+
+        super()._delete()
+
+    def add_collaborator(
+        self, email: EmailStr, role: Union["Role", UUID, str]
+    ) -> "Collaborator":
+        """Add a new collaborator to the workspace."""
+
+        response = self._connection.workspaces.add_collaborator(
+            uid=self.uid, email=email, role=role
+        )
+        self._collaborators = None
+
+        return response
+
+    def edit_collaborator_role(
+        self, email: EmailStr, role: Union["Role", UUID, str]
+    ) -> "Collaborator":
+        """Edit a collaborator's role in this workspace."""
+
+        response = self._connection.workspaces.edit_collaborator_role(
+            uid=self.uid, email=email, role=role
+        )
+        self._collaborators = None
+
+        return response
+
+    def remove_collaborator(self, email: EmailStr) -> None:
+        """Remove a collaborator from the workspace."""
+
+        self._connection.workspaces.remove_collaborator(uid=self.uid, email=email)
+        self._collaborators = None
+
+    def transfer_ownership(self, email: EmailStr) -> None:
+        """Transfer ownership of this workspace to another HydroServer user."""
+
+        self._connection.workspaces.transfer_ownership(uid=self.uid, email=email)
+        self.refresh()
+
+    def accept_ownership_transfer(self) -> None:
+        """Accept ownership transfer of this workspace."""
+
+        self._connection.workspaces.accept_ownership_transfer(uid=self.uid)
+        self.refresh()
+
+    def cancel_ownership_transfer(self) -> None:
+        """Cancel ownership transfer of this workspace."""
+
+        self._connection.workspaces.cancel_ownership_transfer(uid=self.uid)
+        self.refresh()

hydroserverpy/api/models/sta/datastream.py

@@ -0,0 +1,338 @@
+from typing import Union, Optional, Literal, TYPE_CHECKING
+from pydantic import BaseModel, Field, AliasChoices, AliasPath, field_validator
+from pandas import DataFrame
+from uuid import UUID
+from datetime import datetime
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import (
+        Workspace,
+        Thing,
+        Sensor,
+        ObservedProperty,
+        Unit,
+        ProcessingLevel,
+    )
+
+
+class DatastreamFields(BaseModel):
+    name: str = Field(..., max_length=255)
+    description: str
+    observation_type: str = Field(..., max_length=255)
+    sampled_medium: str = Field(
+        ...,
+        max_length=255,
+        validation_alias=AliasChoices(
+            "sampledMedium", AliasPath("properties", "sampledMedium")
+        ),
+    )
+    no_data_value: float = Field(
+        ...,
+        validation_alias=AliasChoices(
+            "noDataValue", AliasPath("properties", "noDataValue")
+        ),
+    )
+    aggregation_statistic: str = Field(
+        ...,
+        max_length=255,
+        validation_alias=AliasChoices(
+            "aggregationStatistic", AliasPath("properties", "aggregationStatistic")
+        ),
+    )
+    time_aggregation_interval: float = Field(
+        ...,
+        validation_alias=AliasChoices(
+            "timeAggregationInterval",
+            AliasPath("properties", "timeAggregationInterval"),
+        ),
+    )
+    status: Optional[str] = Field(
+        None,
+        max_length=255,
+        validation_alias=AliasChoices("status", AliasPath("properties", "status")),
+    )
+    result_type: str = Field(
+        ...,
+        max_length=255,
+        validation_alias=AliasChoices(
+            "resultType", AliasPath("properties", "resultType")
+        ),
+    )
+    value_count: Optional[int] = Field(
+        None,
+        ge=0,
+        validation_alias=AliasChoices(
+            "valueCount", AliasPath("properties", "valueCount")
+        ),
+    )
+    phenomenon_begin_time: Optional[datetime] = Field(
+        None, validation_alias=AliasChoices("phenomenonBeginTime", "phenomenonTime")
+    )
+    phenomenon_end_time: Optional[datetime] = Field(
+        None, validation_alias=AliasChoices("phenomenonEndTime", "phenomenonTime")
+    )
+    result_begin_time: Optional[datetime] = Field(
+        None, validation_alias=AliasChoices("resultBeginTime", "resultTime")
+    )
+    result_end_time: Optional[datetime] = Field(
+        None, validation_alias=AliasChoices("resultEndTime", "resultTime")
+    )
+    is_private: bool = Field(
+        False,
+        validation_alias=AliasChoices(
+            "isPrivate", AliasPath("properties", "isPrivate")
+        ),
+    )
+    is_visible: bool = Field(
+        True,
+        validation_alias=AliasChoices(
+            "isVisible", AliasPath("properties", "isVisible")
+        ),
+    )
+    time_aggregation_interval_unit: Literal["seconds", "minutes", "hours", "days"] = (
+        Field(
+            ...,
+            validation_alias=AliasChoices(
+                "timeAggregationIntervalUnit",
+                AliasPath("properties", "timeAggregationIntervalUnitOfMeasurement"),
+            ),
+        )
+    )
+    intended_time_spacing: Optional[float] = Field(
+        None,
+        validation_alias=AliasChoices(
+            "intendedTimeSpacing", AliasPath("properties", "intendedTimeSpacing")
+        ),
+    )
+    intended_time_spacing_unit: Optional[
+        Literal["seconds", "minutes", "hours", "days"]
+    ] = Field(
+        None,
+        validation_alias=AliasChoices(
+            "intendedTimeSpacingUnit",
+            AliasPath("properties", "intendedTimeSpacingUnit"),
+        ),
+    )
+
+    @field_validator(
+        "phenomenon_begin_time",
+        "phenomenon_end_time",
+        "result_begin_time",
+        "result_end_time",
+        mode="before",
+    )
+    def split_time(cls, value: str, info) -> str:
+        if isinstance(value, str):
+            parts = value.split("/")
+            return parts[0] if "begin" in info.field_name else parts[-1]
+        return value
+
+
+class Datastream(HydroServerModel, DatastreamFields):
+    def __init__(
+        self,
+        _connection: "HydroServer",
+        _uid: Union[UUID, str],
+        **data,
+    ):
+        super().__init__(
+            _connection=_connection, _model_ref="datastreams", _uid=_uid, **data
+        )
+
+        self._workspace_id = str(
+            data.get("workspace_id")
+            or data.get("workspaceId")
+            or data["properties"]["workspace"]["id"]
+        )
+        self._processing_level_id = str(
+            data.get("workspace_id")
+            or data.get("workspaceId")
+            or data["properties"]["processingLevelId"]
+        )
+        self._unit_id = str(
+            data.get("unit_id") or data.get("unitId") or data["properties"]["unitId"]
+        )
+
+        self._workspace = None
+        self._thing = None
+        self._observed_property = None
+        self._unit = None
+        self._processing_level = None
+        self._sensor = None
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this datastream belongs to."""
+
+        if self._workspace is None:
+            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+
+        return self._workspace
+
+    @property
+    def thing(self) -> "Thing":
+        """The thing this datastream belongs to."""
+
+        if self._thing is None:
+            self._thing = self._connection.things.get(
+                uid=self.uid,
+                fetch_by_datastream_uid=True,
+            )
+            self._original_data["thing"] = self._thing
+
+        return self._thing
+
+    @thing.setter
+    def thing(self, thing: Union["Thing", UUID, str]):
+        if not thing:
+            raise ValueError("Thing of datastream cannot be None.")
+        if str(getattr(thing, "uid", thing)) != str(self.thing.uid):
+            self._thing = self._connection.things.get(
+                uid=str(getattr(thing, "uid", thing))
+            )
+
+    @property
+    def sensor(self) -> "Sensor":
+        """The sensor this datastream uses."""
+
+        if self._sensor is None:
+            self._sensor = self._connection.sensors.get(
+                uid=self.uid,
+                fetch_by_datastream_uid=True,
+            )
+            self._original_data["sensor"] = self._sensor
+
+        return self._sensor
+
+    @sensor.setter
+    def sensor(self, sensor: Union["Sensor", UUID, str]):
+        if not sensor:
+            raise ValueError("Sensor of datastream cannot be None.")
+        if str(getattr(sensor, "uid", sensor)) != str(self.sensor.uid):
+            self._sensor = self._connection.sensors.get(
+                uid=str(getattr(sensor, "uid", sensor))
+            )
+
+    @property
+    def observed_property(self) -> "Thing":
+        """The observed property of this datastream."""
+
+        if self._observed_property is None:
+            self._observed_property = self._connection.observedproperties.get(
+                uid=self.uid,
+                fetch_by_datastream_uid=True,
+            )
+            self._original_data["observed_property"] = self._observed_property
+
+        return self._observed_property
+
+    @observed_property.setter
+    def observed_property(
+        self, observed_property: Union["ObservedProperty", UUID, str]
+    ):
+        if not observed_property:
+            raise ValueError("Observed property of datastream cannot be None.")
+        if str(getattr(observed_property, "uid", observed_property)) != str(
+            self.observed_property.uid
+        ):
+            self._observed_property = self._connection.observedproperties.get(
+                uid=str(getattr(observed_property, "uid", observed_property))
+            )
+
+    @property
+    def unit(self) -> "Unit":
+        """The unit this datastream uses."""
+
+        if self._unit is None:
+            self._unit = self._connection.units.get(uid=self._unit_id)
+            self._original_data["unit"] = self._unit
+
+        return self._unit
+
+    @unit.setter
+    def unit(self, unit: Union["Unit", UUID, str]):
+        if not unit:
+            raise ValueError("Unit of datastream cannot be None.")
+        if str(getattr(unit, "uid", unit)) != str(self.unit.uid):
+            self._unit = self._connection.units.get(uid=str(getattr(unit, "uid", unit)))
+
+    @property
+    def processing_level(self) -> "Thing":
+        """The processing level of this datastream."""
+
+        if self._processing_level is None:
+            self._processing_level = self._connection.processinglevels.get(
+                uid=self._processing_level_id
+            )
+            self._original_data["processing_level"] = self._processing_level
+
+        return self._processing_level
+
+    @processing_level.setter
+    def processing_level(self, processing_level: Union["ProcessingLevel", UUID, str]):
+        if not processing_level:
+            raise ValueError("Processing level of datastream cannot be None.")
+        if str(getattr(processing_level, "uid", processing_level)) != str(
+            self.processing_level.uid
+        ):
+            self._processing_level = self._connection.processinglevels.get(
+                uid=str(getattr(processing_level, "uid", processing_level))
+            )
+
+    def refresh(self):
+        """Refresh this datastream from HydroServer."""
+
+        self._workspace = None
+        self._workspace_id = None
+        self._thing = None
+        self._observed_property = None
+        self._unit = None
+        self._unit_id = None
+        self._processing_level = None
+        self._processing_level_id = None
+        self._sensor = None
+        super()._refresh()
+
+    def save(self):
+        """Save changes to this datastream to HydroServer."""
+
+        super()._save()
+
+    def delete(self):
+        """Delete this datastream from HydroServer."""
+
+        super()._delete()
+
+    def get_observations(
+        self,
+        start_time: datetime = None,
+        end_time: datetime = None,
+        page: int = 1,
+        page_size: int = 100000,
+        include_quality: bool = False,
+        fetch_all: bool = False,
+    ) -> DataFrame:
+        """Retrieve the observations for this datastream."""
+
+        return self._connection.datastreams.get_observations(
+            uid=self.uid,
+            start_time=start_time,
+            end_time=end_time,
+            page=page,
+            page_size=page_size,
+            include_quality=include_quality,
+            fetch_all=fetch_all,
+        )
+
+    def load_observations(
+        self,
+        observations: DataFrame,
+    ) -> None:
+        """Load a DataFrame of observations to the datastream."""
+
+        return self._connection.datastreams.load_observations(
+            uid=self.uid,
+            observations=observations,
+        )

hydroserverpy/api/models/sta/observed_property.py

@@ -0,0 +1,72 @@
+from typing import Union, TYPE_CHECKING
+from uuid import UUID
+from pydantic import BaseModel, Field, AliasChoices, AliasPath
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class ObservedPropertyFields(BaseModel):
+    name: str = Field(..., max_length=255)
+    definition: str
+    description: str
+    observed_property_type: str = Field(
+        ...,
+        max_length=255,
+        serialization_alias="type",
+        validation_alias=AliasChoices("type", AliasPath("properties", "variableType")),
+    )
+    code: str = Field(
+        ...,
+        max_length=255,
+        validation_alias=AliasChoices("code", AliasPath("properties", "variableCode")),
+    )
+
+
+class ObservedProperty(HydroServerModel, ObservedPropertyFields):
+    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
+        super().__init__(
+            _connection=_connection, _model_ref="observedproperties", _uid=_uid, **data
+        )
+
+        self._workspace_id = (
+            data.get("workspace_id")
+            or data.get("workspaceId")
+            or (
+                None
+                if data.get("properties", {}).get("workspace") is None
+                else data.get("properties", {}).get("workspace", {}).get("id")
+            )
+        )
+        self._workspace_id = (
+            str(self._workspace_id) if self._workspace_id is not None else None
+        )
+
+        self._workspace = None
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this observed property belongs to."""
+
+        if self._workspace is None and self._workspace_id:
+            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+
+        return self._workspace
+
+    def refresh(self):
+        """Refresh this observed property from HydroServer."""
+
+        super()._refresh()
+        self._workspace = None
+
+    def save(self):
+        """Save changes to this observed property to HydroServer."""
+
+        super()._save()
+
+    def delete(self):
+        """Delete this observed property from HydroServer."""
+
+        super()._delete()