hydroserverpy 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

hydroserverpy/api/models/sta/processing_level.py

@@ -1,50 +1,35 @@
-from typing import Union, Optional, TYPE_CHECKING
-from uuid import UUID
-from pydantic import BaseModel, Field
-from ..base import HydroServerModel
+import uuid
+from typing import Optional, ClassVar, TYPE_CHECKING
+from pydantic import Field
+from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
     from hydroserverpy.api.models import Workspace
 
 
-class ProcessingLevelFields(BaseModel):
+class ProcessingLevel(HydroServerBaseModel):
     code: str = Field(..., max_length=255)
     definition: Optional[str] = None
     explanation: Optional[str] = None
+    workspace_id: Optional[uuid.UUID] = None
 
+    _editable_fields: ClassVar[set[str]] = {"code", "definition", "explanation"}
 
-class ProcessingLevel(HydroServerModel, ProcessingLevelFields):
-    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
-        super().__init__(
-            _connection=_connection, _model_ref="processinglevels", _uid=_uid, **data
-        )
-
-        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.processinglevels, **data)
 
         self._workspace = None
 
+    @classmethod
+    def get_route(cls):
+        return "processing-levels"
+
     @property
-    def workspace(self) -> "Workspace":
+    def workspace(self) -> Optional["Workspace"]:
         """The workspace this processing level belongs to."""
 
-        if self._workspace is None and self._workspace_id:
-            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+        if self._workspace is None and self.workspace_id:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
 
         return self._workspace
-
-    def refresh(self):
-        """Refresh this processing level from HydroServer."""
-
-        super()._refresh()
-        self._workspace = None
-
-    def save(self):
-        """Save changes to this processing level to HydroServer."""
-
-        super()._save()
-
-    def delete(self):
-        """Delete this processing level from HydroServer."""
-
-        super()._delete()

hydroserverpy/api/models/sta/result_qualifier.py

@@ -1,49 +1,34 @@
-from typing import Union, Optional, TYPE_CHECKING
-from uuid import UUID
-from pydantic import BaseModel, Field
-from ..base import HydroServerModel
+import uuid
+from typing import Optional, ClassVar, TYPE_CHECKING
+from pydantic import Field
+from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
     from hydroserverpy.api.models import Workspace
 
 
-class ResultQualifierFields(BaseModel):
+class ResultQualifier(HydroServerBaseModel):
     code: str = Field(..., max_length=255)
     description: str
+    workspace_id: Optional[uuid.UUID] = None
 
+    _editable_fields: ClassVar[set[str]] = {"code", "description"}
 
-class ResultQualifier(HydroServerModel, ResultQualifierFields):
-    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
-        super().__init__(
-            _connection=_connection, _model_ref="resultqualifiers", _uid=_uid, **data
-        )
-
-        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.resultqualifiers, **data)
 
         self._workspace = None
 
+    @classmethod
+    def get_route(cls):
+        return "result-qualifiers"
+
     @property
-    def workspace(self) -> "Workspace":
+    def workspace(self) -> Optional["Workspace"]:
         """The workspace this result qualifier belongs to."""
 
-        if self._workspace is None and self._workspace_id:
-            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+        if self._workspace is None and self.workspace_id:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
 
         return self._workspace
-
-    def refresh(self):
-        """Refresh this result qualifier from HydroServer."""
-
-        super()._refresh()
-        self._workspace = None
-
-    def save(self):
-        """Save changes to this result qualifier to HydroServer."""
-
-        super()._save()
-
-    def delete(self):
-        """Delete this result qualifier from HydroServer."""
-
-        super()._delete()

hydroserverpy/api/models/sta/sensor.py

@@ -1,105 +1,44 @@
-from typing import Union, Optional, TYPE_CHECKING
-from uuid import UUID
-from pydantic import BaseModel, Field, AliasChoices, AliasPath
-from ..base import HydroServerModel
+import uuid
+from typing import Optional, ClassVar, TYPE_CHECKING
+from pydantic import Field
+from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
     from hydroserverpy.api.models import Workspace
 
 
-class SensorFields(BaseModel):
+class Sensor(HydroServerBaseModel):
     name: str = Field(..., max_length=255)
     description: str
     encoding_type: str = Field(..., max_length=255)
