hydroserverpy 0.5.0b1__py3-none-any.whl → 0.5.0b3__py3-none-any.whl

hydroserverpy/api/http.py

@@ -3,8 +3,6 @@ from requests import HTTPError
 
 
 def raise_for_hs_status(response):
-    """"""
-
     try:
         response.raise_for_status()
     except HTTPError as e:

hydroserverpy/api/main.py

@@ -10,6 +10,9 @@ from hydroserverpy.api.services import (
     ResultQualifierService,
     SensorService,
     DatastreamService,
+    OrchestrationSystemService,
+    DataSourceService,
+    DataArchiveService,
 )
 
 
@@ -150,3 +153,21 @@ class HydroServer:
         """Utilities for managing HydroServer datastreams."""
 
         return DatastreamService(self)
+
+    @property
+    def orchestrationsystems(self):
+        """Utilities for managing HydroServer orchestration systems."""
+
+        return OrchestrationSystemService(self)
+
+    @property
+    def datasources(self):
+        """Utilities for managing HydroServer data sources."""
+
+        return DataSourceService(self)
+
+    @property
+    def dataarchives(self):
+        """Utilities for managing HydroServer data archives."""
+
+        return DataArchiveService(self)

hydroserverpy/api/models/__init__.py

@@ -10,6 +10,9 @@ from .sta.result_qualifier import ResultQualifier
 from .sta.sensor import Sensor
 from .sta.thing import Thing
 from .sta.unit import Unit
+from .etl.orchestration_system import OrchestrationSystem
+from .etl.data_source import DataSource
+from .etl.data_archive import DataArchive
 
 Workspace.model_rebuild()
 Role.model_rebuild()

hydroserverpy/api/models/etl/data_archive.py

@@ -0,0 +1,105 @@
+from typing import Union, Optional, TYPE_CHECKING, List
+from uuid import UUID
+from pydantic import BaseModel, Field
+from .orchestration_system import OrchestrationSystem
+from .orchestration_configuration import OrchestrationConfigurationFields
+from ..sta.datastream import Datastream
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class DataArchiveFields(BaseModel):
+    name: str = Field(..., max_length=255)
+    settings: Optional[dict] = None
+
+
+class DataArchive(
+    HydroServerModel, DataArchiveFields, OrchestrationConfigurationFields
+):
+    def __init__(self, _connection: "HydroServer", _uid: Union[UUID, str], **data):
+        super().__init__(
+            _connection=_connection, _model_ref="dataarchives", _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"]
+        )
+
+        self._workspace = 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 = []
+
+    @property
+    def workspace(self) -> "Workspace":
+        """The workspace this data archive belongs to."""
+
+        if self._workspace is None and self._workspace_id:
+            self._workspace = self._connection.workspaces.get(uid=self._workspace_id)
+
+        return self._workspace
+
+    @property
+    def orchestration_system(self) -> "OrchestrationSystem":
+        """The orchestration system that manages this data archive."""
+
+        if self._orchestration_system is None and self._orchestration_system_id:
+            self._orchestration_system = self._connection.orchestration_systems.get(
+                uid=self._orchestration_system_id
+            )
+
+        return self._orchestration_system
+
+    @property
+    def datastreams(self) -> List["Datastream"]:
+        """The datastreams this data archive provides data for."""
+
+        return self._datastreams
+
+    def refresh(self):
+        """Refresh this data archive from HydroServer."""
+
+        super()._refresh()
+        self._workspace = None
+
+    def save(self):
+        """Save changes to this data archive to HydroServer."""
+
+        super()._save()
+
+    def delete(self):
+        """Delete this data archive from HydroServer."""
+
+        super()._delete()
+
+    def add_datastream(self, datastream: Union["Datastream", UUID, str]):
+        """Add a datastream to this data archive."""
+
+        self._connection.dataarchives.add_datastream(
+            uid=self.uid, datastream=datastream
+        )
+
+    def remove_datastream(self, datastream: Union["Datastream", UUID, str]):
+        """Remove a datastream from this data archive."""
+
+        self._connection.dataarchives.remove_datastream(
+            uid=self.uid, datastream=datastream
+        )

hydroserverpy/api/models/etl/data_source.py

@@ -0,0 +1,150 @@
+import tempfile
+from typing import Union, List, Optional, TYPE_CHECKING
+from uuid import UUID
+from pydantic import BaseModel, Field
+from urllib.request import urlopen
+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
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class DataSourceFields(BaseModel):
+    name: str = Field(..., max_length=255)
+    settings: Optional[dict] = None
+
+
+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"]
+        )
+
+        self._workspace = 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 = []
+
+    @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)
+
+        return self._workspace
+
+    @property
+    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
+            )
+
+        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
+
+        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]):
+        """Add a datastream to this data source."""
+
+        self._connection.datasources.add_datastream(uid=self.uid, datastream=datastream)
+
+    def remove_datastream(self, datastream: Union["Datastream", UUID, str]):
+        """Remove a datastream from this data source."""
+
+        self._connection.datasources.remove_datastream(
+            uid=self.uid, datastream=datastream
+        )
+
+    # TODO: Replace with ETL module.
+    def load_data(self):
+        """Load data for this data source."""
+
+        if self.paused is True:
+            return
+
+        if self.settings["extractor"]["type"] == "local":
+            with open(self.settings["extractor"]["path"]) as data_file:
+                loader = HydroServerETLCSV(
+                    self._connection, data_file=data_file, data_source=self
+                )
+                loader.run()
+        elif self.settings["extractor"]["type"] == "HTTP":
+            with tempfile.NamedTemporaryFile(mode="w") as temp_file:
+                with urlopen(self.settings["extractor"]["urlTemplate"]) as response:
+                    chunk_size = 1024 * 1024 * 10  # Use a 10mb chunk size.
+                    while True:
+                        chunk = response.read(chunk_size)
+                        if not chunk:
+                            break
+                        temp_file.write(chunk)
+                temp_file.seek(0)
+                loader = HydroServerETLCSV(
+                    self._connection, data_file=temp_file, data_source=self
+                )
+                loader.run()

