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

hydroserverpy/api/models/etl/data_source.py

@@ -1,60 +1,49 @@
-import requests
+import uuid
 import tempfile
-from typing import Union, List, Optional, TYPE_CHECKING
-from uuid import UUID
-from pydantic import BaseModel, Field
+import requests
+from typing import Union, ClassVar, Optional, TYPE_CHECKING, List
+from pydantic import Field
 from hydroserverpy.etl_csv.hydroserver_etl_csv import HydroServerETLCSV
 from .orchestration_system import OrchestrationSystem
 from .orchestration_configuration import OrchestrationConfigurationFields
 from ..sta.datastream import Datastream
-from ..base import HydroServerModel
+from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
     from hydroserverpy.api.models import Workspace
 
 
-class DataSourceFields(BaseModel):
+class DataSource(
+    HydroServerBaseModel, OrchestrationConfigurationFields
+):
     name: str = Field(..., max_length=255)
     settings: Optional[dict] = None
+    orchestration_system_id: uuid.UUID
+    workspace_id: uuid.UUID
 
+    _editable_fields: ClassVar[set[str]] = {
+        "name", "settings", "interval", "interval_units", "crontab", "start_time", "end_time", "last_run_successful",
+        "last_run_message", "last_run", "next_run", "paused"
+    }
 
-class DataSource(HydroServerModel, DataSourceFields, OrchestrationConfigurationFields):
-    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
-        super().__init__(
-            _connection=_connection, _model_ref="datasources", _uid=_uid, **data
-        )
-
-        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
-        self._orchestration_system_id = str(
-            data.get("orchestration_system_id") or data["orchestrationSystem"]["id"]
-        )
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.datasources, **data)
 
         self._workspace = None
+        self._orchestration_system = None
+        self._datastreams = None
 