-    manufacturer: Optional[str] = Field(
-        None,
-        max_length=255,
-        validation_alias=AliasChoices(
-            "manufacturer", AliasPath("metadata", "sensorModel", "sensorManufacturer")
-        ),
-    )
-    sensor_model: Optional[str] = Field(
-        None,
-        max_length=255,
-        alias="model",
-        validation_alias=AliasChoices(
-            "model", AliasPath("metadata", "sensorModel", "sensorModelName")
-        ),
-    )
-    sensor_model_link: Optional[str] = Field(
-        None,
-        max_length=500,
-        alias="modelLink",
-        validation_alias=AliasChoices(
-            "modelLink", AliasPath("metadata", "sensorModel", "sensorModelUrl")
-        ),
-    )
-    method_type: str = Field(
-        ...,
-        max_length=100,
-        validation_alias=AliasChoices(
-            "methodType", AliasPath("metadata", "methodType")
-        ),
-    )
-    method_link: Optional[str] = Field(
-        None,
-        max_length=500,
-        validation_alias=AliasChoices(
-            "methodLink", AliasPath("metadata", "methodLink")
-        ),
-    )
-    method_code: Optional[str] = Field(
-        None,
-        max_length=50,
-        validation_alias=AliasChoices(
-            "methodCode", AliasPath("metadata", "methodCode")
-        ),
-    )
-
-
-class Sensor(HydroServerModel, SensorFields):
-    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
-        super().__init__(
-            _connection=_connection, _model_ref="sensors", _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
-        )
+    manufacturer: Optional[str] = Field(None, max_length=255)
+    sensor_model: Optional[str] = Field(None, max_length=255, alias="model")
+    sensor_model_link: Optional[str] = Field(None, max_length=500, alias="modelLink")
+    method_type: str = Field(..., max_length=100)
+    method_link: Optional[str] = Field(None, max_length=500)
+    method_code: Optional[str] = Field(None, max_length=50)
+    workspace_id: Optional[uuid.UUID] = None
+
+    _editable_fields: ClassVar[set[str]] = {
+        "name", "description", "encoding_type", "manufacturer", "sensor_model", "sensor_model_link", "method_type",
+        "method_link", "method_code"
+    }
+
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.sensors, **data)
 
         self._workspace = None
 
+    @classmethod
+    def get_route(cls):
+        return "sensors"
+
     @property
-    def workspace(self) -> "Workspace":
+    def workspace(self) -> Optional["Workspace"]:
         """The workspace this sensor belongs to."""
 
-        if self._workspace is None and self._workspace_id:
-            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+        if self._workspace is None and self.workspace_id:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
 
         return self._workspace
-
-    def refresh(self):
-        """Refresh this sensor from HydroServer."""
-
-        super()._refresh()
-        self._workspace = None
-
-    def save(self):
-        """Save changes to this sensor to HydroServer."""
-
-        super()._save()
-
-    def delete(self):
-        """Delete this sensor from HydroServer."""
-
-        super()._delete()

hydroserverpy/api/models/sta/thing.py

@@ -1,162 +1,63 @@
-from typing import Optional, Union, List, Dict, IO, TYPE_CHECKING
-from uuid import UUID
+import uuid
+from typing import Optional, ClassVar, List, Dict, IO, TYPE_CHECKING
 from pydantic import (
-    BaseModel,
     Field,
-    AliasChoices,
     AliasPath,
+    AliasChoices,
     AnyHttpUrl,
-    field_validator,
+    field_validator
 )
-from ..base import HydroServerModel
+from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
     from hydroserverpy.api.models import Workspace, Datastream
 
 
-class ThingFields(BaseModel):
+class Thing(HydroServerBaseModel):
     name: str = Field(..., max_length=200)
     description: str