hydroserverpy/api/models/etl/orchestration_configuration.py

@@ -0,0 +1,35 @@
+from pydantic import AliasPath
+from typing import Optional, Literal
+from datetime import datetime
+from pydantic import BaseModel, Field
+
+
+class OrchestrationConfigurationFields(BaseModel):
+    interval: Optional[int] = Field(
+        None, gt=0, validation_alias=AliasPath("schedule", "interval")
+    )
+    interval_units: Optional[Literal["minutes", "hours", "days"]] = Field(
+        None, validation_alias=AliasPath("schedule", "intervalUnits")
+    )
+    crontab: Optional[str] = Field(
+        None, max_length=255, validation_alias=AliasPath("schedule", "crontab")
+    )
+    start_time: Optional[datetime] = Field(
+        None, validation_alias=AliasPath("schedule", "startTime")
+    )
+    end_time: Optional[datetime] = Field(
+        None, validation_alias=AliasPath("schedule", "endTime")
+    )
+    last_run_successful: Optional[bool] = Field(
+        None, validation_alias=AliasPath("status", "lastRunSuccessful")
+    )
+    last_run_message: Optional[str] = Field(
+        None, max_length=255, validation_alias=AliasPath("status", "lastRunMessage")
+    )
+    last_run: Optional[datetime] = Field(
+        None, validation_alias=AliasPath("status", "lastRun")
+    )
+    next_run: Optional[datetime] = Field(
+        None, validation_alias=AliasPath("status", "nextRun")
+    )
+    paused: bool = Field(False, validation_alias=AliasPath("status", "paused"))

hydroserverpy/api/models/etl/orchestration_system.py

@@ -0,0 +1,78 @@
+from typing import Union, List, TYPE_CHECKING
+from uuid import UUID
+from pydantic import BaseModel, Field
+from ..base import HydroServerModel
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace, DataSource, DataArchive
+
+
+class OrchestrationSystemFields(BaseModel):
+    name: str = Field(..., max_length=255)
+    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
+        )
+
+        self._workspace_id = str(data.get("workspace_id") or data["workspaceId"])
+
+        self._workspace = None
+        self._datasources = None
+        self._dataarchives = None
+
+    @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)
+
+        return self._workspace
+
+    @property
+    def datasources(self) -> List["DataSource"]:
+        """The data sources associated with this workspace."""
+
+        if self._datasources is None:
+            self._datasources = self._connection.datasources.list(
+                orchestration_system=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(
+                orchestration_system=self.uid
+            )
+
+        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/workspace.py

@@ -16,6 +16,9 @@ if TYPE_CHECKING:
         ProcessingLevel,
         ResultQualifier,
         Datastream,
+        OrchestrationSystem,
+        DataSource,
+        DataArchive,
     )
 
 
@@ -41,6 +44,9 @@ class Workspace(HydroServerModel, WorkspaceFields):
         self._units = None
         self._sensors = None
         self._datastreams = None
+        self._orchestrationsystems = None
+        self._datasources = None
+        self._dataarchives = None
 
     @property
     def roles(self) -> List["Role"]:
@@ -131,6 +137,35 @@ class Workspace(HydroServerModel, WorkspaceFields):
 
         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."""
 

hydroserverpy/api/models/sta/datastream.py

@@ -263,7 +263,9 @@ class Datastream(HydroServerModel, DatastreamFields):
         """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._processing_level = self._connection.processinglevels.get(
+                uid=self._processing_level_id
+            )
             self._original_data["processing_level"] = self._processing_level
 
         return self._processing_level

hydroserverpy/api/services/__init__.py

@@ -6,3 +6,6 @@ from .sta.processing_level import ProcessingLevelService
 from .sta.result_qualifier import ResultQualifierService
 from .sta.sensor import SensorService
 from .sta.datastream import DatastreamService
+from .etl.orchestration_system import OrchestrationSystemService
+from .etl.data_source import DataSourceService
+from .etl.data_archive import DataArchiveService

hydroserverpy/api/services/base.py

@@ -1,4 +1,5 @@
 from typing import TYPE_CHECKING, Type, Union, Optional
+from datetime import datetime
 from uuid import UUID
 
 if TYPE_CHECKING:
@@ -38,7 +39,7 @@ class EndpointService:
         path = f"/{self._api_route}/{self._endpoint_route}"
         headers = {"Content-type": "application/json"}
         response = self._connection.request(
-            "post", path, headers=headers, json=kwargs
+            "post", path, headers=headers, json=self._to_iso_time(kwargs)
         ).json()
 
         return self._model(
@@ -49,7 +50,7 @@ class EndpointService:
         path = f"/{self._api_route}/{self._endpoint_route}/{str(uid)}"
         headers = {"Content-type": "application/json"}
         response = self._connection.request(
-            "patch", path, headers=headers, json=kwargs
+            "patch", path, headers=headers, json=self._to_iso_time(kwargs)
         ).json()
 
         return self._model(
@@ -62,6 +63,15 @@ class EndpointService:
 
         return response
 
+    def _to_iso_time(self, obj):
+        if isinstance(obj, dict):
+            return {k: self._to_iso_time(v) for k, v in obj.items()}
+        elif isinstance(obj, list):
+            return [self._to_iso_time(i) for i in obj]
+        elif isinstance(obj, datetime):
+            return obj.isoformat()
+        return obj
+
 
 class SensorThingsService(EndpointService):
     _sta_route: str

hydroserverpy/api/services/etl/data_archive.py

@@ -0,0 +1,196 @@
+from datetime import datetime
+from typing import Optional, Literal, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import EndpointService
+from hydroserverpy.api.models import DataArchive, Datastream
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace, OrchestrationSystem
+
+
+class DataArchiveService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = DataArchive
+        self._api_route = "api/data"
+        self._endpoint_route = "data-archives"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        orchestration_system: Optional[Union["OrchestrationSystem", UUID, str]] = None,
+    ) -> List["DataArchive"]:
+        """Fetch a collection of data archives."""
+
+        params = {}
+
+        workspace_id = getattr(workspace, "uid", workspace)
+        workspace_id = str(workspace_id) if workspace_id else None
+
+        orchestration_system_id = getattr(
+            orchestration_system, "uid", orchestration_system
+        )
+        orchestration_system_id = (
+            str(orchestration_system_id) if orchestration_system_id else None
+        )
+
+        if workspace_id:
+            params["workspace_id"] = workspace_id
+
+        if orchestration_system_id:
+            params["orchestration_system_id"] = orchestration_system_id
+
+        return super()._list(
+            params=params,
+        )
+
+    def get(self, uid: Union[UUID, str]) -> "DataArchive":
+        """Get a data archive by ID."""
+
+        return super()._get(uid=str(uid))
+
+    def create(
+        self,
+        name: str,
+        workspace: Union["Workspace", UUID, str],
+        orchestration_system: Union["OrchestrationSystem", UUID, str],
+        settings: Optional[dict] = None,
+        interval: Optional[int] = None,
+        interval_units: Optional[Literal["minutes", "hours", "days"]] = None,
+        crontab: Optional[str] = None,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        last_run_successful: Optional[bool] = None,
+        last_run_message: Optional[str] = None,
+        last_run: Optional[datetime] = None,
+        next_run: Optional[datetime] = None,
+        paused: bool = False,
+        datastreams: Optional[List[Union["Datastream", UUID, str]]] = None,
+    ) -> "DataArchive":
+        """Create a new data archive."""
+
+        kwargs = {
+            "name": name,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+            "orchestrationSystemId": getattr(
+                orchestration_system, "uid", orchestration_system
+            ),
+            "settings": settings,
+            "schedule": {
+                "interval": interval,
+                "intervalUnits": interval_units,
+                "crontab": crontab,
+                "startTime": start_time,
+                "endTime": end_time,
+            },
+            "status": {
+                "lastRunSuccessful": last_run_successful,
+                "lastRunMessage": last_run_message,
+                "lastRun": last_run,
+                "nextRun": next_run,
+                "paused": paused,
+            },
+            "datastreamIds": (
+                [
+                    str(getattr(datastream, "uid", datastream))
+                    for datastream in datastreams
+                ]
+                if datastreams
+                else []
+            ),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        orchestration_system: Union["OrchestrationSystem", UUID, str] = ...,
+        settings: Optional[dict] = ...,
+        interval: Optional[int] = ...,
+        interval_units: Optional[Literal["minutes", "hours", "days"]] = ...,
+        crontab: Optional[str] = ...,
+        start_time: Optional[datetime] = ...,
+        end_time: Optional[datetime] = ...,
+        last_run_successful: Optional[bool] = ...,
+        last_run_message: Optional[str] = ...,
+        last_run: Optional[datetime] = ...,
+        next_run: Optional[datetime] = ...,
+        paused: bool = ...,
+    ) -> "DataArchive":
+        """Update a data archive."""
+
+        status_kwargs = {
+            k: v
+            for k, v in {
+                "lastRunSuccessful": last_run_successful,
+                "lastRunMessage": last_run_message,
+                "lastRun": last_run,
+                "nextRun": next_run,
+                "paused": paused,
+            }.items()
+            if v is not ...
+        }
+        status_kwargs = status_kwargs if status_kwargs else ...
+
+        schedule_kwargs = {
+            k: v
+            for k, v in {
+                "interval": interval,
+                "intervalUnits": interval_units,
+                "crontab": crontab,
+                "startTime": start_time,
+                "endTime": end_time,
+            }.items()
+            if v is not ...
+        }
+        schedule_kwargs = schedule_kwargs if schedule_kwargs else ...
+
+        kwargs = {
+            k: v
+            for k, v in {
+                "name": name,
+                "orchestrationSystemId": getattr(
+                    orchestration_system, "uid", orchestration_system
+                ),
+                "settings": settings,
+                "schedule": schedule_kwargs,
+                "status": status_kwargs,
+            }.items()
+            if v is not ...
+        }
+
+        return super()._update(uid=str(uid), **kwargs)
+
+    def delete(self, uid: Union[UUID, str]) -> None:
+        """Delete a data archive."""
+
+        super()._delete(uid=str(uid))
+
+    def add_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Add a datastream to this data archive."""
+
+        datastream_id = str(getattr(datastream, "uid", datastream))
+
+        self._connection.request(
+            "post",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
+        )
+
+    def remove_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Remove a datastream from this data archive."""
+
+        datastream_id = str(getattr(datastream, "uid", datastream))
+
+        self._connection.request(
+            "delete",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
+        )

hydroserverpy/api/services/etl/data_source.py

@@ -0,0 +1,196 @@
+from datetime import datetime
+from typing import Optional, Literal, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import EndpointService
+from hydroserverpy.api.models import DataSource, Datastream
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace, OrchestrationSystem
+
+
+class DataSourceService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = DataSource
+        self._api_route = "api/data"
+        self._endpoint_route = "data-sources"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        orchestration_system: Optional[Union["OrchestrationSystem", UUID, str]] = None,
+    ) -> List["DataSource"]:
+        """Fetch a collection of data sources."""
+
+        params = {}
+
+        workspace_id = getattr(workspace, "uid", workspace)
+        workspace_id = str(workspace_id) if workspace_id else None
+
+        orchestration_system_id = getattr(
+            orchestration_system, "uid", orchestration_system
+        )
+        orchestration_system_id = (
+            str(orchestration_system_id) if orchestration_system_id else None
+        )
+
+        if workspace_id:
+            params["workspace_id"] = workspace_id
+
+        if orchestration_system_id:
+            params["orchestration_system_id"] = orchestration_system_id
+
+        return super()._list(
+            params=params,
+        )
+
+    def get(self, uid: Union[UUID, str]) -> "DataSource":
+        """Get a data source by ID."""
+
+        return super()._get(uid=str(uid))
+
+    def create(
+        self,
+        name: str,
+        workspace: Union["Workspace", UUID, str],
+        orchestration_system: Union["OrchestrationSystem", UUID, str],
+        settings: Optional[dict] = None,
+        interval: Optional[int] = None,
+        interval_units: Optional[Literal["minutes", "hours", "days"]] = None,
+        crontab: Optional[str] = None,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
+        last_run_successful: Optional[bool] = None,
+        last_run_message: Optional[str] = None,
+        last_run: Optional[datetime] = None,
+        next_run: Optional[datetime] = None,
+        paused: bool = False,
+        datastreams: Optional[List[Union["Datastream", UUID, str]]] = None,
+    ) -> "DataSource":
+        """Create a new data source."""
+
+        kwargs = {
+            "name": name,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+            "orchestrationSystemId": getattr(
+                orchestration_system, "uid", orchestration_system
+            ),
+            "settings": settings,
+            "schedule": {
+                "interval": interval,
+                "intervalUnits": interval_units,
+                "crontab": crontab,
+                "startTime": start_time,
+                "endTime": end_time,
+            },
+            "status": {
+                "lastRunSuccessful": last_run_successful,
+                "lastRunMessage": last_run_message,
+                "lastRun": last_run,
+                "nextRun": next_run,
+                "paused": paused,
+            },
+            "datastreamIds": (
+                [
+                    str(getattr(datastream, "uid", datastream))
+                    for datastream in datastreams
+                ]
+                if datastreams
+                else []
+            ),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        orchestration_system: Union["OrchestrationSystem", UUID, str] = ...,
+        settings: Optional[dict] = ...,
+        interval: Optional[int] = ...,
+        interval_units: Optional[Literal["minutes", "hours", "days"]] = ...,
+        crontab: Optional[str] = ...,
+        start_time: Optional[datetime] = ...,
+        end_time: Optional[datetime] = ...,
+        last_run_successful: Optional[bool] = ...,
+        last_run_message: Optional[str] = ...,
+        last_run: Optional[datetime] = ...,
+        next_run: Optional[datetime] = ...,
+        paused: bool = ...,
+    ) -> "DataSource":
+        """Update a data source."""
+
+        status_kwargs = {
+            k: v
+            for k, v in {
+                "lastRunSuccessful": last_run_successful,
+                "lastRunMessage": last_run_message,
+                "lastRun": last_run,
+                "nextRun": next_run,
+                "paused": paused,
+            }.items()
+            if v is not ...
+        }
+        status_kwargs = status_kwargs if status_kwargs else ...
+
+        schedule_kwargs = {
+            k: v
+            for k, v in {
+                "interval": interval,
+                "intervalUnits": interval_units,
+                "crontab": crontab,
+                "startTime": start_time,
+                "endTime": end_time,
+            }.items()
+            if v is not ...
+        }
+        schedule_kwargs = schedule_kwargs if schedule_kwargs else ...
+
+        kwargs = {
+            k: v
+            for k, v in {
+                "name": name,
+                "orchestrationSystemId": getattr(
+                    orchestration_system, "uid", orchestration_system
+                ),
+                "settings": settings,
+                "schedule": schedule_kwargs,
+                "status": status_kwargs,
+            }.items()
+            if v is not ...
+        }
+
+        return super()._update(uid=str(uid), **kwargs)
+
+    def delete(self, uid: Union[UUID, str]) -> None:
+        """Delete a data source."""
+
+        super()._delete(uid=str(uid))
+
+    def add_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Add a datastream to this data source."""
+
+        datastream_id = str(getattr(datastream, "uid", datastream))
+
+        self._connection.request(
+            "post",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
+        )
+
+    def remove_datastream(
+        self, uid: Union[UUID, str], datastream: Union["Datastream", UUID, str]
+    ) -> None:
+        """Remove a datastream from this data source."""
+
+        datastream_id = str(getattr(datastream, "uid", datastream))
+
+        self._connection.request(
+            "delete",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/datastreams/{datastream_id}",
+        )

hydroserverpy/api/services/etl/orchestration_system.py

@@ -0,0 +1,74 @@
+from typing import Optional, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import EndpointService
+from hydroserverpy.api.models import OrchestrationSystem
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class OrchestrationSystemService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = OrchestrationSystem
+        self._api_route = "api/data"
+        self._endpoint_route = "orchestration-systems"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+    ) -> List["OrchestrationSystem"]:
+        """Fetch a collection of orchestration systems."""
+
+        workspace_id = getattr(workspace, "uid", workspace)
+        workspace_id = str(workspace_id) if workspace_id else None
+
+        return super()._list(
+            params={"workspace_id": workspace_id} if workspace_id else {},
+        )
+
+    def get(self, uid: Union[UUID, str]) -> "OrchestrationSystem":
+        """Get an orchestration system by ID."""
+
+        return super()._get(uid=str(uid))
+
+    def create(
+        self,
+        workspace: Union["Workspace", UUID, str],
+        name: str,
+        orchestration_system_type: str,
+    ) -> "OrchestrationSystem":
+        """Create a new orchestration system."""
+
+        kwargs = {
+            "name": name,
+            "type": orchestration_system_type,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        orchestration_system_type: str = ...,
+    ) -> "OrchestrationSystem":
+        """Update an orchestration system."""
+
+        kwargs = {
+            "name": name,
+            "type": orchestration_system_type,
+        }
+
+        return super()._update(
+            uid=str(uid), **{k: v for k, v in kwargs.items() if v is not ...}
+        )
+
+    def delete(self, uid: Union[UUID, str]) -> None:
+        """Delete an orchestration system."""
+
+        super()._delete(uid=str(uid))

hydroserverpy/api/services/sta/observed_property.py

@@ -35,7 +35,9 @@ class ObservedPropertyService(SensorThingsService):
 
         return super()._list(params=params)
 
-    def get(self, uid: Union[UUID, str], fetch_by_datastream_uid: bool = False) -> "ObservedProperty":
+    def get(
+        self, uid: Union[UUID, str], fetch_by_datastream_uid: bool = False
+    ) -> "ObservedProperty":
         """Get an observed property by ID."""
 
         return self._get(

hydroserverpy/etl_csv/hydroserver_etl_csv.py

@@ -10,7 +10,7 @@ from .exceptions import HeaderParsingError, TimestampParsingError
 import warnings
 
 if TYPE_CHECKING:
-    from hydroserverpy_old.core.schemas import DataSource
+    from hydroserverpy.api.models import DataSource
 
 logger = logging.getLogger("hydroserver_etl")
 logger.addHandler(logging.NullHandler())
@@ -36,10 +36,15 @@ class HydroServerETLCSV:
             datastream.uid: datastream for datastream in data_source.datastreams
         }
 
+        self._datastream_mapping = {
+            mapping["targetIdentifier"]: mapping["sourceIdentifier"]
+            for payload in self._data_source.settings["payloads"]
+            for mapping in payload.get("mappings", [])
+        }
+
         self._timestamp_column_index = None
         self._datastream_column_indexes = None
         self._datastream_start_row_indexes = {}
-        self._last_loaded_timestamp = self._data_source.data_source_thru
 
         self._message = None
         self._failed_datastreams = []
@@ -59,7 +64,10 @@ class HydroServerETLCSV:
         :return: None
         """
 