-        if data.get("orchestrationSystem"):
-            self._orchestration_system = OrchestrationSystem(
-                _connection=_connection,
-                _uid=self._orchestration_system_id,
-                **data["orchestrationSystem"]
-            )
-        else:
-            self._orchestration_system = None
-
-        if data.get("datastreams"):
-            self._datastreams = [
-                Datastream(_connection=_connection, _uid=datastream["id"], **datastream)
-                for datastream in data["datastreams"]
-            ]
-        else:
-            self._datastreams = []
+    @classmethod
+    def get_route(cls):
+        return "data-sources"
 
     @property
     def workspace(self) -> "Workspace":
         """The workspace this data source 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:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
 
         return self._workspace
 
@@ -62,62 +51,31 @@ class DataSource(HydroServerModel, DataSourceFields, OrchestrationConfigurationF
     def orchestration_system(self) -> "OrchestrationSystem":
         """The orchestration system that manages this data source."""
 
-        if self._orchestration_system is None and self._orchestration_system_id:
-            self._orchestration_system = self._connection.orchestration_systems.get(
-                uid=self._orchestration_system_id
-            )
+        if self._orchestration_system is None:
+            self._orchestration_system = self.client.orchestrationsystems.get(uid=self.orchestration_system_id)
 
         return self._orchestration_system
 
-    @orchestration_system.setter
-    def orchestration_system(
-        self, orchestration_system: Union["OrchestrationSystem", UUID, str]
-    ):
-        if not orchestration_system:
-            raise ValueError("Orchestration system of data source cannot be None.")
-        if str(getattr(orchestration_system, "uid", orchestration_system)) != str(
-            self.orchestration_system.uid
-        ):
-            self._orchestration_system = self._connection.orchestrationsystems.get(
-                uid=str(getattr(orchestration_system, "uid", orchestration_system))
-            )
-
     @property
     def datastreams(self) -> List["Datastream"]:
         """The datastreams this data source provides data for."""
 
         if self._datastreams is None:
-            data_source = self._connection.datasources.get(uid=self.uid)
-            self._datastreams = data_source.datastreams
+            self._datastreams = self.client.datastreams.list(data_source=self.uid, fetch_all=True).items
 
         return self._datastreams
 
-    def refresh(self):
-        """Refresh this data source from HydroServer."""
-
-        super()._refresh()
-        self._workspace = None
-        self._datastreams = None
-
-    def save(self):
-        """Save changes to this data source to HydroServer."""
-
-        super()._save()
-
-    def delete(self):
-        """Delete this data source from HydroServer."""
-
-        super()._delete()
-
-    def add_datastream(self, datastream: Union["Datastream", UUID, str]):
+    def add_datastream(self, datastream: Union["Datastream", uuid.UUID, str]):
         """Add a datastream to this data source."""
 
-        self._connection.datasources.add_datastream(uid=self.uid, datastream=datastream)
+        self.client.datasources.add_datastream(
+            uid=self.uid, datastream=datastream
+        )
 
-    def remove_datastream(self, datastream: Union["Datastream", UUID, str]):
+    def remove_datastream(self, datastream: Union["Datastream", uuid.UUID, str]):
         """Remove a datastream from this data source."""
 
-        self._connection.datasources.remove_datastream(
+        self.client.datasources.remove_datastream(
             uid=self.uid, datastream=datastream
         )
 
@@ -131,7 +89,7 @@ class DataSource(HydroServerModel, DataSourceFields, OrchestrationConfigurationF
         if self.settings["extractor"]["type"] == "local":
             with open(self.settings["extractor"]["sourceUri"]) as data_file:
                 loader = HydroServerETLCSV(
-                    self._connection, data_file=data_file, data_source=self
+                    self.client, data_file=data_file, data_source=self
                 )
                 loader.run()
         elif self.settings["extractor"]["type"] == "HTTP":
@@ -148,6 +106,6 @@ class DataSource(HydroServerModel, DataSourceFields, OrchestrationConfigurationF
                         temp_file.write(chunk.decode("utf-8"))
                 temp_file.seek(0)
                 loader = HydroServerETLCSV(
-                    self._connection, data_file=temp_file, data_source=self
+                    self.client, data_file=temp_file, data_source=self
                 )
                 loader.run()

hydroserverpy/api/models/etl/orchestration_system.py

@@ -1,7 +1,7 @@
-from typing import Union, List, TYPE_CHECKING
-from uuid import UUID
+import uuid
+from typing import Optional, ClassVar, List, TYPE_CHECKING
 from pydantic import BaseModel, Field
-from ..base import HydroServerModel
+from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
@@ -13,27 +13,30 @@ class OrchestrationSystemFields(BaseModel):
     orchestration_system_type: str = Field(..., max_length=255, alias="type")
 
 
-class OrchestrationSystem(HydroServerModel, OrchestrationSystemFields):
-    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
-        super().__init__(
-            _connection=_connection,
-            _model_ref="orchestrationsystems",
-            _uid=_uid,
-            **data
-        )
+class OrchestrationSystem(HydroServerBaseModel):
+    name: str = Field(..., max_length=255)
+    orchestration_system_type: str = Field(..., max_length=255, alias="type")
+    workspace_id: Optional[uuid.UUID] = None
 
-        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
+    _editable_fields: ClassVar[set[str]] = {"name", "orchestration_system_type"}
+
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.orchestrationsystems, **data)
 
         self._workspace = None
         self._datasources = None
         self._dataarchives = None
 
+    @classmethod
+    def get_route(cls):
+        return "orchestration-systems"
+
     @property
     def workspace(self) -> "Workspace":
         """The workspace this orchestration system 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
 
@@ -42,9 +45,9 @@ class OrchestrationSystem(HydroServerModel, OrchestrationSystemFields):
         """The data sources associated with this workspace."""
 
         if self._datasources is None:
-            self._datasources = self._connection.datasources.list(
-                orchestration_system=self.uid
-            )
+            self._datasources = self.client.datasources.list(
+                orchestration_system=self.uid, fetch_all=True
+            ).items
 
         return self._datasources
 
@@ -53,26 +56,8 @@ class OrchestrationSystem(HydroServerModel, OrchestrationSystemFields):
         """The data archives associated with this workspace."""
 
         if self._dataarchives is None:
-            self._dataarchives = self._connection.dataarchives.list(
-                orchestration_system=self.uid
-            )
+            self._dataarchives = self.client.dataarchives.list(
+                orchestration_system=self.uid, fetch_all=True
+            ).items
 
         return self._dataarchives
-
-    def refresh(self):
-        """Refresh this orchestration system from HydroServer."""
-
-        super()._refresh()
-        self._workspace = None
-        self._datasources = None
-        self._dataarchives = None
-
-    def save(self):
-        """Save changes to this orchestration system to HydroServer."""
-
-        super()._save()
-
-    def delete(self):
-        """Delete this orchestration system from HydroServer."""
-
-        super()._delete()