-    sampling_feature_type: str = Field(
-        ...,
-        max_length=200,
-        validation_alias=AliasChoices(
-            "samplingFeatureType", AliasPath("properties", "samplingFeatureType")
-        ),
-    )
-    sampling_feature_code: str = Field(
-        ...,
-        max_length=200,
-        validation_alias=AliasChoices(
-            "samplingFeatureCode", AliasPath("properties", "samplingFeatureCode")
-        ),
-    )
-    site_type: str = Field(
-        ...,
-        max_length=200,
-        validation_alias=AliasChoices("siteType", AliasPath("properties", "siteType")),
-    )
-    tags: Dict[str, str] = Field(
-        ...,
-        json_schema_extra={"editable": False, "read_only": True},
-        validation_alias=AliasChoices("tags", AliasPath("properties", "tags")),
-    )
-    photos: Dict[str, AnyHttpUrl] = Field(
-        ...,
-        json_schema_extra={"editable": False, "read_only": True},
-        validation_alias=AliasChoices("photos", AliasPath("properties", "photos")),
-    )
-    data_disclaimer: Optional[str] = Field(
-        None,
-        validation_alias=AliasChoices(
-            "dataDisclaimer", AliasPath("properties", "dataDisclaimer")
-        ),
-    )
-    is_private: bool = Field(
-        ...,
-        validation_alias=AliasChoices(
-            "isPrivate", AliasPath("properties", "isPrivate")
-        ),
-    )
-
-    @field_validator("tags", mode="before")
-    def convert_tags(
-        cls, value: Union[List[Dict[str, str]], Dict[str, str]]
-    ) -> Dict[str, str]:
-        if isinstance(value, list):
-            return {item["key"]: item["value"] for item in value}
-        return value
-
-    @field_validator("photos", mode="before")
-    def convert_photos(
-        cls, value: Union[List[Dict[str, str]], Dict[str, str]]
-    ) -> Dict[str, str]:
-        if isinstance(value, list):
-            return {item["name"]: item["link"] for item in value}
-        return value
-
-
-class LocationFields(BaseModel):
-    latitude: float = Field(
-        ...,
-        ge=-90,
-        le=90,
-        validation_alias=AliasChoices(
-            "latitude",
-            AliasPath("Locations", 0, "location", "geometry", "coordinates", 0),
-        ),
-    )
-    longitude: float = Field(
-        ...,
-        ge=-180,
-        le=180,
-        validation_alias=AliasChoices(
-            "longitude",
-            AliasPath("Locations", 0, "location", "geometry", "coordinates", 1),
-        ),
-    )
+    sampling_feature_type: str = Field(..., max_length=200)
+    sampling_feature_code: str = Field(..., max_length=200)
+    site_type: str = Field(..., max_length=200)
+    data_disclaimer: Optional[str] = None
+    is_private: bool
+    latitude: float = Field(..., ge=-90, le=90, validation_alias=AliasPath("location", "latitude"))
+    longitude: float = Field(..., ge=-180, le=180, validation_alias=AliasPath("location", "longitude"))
     elevation_m: Optional[float] = Field(
-        None,
-        ge=-99999,
-        le=99999,
-        validation_alias=AliasChoices(
-            "elevation_m", AliasPath("Locations", 0, "properties", "elevation_m")
-        ),
+        None, ge=-99999, le=99999, alias="elevation_m", validation_alias=AliasPath("location", "elevation_m")
     )
     elevation_datum: Optional[str] = Field(
-        None,
-        max_length=255,
-        validation_alias=AliasChoices(
-            "elevationDatum", AliasPath("Locations", 0, "properties", "elevationDatum")
-        ),
-    )
-    state: Optional[str] = Field(
-        None,
-        max_length=200,
-        validation_alias=AliasChoices(
-            "state", AliasPath("Locations", 0, "properties", "state")
-        ),
-    )
-    county: Optional[str] = Field(
-        None,
-        max_length=200,
-        validation_alias=AliasChoices(
-            "county", AliasPath("Locations", 0, "properties", "county")
-        ),
-    )
-    country: Optional[str] = Field(
-        None,
-        max_length=2,
-        validation_alias=AliasChoices(
-            "country", AliasPath("Locations", 0, "properties", "country")
-        ),
+        None, max_length=255, validation_alias=AliasChoices("elevationDatum", AliasPath("location", "elevationDatum"))
     )
+    state: Optional[str] = Field(None, max_length=200, validation_alias=AliasPath("location", "state"))
+    county: Optional[str] = Field(None, max_length=200, validation_alias=AliasPath("location", "county"))
+    country: Optional[str] = Field(None, max_length=2, validation_alias=AliasPath("location", "country"))
+    tags: Dict[str, str]
+    photos: Dict[str, AnyHttpUrl]
+    workspace_id: uuid.UUID
 
+    _editable_fields: ClassVar[set[str]] = {
+        "name", "description", "sampling_feature_type", "sampling_feature_code", "site_type", "data_disclaimer",
+        "is_private", "latitude", "longitude", "elevation_m", "elevation_datum", "state", "county", "country"
+    }
 
-class Thing(HydroServerModel, ThingFields, LocationFields):
-    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
-        super().__init__(
-            _connection=_connection, _model_ref="things", _uid=_uid, **data
-        )
-
-        self._workspace_id = str(
-            data.get("workspace_id")
-            or data.get("workspaceId")
-            or data["properties"]["workspace"]["id"]
-        )
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.things, **data)
 
         self._workspace = None
         self._datastreams = None
-        self._photos = None
-        self._tags = None
+
+    @classmethod
+    def get_route(cls):
+        return "things"
 
     @property
     def workspace(self) -> "Workspace":
         """The workspace this thing belongs to."""
 
         if self._workspace is None:
-            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
 
         return self._workspace
 
@@ -165,53 +66,48 @@ class Thing(HydroServerModel, ThingFields, LocationFields):
         """The datastreams collected at this thing."""
 
         if self._datastreams is None:
-            self._datastreams = self._connection.datastreams.list(thing=self.uid)
+            self._datastreams = self.client.datastreams.list(thing=self.uid, fetch_all=True).items
 
         return self._datastreams
 
-    def refresh(self):
-        """Refresh this thing from HydroServer."""
-
-        super()._refresh()
-        self._workspace = None
-        self._datastreams = None
-
-    def save(self):
-        """Save changes to this thing to HydroServer."""
-
-        super()._save()
-
-    def delete(self):
-        """Delete this thing from HydroServer."""
+    @field_validator("tags", mode="before")
+    def transform_tags(cls, v):
+        if isinstance(v, list):
+            return {item["key"]: item["value"] for item in v if "key" in item and "value" in item}
+        return v
 
-        super()._delete()
+    @field_validator("photos", mode="before")
+    def transform_photos(cls, v):
+        if isinstance(v, list):
+            return {item["name"]: item["link"] for item in v if "name" in item and "link" in item}
+        return v
 
     def add_tag(self, key: str, value: str):
         """Add a tag to this thing."""
 
-        self._connection.things.add_tag(uid=self.uid, key=key, value=value)
+        self.client.things.add_tag(uid=self.uid, key=key, value=value)
         self.tags[key] = value
 
     def update_tag(self, key: str, value: str):
         """Edit a tag of this thing."""
 
-        self._connection.things.update_tag(uid=self.uid, key=key, value=value)
+        self.client.things.update_tag(uid=self.uid, key=key, value=value)
         self.tags[key] = value
 
     def delete_tag(self, key: str):
         """Delete a tag of this thing."""
 
-        self._connection.things.delete_tag(uid=self.uid, key=key)
+        self.client.things.delete_tag(uid=self.uid, key=key, value=self.tags[key])
         del self.tags[key]
 
     def add_photo(self, file: IO[bytes]):
         """Add a photo of this thing."""
 
-        photo = self._connection.things.add_photo(uid=self.uid, file=file)
+        photo = self.client.things.add_photo(uid=self.uid, file=file)
         self.photos[photo["name"]] = photo["link"]
 
     def delete_photo(self, name: str):
         """Delete a photo of this thing."""
 
-        self._connection.things.delete_photo(uid=self.uid, name=name)
+        self.client.things.delete_photo(uid=self.uid, name=name)
         del self.photos[name]

hydroserverpy/api/models/sta/unit.py

@@ -1,49 +1,36 @@
-from typing import Union, TYPE_CHECKING
-from uuid import UUID
-from pydantic import BaseModel, Field
-from ..base import HydroServerModel
+import uuid
+from typing import Optional, ClassVar, TYPE_CHECKING
+from pydantic import Field
+from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
     from hydroserverpy.api.models import Workspace
 
 
-class UnitFields(BaseModel):
+class Unit(HydroServerBaseModel):
     name: str = Field(..., max_length=255)
     symbol: str = Field(..., max_length=255)
     definition: str
     unit_type: str = Field(..., max_length=255, alias="type")
+    workspace_id: Optional[uuid.UUID] = None
 
+    _editable_fields: ClassVar[set[str]] = {"name", "symbol", "definition", "unit_type"}
 
-class Unit(HydroServerModel, UnitFields):
-    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
-        super().__init__(_connection=_connection, _model_ref="units", _uid=_uid, **data)
-
-        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.units, **data)
 
         self._workspace = None
 
+    @classmethod
+    def get_route(cls):
+        return "units"
+
     @property
-    def workspace(self) -> "Workspace":
+    def workspace(self) -> Optional["Workspace"]:
         """The workspace this unit belongs to."""
 
-        if self._workspace is None and self._workspace_id:
-            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+        if self._workspace is None and self.workspace_id:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
 
         return self._workspace
-
-    def refresh(self):
-        """Refresh this unit from HydroServer."""
-
-        super()._refresh()
-        self._workspace = None
-
-    def save(self):
-        """Save changes to this unit to HydroServer."""
-
-        super()._save()
-
-    def delete(self):
-        """Delete this unit from HydroServer."""
-
-        super()._delete()

hydroserverpy/api/services/__init__.py

@@ -1,4 +1,5 @@
 from .iam.workspace import WorkspaceService
+from .iam.role import RoleService
 from .sta.thing import ThingService
 from .sta.observed_property import ObservedPropertyService
 from .sta.unit import UnitService