-        data_reader = csv.reader(self._data_file, delimiter=self._data_source.delimiter)
+        data_reader = csv.reader(
+            self._data_file,
+            delimiter=self._data_source.settings["transformer"]["delimiter"],
+        )
 
         try:
             for i, row in enumerate(data_reader):
@@ -104,13 +112,13 @@ class HydroServerETLCSV:
         :return: A list of datetime and value pairs for each datastream
         """
 
-        if index == self._data_source.header_row or (
-            index == self._data_source.data_start_row
+        if index == self._data_source.settings["transformer"]["headerRow"] or (
+            index == self._data_source.settings["transformer"]["dataStartRow"]
             and self._timestamp_column_index is None
         ):
             self._parse_file_header(row)
 
-        if index < self._data_source.data_start_row:
+        if index < self._data_source.settings["transformer"]["dataStartRow"]:
             return
 
         timestamp = self._parse_row_timestamp(row)
@@ -135,7 +143,7 @@ class HydroServerETLCSV:
                         "phenomenon_time": timestamp,
                         "result": row[
                             self._datastream_column_indexes[
-                                datastream.data_source_column
+                                self._datastream_mapping[str(datastream.uid)]
                             ]
                         ],
                     }
@@ -155,17 +163,19 @@ class HydroServerETLCSV:
 
         try:
             self._timestamp_column_index = (
-                row.index(self._data_source.timestamp_column)
-                if isinstance(self._data_source.timestamp_column, str)
-                else int(self._data_source.timestamp_column) - 1
+                row.index(self._data_source.settings["transformer"]["timestampKey"])
+                if isinstance(
+                    self._data_source.settings["transformer"]["timestampKey"], str
+                )
+                else int(self._data_source.settings["transformer"]["timestampKey"]) - 1
             )
             if self._timestamp_column_index > len(row):
                 raise ValueError
             self._datastream_column_indexes = {
-                datastream.data_source_column: (
-                    row.index(datastream.data_source_column)
-                    if not datastream.data_source_column.isdigit()
-                    else int(datastream.data_source_column) - 1
+                self._datastream_mapping[str(datastream.uid)]: (
+                    row.index(self._datastream_mapping[str(datastream.uid)])
+                    if not self._datastream_mapping[str(datastream.uid)].isdigit()
+                    else int(self._datastream_mapping[str(datastream.uid)]) - 1
                 )
                 for datastream in self._datastreams.values()
             }
@@ -190,28 +200,39 @@ class HydroServerETLCSV:
 
         try:
             if (
-                self._data_source.timestamp_format == "iso"
-                or self._data_source.timestamp_format is None
+                self._data_source.settings["transformer"].get("timestampFormat") in ["utc", "constant", "ISO8601"]
+                or self._data_source.settings["transformer"].get("timestampFormat")
+                is None
             ):
                 timestamp = isoparse(row[self._timestamp_column_index])
             else:
                 timestamp = datetime.strptime(
                     row[self._timestamp_column_index],
-                    self._data_source.timestamp_format,
+                    self._data_source.settings["transformer"].get("timestampFormat"),
                 )
         except ValueError as e:
             raise TimestampParsingError(str(e)) from e
 
         if timestamp.tzinfo is None:
-            if not self._data_source.timestamp_offset:
+            if not self._data_source.settings["transformer"].get(
+                "timestampOffset"
+            ) or self._data_source.settings["transformer"].get(
+                "timestampOffset"
+            ).endswith(
+                "0000"
+            ):
                 timestamp = timestamp.replace(tzinfo=timezone.utc)
             else:
                 try:
                     timestamp = timestamp.replace(
                         tzinfo=datetime.strptime(
-                            self._data_source.timestamp_offset[:-2]
+                            self._data_source.settings["transformer"].get(
+                                "timestampOffset"
+                            )[:-2]
                             + ":"
-                            + self._data_source.timestamp_offset[3:],
+                            + self._data_source.settings["transformer"].get(
+                                "timestampOffset"
+                            )[3:],
                             "%z",
                         ).tzinfo
                     )
@@ -264,12 +285,6 @@ class HydroServerETLCSV:
                 except HTTPError:
                     failed_datastreams.append(datastream_id)
 
-                if not self._last_loaded_timestamp or (
-                    observations[-1]["phenomenon_time"]
-                    and observations[-1]["phenomenon_time"]
-                    > self._last_loaded_timestamp
-                ):
-                    self._last_loaded_timestamp = observations[-1]["phenomenon_time"]
             elif datastream_id in self._failed_datastreams:
                 logger.info(
                     f"Skipping observations POST request from "
@@ -292,29 +307,28 @@ class HydroServerETLCSV:
         """
 
         if self._data_source.crontab is not None:
-            next_sync = croniter.croniter(
+            next_run = croniter.croniter(
                 self._data_source.crontab, datetime.now()
             ).get_next(datetime)
         elif (
             self._data_source.interval is not None
             and self._data_source.interval_units is not None
         ):
-            next_sync = datetime.now() + timedelta(
+            next_run = datetime.now() + timedelta(
                 **{self._data_source.interval_units: self._data_source.interval}
             )
         else:
-            next_sync = None
+            next_run = None
 
-        self._data_source.data_source_thru = self._last_loaded_timestamp
-        self._data_source.last_sync_successful = (
+        self._data_source.last_run_successful = (
             True
             if not self._file_timestamp_error
             and not self._file_header_error
             and len(self._failed_datastreams) == 0
             else False
         )
-        self._data_source.last_sync_message = self._message
-        self._data_source.last_synced = datetime.now(timezone.utc)
-        self._data_source.next_sync = next_sync
+        self._data_source.last_run_message = self._message
+        self._data_source.last_run = datetime.now(timezone.utc)
+        self._data_source.next_run = next_run
 
         self._data_source.save()

{hydroserverpy-0.5.0b1.dist-info → hydroserverpy-0.5.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hydroserverpy
-Version: 0.5.0b1
+Version: 0.5.0b3
 Requires-Python: <4,>=3.9
 License-File: LICENSE
 Requires-Dist: requests>=2

{hydroserverpy-0.5.0b1.dist-info → hydroserverpy-0.5.0b3.dist-info}/RECORD

@@ -1,31 +1,38 @@
 hydroserverpy/__init__.py,sha256=FgaGFyhCjwmpJYEKNzOZxvfRx2neWMaOybj1z02_VSE,218
 hydroserverpy/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydroserverpy/api/http.py,sha256=be2L_0t9RtpjRlS4YYlJ0T09wyvUYw2-fg5eXBQwNXA,632
-hydroserverpy/api/main.py,sha256=2IVNMsf5h1UWfDZSxJn1wewOmN2D2kIMq7iqwiBqCNY,4216
-hydroserverpy/api/models/__init__.py,sha256=YwO9ixElkQp3Nwi6gb0XPj4H32aNmUOFm0oXc20E_F8,550
+hydroserverpy/api/http.py,sha256=C5DgvEeiu54RaL-9oouFPSKosC8Uy5Qdwm5hYh2Ps-s,620
+hydroserverpy/api/main.py,sha256=OWJpCIuheBgWQA7R33BiG89-upMS-a3K_AScbVeVjxQ,4760
+hydroserverpy/api/models/__init__.py,sha256=ELrf3b7Aix7YcVF__Q_8e_G_FF8GYlX0J5l7fkGcHnY,690
 hydroserverpy/api/models/base.py,sha256=dc2tfMSgizymxAAOVURfy7Jzeh6xIiiq7hfWZI7l1_Q,2280
 hydroserverpy/api/models/etl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/api/models/etl/data_archive.py,sha256=u-gpvUsaWaw0kyF3bPMm2e55Jx2yhvSV9ufXXaNtrTc,3429
+hydroserverpy/api/models/etl/data_source.py,sha256=ca-9KKVhkLNaUn3vOIk-JgdWk58fTRme8YKIesk8WIw,5455
+hydroserverpy/api/models/etl/orchestration_configuration.py,sha256=ElSrgi7ioFZJFJg6aGogW5ZZk7fA17y4p--yWwiOhZ0,1367
+hydroserverpy/api/models/etl/orchestration_system.py,sha256=25En2G0z1gQzN-RW3UlrEGgkC952QDW21oYnawCX8hY,2357
 hydroserverpy/api/models/iam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hydroserverpy/api/models/iam/account.py,sha256=7COk_CPYFlthg1uFWTBlJESfnuqMW90TSjZoIcBb-_8,439
 hydroserverpy/api/models/iam/collaborator.py,sha256=jp661DKDCwk8c8HFPAV-YVhEc80F5eGDKaSHmH62Q8Q,1007
 hydroserverpy/api/models/iam/role.py,sha256=8FVTj_1QwtPF9tk7baliMVg000kjc5N8oP6eYo8vTDY,275
-hydroserverpy/api/models/iam/workspace.py,sha256=IonbIWMGAuxPVum0i0kEy0EJq7l79eH40-2P_SZAJHs,6194
+hydroserverpy/api/models/iam/workspace.py,sha256=s9u1oZyOdxM7txjJARFcIBrWMHQSDxODdreiatFsXJs,7331
 hydroserverpy/api/models/sta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-hydroserverpy/api/models/sta/datastream.py,sha256=SfBixRPsR0j6g1hNnjg0fzlCK4AfQxo8voXVyU0tS-o,10744
+hydroserverpy/api/models/sta/datastream.py,sha256=sB-KifvegbyDUnyPE_NCHFrab1ZSVVb6g-Gs7kUgMiE,10774
 hydroserverpy/api/models/sta/observed_property.py,sha256=ThTg8aPMHPxbk9Hzpxw3AwM16gE1xvYpRK8UkiOdGeA,2180
 hydroserverpy/api/models/sta/processing_level.py,sha256=y5_0wX7QGXgswvukXJtbpOiTCZ9pI8E08DXaTSUHakg,1470
 hydroserverpy/api/models/sta/result_qualifier.py,sha256=IJcY04KjP9e2D-jPzUJjH2PC-JvDNCjbi5LKkTVSwgw,1416
 hydroserverpy/api/models/sta/sensor.py,sha256=TD9R1Uwcu1t9tRQBfk0crsSJmV5UN_9kH9Ye9b7lDJc,3055
 hydroserverpy/api/models/sta/thing.py,sha256=o4Xn_Luy2IEOCBjXTbek7GvPoXZyKA0dhfzoFM6nfTs,6357
 hydroserverpy/api/models/sta/unit.py,sha256=Pbxxp9hZErsrYImIb8-1HVnZAsJopE3US_AplSQWOJQ,1398
-hydroserverpy/api/services/__init__.py,sha256=PhqbFlKfZ8a3WJidJUwa0gJ3OADcivepEEqfbQXb1dc,371
-hydroserverpy/api/services/base.py,sha256=Y2aJDMcVR7qxTgZQh1s8UYyRsoogjDY6TkCxvV9jfxA,3025
+hydroserverpy/api/services/__init__.py,sha256=B0kGyn8_HlIBf9deU6qLocQTbxe59qestUZtLU9CeXk,532
+hydroserverpy/api/services/base.py,sha256=zLhRDlf4h4zBXHpicKMI7xgQrXN_wHvvthvQzYNyj2E,3415
 hydroserverpy/api/services/etl/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/api/services/etl/data_archive.py,sha256=hlNJOHJSZ1kV2n2xivWIBtT1Eovj65PDbwpAyXnlZsM,6506
+hydroserverpy/api/services/etl/data_source.py,sha256=DCgTyh8lF2iwh4uszePFg9UupXxJCN7Ww9Ut1MQKHis,6491
+hydroserverpy/api/services/etl/orchestration_system.py,sha256=JFuSJJUq4JJUt8KlZ-Ga0ktyQIe2U0Sa7ogd4oLjex4,2166
 hydroserverpy/api/services/iam/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hydroserverpy/api/services/iam/workspace.py,sha256=jJiqkMxFEp9REjR4LXyVp2o45CGBrrEadGelPPCuRJs,4547
 hydroserverpy/api/services/sta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hydroserverpy/api/services/sta/datastream.py,sha256=_m-xFom3z8wo5-1_q8NjWUpcw36wYv1brIG7xeGGadk,12402
-hydroserverpy/api/services/sta/observed_property.py,sha256=7V2PjsQqEGPEWk1n_o3MS0UM_tKQdTCEjDYM2XKMk0I,2894
+hydroserverpy/api/services/sta/observed_property.py,sha256=nRlqBldJpXlj8VOZ4EwNOs4ZgmBw5w-EqAChfM3Z0Z0,2908
 hydroserverpy/api/services/sta/processing_level.py,sha256=Oupfeww2XgT83AwR5Spt91VjZK6MG0XIl11Et9fRjA0,2255
 hydroserverpy/api/services/sta/result_qualifier.py,sha256=XG5Ng3xdFT-l3Ktkuq23Cty1RfmepBO7EQ9gPzidZuA,2069
 hydroserverpy/api/services/sta/sensor.py,sha256=SbDhLjlOaM2ypLDfXmQVinj7eHHJ_fHxjTD68dM2pQI,3473
@@ -48,12 +55,12 @@ hydroserverpy/etl/transformers/csv_transformer.py,sha256=9DKSO4NfUUDlr_c6UnH4AU3
 hydroserverpy/etl/transformers/json_transformer.py,sha256=ity0MXcYjEnlun4Y6cVSrnjrglKrK4JOXXHxWHIHN2A,2323
 hydroserverpy/etl_csv/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 hydroserverpy/etl_csv/exceptions.py,sha256=0UY8YUlNepG0y6FfH36hJyR1bOhwYHSZIdUSSMTg7GA,314
-hydroserverpy/etl_csv/hydroserver_etl_csv.py,sha256=lpZmlh4BAsljLLCEj4UiDtty3m28MJbnSiOE71gDrCQ,13260
+hydroserverpy/etl_csv/hydroserver_etl_csv.py,sha256=y7AI6MjrcM9Dh-Id7G77dLzogZ7CSO4JhFR-AirMnJA,13854
 hydroserverpy/quality/__init__.py,sha256=GGBMkFSXciJLYrbV-NraFrj_mXWCy_GTcy9KKrKXU4c,84
 hydroserverpy/quality/service.py,sha256=U02UfLKVmFvr5ySiH0n0JYzUIabq5uprrHIiwcqBlqY,13879
-hydroserverpy-0.5.0b1.dist-info/licenses/LICENSE,sha256=xVqFxDw3QOEJukakL7gQCqIMTQ1dlSCTo6Oc1otNW80,1508
-hydroserverpy-0.5.0b1.dist-info/METADATA,sha256=ZhKOorHNQG_J18X3L2HnUqBp5gFZBx8QuwwlmPpc0FM,532
-hydroserverpy-0.5.0b1.dist-info/WHEEL,sha256=L0N565qmK-3nM2eBoMNFszYJ_MTx03_tQ0CQu1bHLYo,91
-hydroserverpy-0.5.0b1.dist-info/top_level.txt,sha256=Zf37hrncXLOYvXhgCrf5mZdeq81G9fShdE2LfYbtb7w,14
-hydroserverpy-0.5.0b1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-hydroserverpy-0.5.0b1.dist-info/RECORD,,
+hydroserverpy-0.5.0b3.dist-info/licenses/LICENSE,sha256=xVqFxDw3QOEJukakL7gQCqIMTQ1dlSCTo6Oc1otNW80,1508
+hydroserverpy-0.5.0b3.dist-info/METADATA,sha256=O1XE90QxIZLWaNymaUyCubt3NyuqJ--m-b7vuzHQ9H8,532
+hydroserverpy-0.5.0b3.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
+hydroserverpy-0.5.0b3.dist-info/top_level.txt,sha256=Zf37hrncXLOYvXhgCrf5mZdeq81G9fShdE2LfYbtb7w,14
+hydroserverpy-0.5.0b3.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+hydroserverpy-0.5.0b3.dist-info/RECORD,,

{hydroserverpy-0.5.0b1.dist-info → hydroserverpy-0.5.0b3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.0.1)
+Generator: setuptools (78.1.1)
 Root-Is-Purelib: true
 Tag: py3-none-any