hydroserverpy/api/models/iam/apikey.py

@@ -1,77 +1,96 @@
-from typing import Optional, Union, TYPE_CHECKING
+from typing import Optional, Union, ClassVar, TYPE_CHECKING
 from uuid import UUID
 from datetime import datetime
-from pydantic import BaseModel
-from ..base import HydroServerModel
+from hydroserverpy.api.models.iam.role import Role
+from hydroserverpy.api.utils import normalize_uuid
+from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
-    from hydroserverpy.api.models import Workspace, Role
+    from hydroserverpy.api.models import Workspace
 
 
-class APIKeyFields(BaseModel):
+class APIKey(HydroServerBaseModel):
     name: str
+    role_id: Union[UUID, str]
+    workspace_id: Union[UUID, str]
     description: Optional[str] = None
     is_active: bool
     expires_at: Optional[datetime] = None
-    role: "Role"
 
+    _editable_fields: ClassVar[set[str]] = {"name", "description", "role_id", "is_active", "expires_at"}
 
-class APIKey(HydroServerModel, APIKeyFields):
-    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
-        super().__init__(
-            _connection=_connection, _model_ref="apikeys", _uid=_uid, **data
-        )
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=None, **data)
 
-        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
         self._workspace = None
+        self._role = None
 
     @property
     def workspace(self) -> "Workspace":
-        """The workspace this data source belongs to."""
+        """The workspace this API key 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:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
 
         return self._workspace
 
-    def refresh(self):
-        """Refresh this data source from HydroServer."""
+    @property
+    def role(self) -> "Role":
+        """The role this API key is assigned."""
 
-        self._original_data = (
-            self._connection.workspaces.get_api_key(
-                uid=self._workspace_id, api_key_id=self.uid
-            ).model_dump(exclude=["uid"])
-        )
-        self.__dict__.update(self._original_data)
-        self._workspace = None
+        if self._role is None:
+            self._role = self.client.roles.get(uid=self.role_id)
+
+        return self._role
+
+    @role.setter
+    def role(self, role: Union["Role", UUID, str] = ...):
+        if not role:
+            raise ValueError("Role of API key cannot be None.")
+        if normalize_uuid(role) != str(self.role_id):
+            self.role_id = normalize_uuid(role)
+            self._role = None
 
     def save(self):
-        """Save changes to this data source to HydroServer."""
+        """Saves changes to this resource to HydroServer."""
+
+        if not self.uid:
+            raise AttributeError("Data cannot be saved: UID is not set.")
 
-        if self._patch_data:
-            api_key = self._connection.workspaces.update_api_key(
-                uid=self._workspace_id, api_key_id=self.uid, **self._patch_data
+        if self.unsaved_changes:
+            saved_resource = self.client.workspaces.update_api_key(
+                uid=self.workspace_id, api_key_id=self.uid, **self.unsaved_changes
             )
-            self._original_data = api_key.dict(by_alias=False, exclude=["uid"])
-            self.__dict__.update(self._original_data)
+            self._server_data = saved_resource.dict(by_alias=False).copy()
+            self.__dict__.update(saved_resource.__dict__)
+
+    def refresh(self):
+        """Refreshes this resource from HydroServer."""
+
+        if self.uid is None:
+            raise ValueError("Cannot refresh data without a valid ID.")
+
+        refreshed_resource = self.client.workspaces.get_api_key(uid=self.workspace_id, api_key_id=self.uid)
+        self._server_data = refreshed_resource.dict(by_alias=False).copy()
+        self.__dict__.update(refreshed_resource.__dict__)
 
     def delete(self):
-        """Delete this data source from HydroServer."""
+        """Deletes this resource from HydroServer."""
 
-        if not self._uid:
-            raise AttributeError("This resource cannot be deleted: UID is not set.")
+        if self.uid is None:
+            raise AttributeError("Cannot delete data without a valid ID.")
 
-        self._connection.workspaces.delete_api_key(
-            uid=self._workspace_id, api_key_id=self.uid
+        self.client.workspaces.delete_api_key(
+            uid=self.workspace_id, api_key_id=self.uid
         )
-        self._uid = None
+        self.uid = None
 
     def regenerate(self):
         """Regenerates this API key. WARNING: Previous key will be invalidated."""
 
-        _, key = self._connection.workspaces.regenerate_api_key(
-            uid=self._workspace_id, api_key_id=self.uid
+        _, key = self.client.workspaces.regenerate_api_key(
+            uid=self.workspace_id, api_key_id=self.uid
         )
 
         return key

hydroserverpy/api/models/iam/collaborator.py

@@ -1,34 +1,70 @@
-from typing import Union, TYPE_CHECKING
+from typing import Union, ClassVar, TYPE_CHECKING
 from uuid import UUID
-from pydantic import BaseModel
+from pydantic import Field, AliasPath
+from hydroserverpy.api.models.iam.role import Role
+from hydroserverpy.api.utils import normalize_uuid
+from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models.iam.workspace import Workspace
     from hydroserverpy.api.models.iam.account import Account
-    from hydroserverpy.api.models.iam.role import Role
 
 
-class CollaboratorFields(BaseModel):
+class Collaborator(HydroServerBaseModel):
     user: "Account"
-    role: "Role"
+    role_id: Union[UUID, str] = Field(..., validation_alias=AliasPath("role", "id"))
     workspace_id: Union[UUID, str]
 
+    _editable_fields: ClassVar[set[str]] = {"role_id"}
 
-class Collaborator(CollaboratorFields):
-    def __init__(self, _connection, **data):
-        super().__init__(**data)
-        self._connection = _connection
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=None, **data)
 
-    def edit_role(self, role: Union["Role", UUID, str]):
-        """Edit the role of this workspace collaborator."""
+        self._workspace = None
+        self._role = Role(client=client, **data.get("role"))
 
-        response = self._connection.workspaces.edit_collaborator_role(
-            uid=self.workspace_id, email=self.user.email, role=role
-        )
-        self.role = response.role
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this collaborator belongs to."""
+
+        if self._workspace is None:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
+
+        return self._workspace
+
+    @property
+    def role(self) -> "Role":
+        """The role this collaborator is assigned."""
+
+        if self._role is None:
+            self._role = self.client.roles.get(uid=self.role_id)
+
+        return self._role
+
+    @role.setter
+    def role(self, role: Union["Role", UUID, str] = ...):
+        if not role:
+            raise ValueError("Role of collaborator cannot be None.")
+        if normalize_uuid(role) != str(self.role_id):
+            self.role_id = normalize_uuid(role)
+            self._role = None
+
+    def save(self):
+        """Saves changes to this resource to HydroServer."""
+
+        if self.unsaved_changes:
+            self.client.workspaces.edit_collaborator_role(
+                uid=str(self.workspace_id), email=self.user.email, role=self.role
+            )
+            self._role = None
+            self._server_data["role_id"] = self.role_id
+            self.__dict__.update({"role_id": self.role_id})
 
-    def remove(self):
-        """Remove this collaborator from the workspace."""
+    def delete(self):
+        """Deletes this resource from HydroServer."""
 
-        self._connection.workspaces.remove_collaborator(
-            uid=self.workspace_id, email=self.user.email
+        self.client.workspaces.remove_collaborator(
+            uid=str(self.workspace_id), email=self.user.email
         )
+        self.uid = None

hydroserverpy/api/models/iam/role.py

@@ -1,10 +1,38 @@
-from typing import Optional, Union
+from typing import Optional, Union, TYPE_CHECKING
 from uuid import UUID
-from pydantic import BaseModel, Field
+from pydantic import Field
+from ..base import HydroServerBaseModel
 
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
 
-class Role(BaseModel):
-    uid: UUID = Field(..., alias="id")
+
+class Role(HydroServerBaseModel):
     name: str = Field(..., max_length=255)
     description: str
     workspace_id: Optional[Union[UUID, str]] = None
+
+    def __init__(self, client: "HydroServer", **data):
+        super().__init__(client=client, service=client.workspaces, **data)
+
+        self._workspace = None
+
+    @classmethod
+    def get_route(cls):
+        return "roles"
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this role belongs to."""
+
+        if self._workspace is None and self.workspace_id is not None:
+            self._workspace = self.client.workspaces.get(uid=self.workspace_id)
+
+        return self._workspace
+
+    def save(self):
+        raise NotImplementedError("Editing roles not enabled.")
+
+    def delete(self):
+        raise NotImplementedError("Deleting roles not enabled.")