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

hydroserverpy/api/services/sta/sensor.py

@@ -0,0 +1,116 @@
+from typing import Optional, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import SensorThingsService
+from hydroserverpy.api.models import Sensor
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class SensorService(SensorThingsService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = Sensor
+        self._api_route = "api/data"
+        self._endpoint_route = "sensors"
+        self._sta_route = "api/sensorthings/v1.1/Sensors"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        page: int = 1,
+        page_size: int = 100,
+    ) -> List["Sensor"]:
+        """Fetch a collection of sensors."""
+
+        params = {"$top": page_size, "$skip": page_size * (page - 1)}
+
+        if workspace:
+            params["$filter"] = (
+                f"properties/workspace/id eq '{str(getattr(workspace, 'uid', workspace))}'"
+            )
+
+        return super()._list(params=params)
+
+    def get(
+        self, uid: Union[UUID, str], fetch_by_datastream_uid: bool = False
+    ) -> "Sensor":
+        """Get a sensor by ID."""
+
+        return self._get(
+            uid=str(uid),
+            path=(
+                f"api/sensorthings/v1.1/Datastreams('{str(uid)}')/Sensor"
+                if fetch_by_datastream_uid
+                else None
+            ),
+        )
+
+    def create(
+        self,
+        workspace: Union["Workspace", UUID, str],
+        name: str,
+        description: str,
+        encoding_type: str,
+        method_type: str,
+        manufacturer: Optional[str] = None,
+        sensor_model: Optional[str] = None,
+        sensor_model_link: Optional[str] = None,
+        method_link: Optional[str] = None,
+        method_code: Optional[str] = None,
+    ) -> "Sensor":
+        """Create a new sensor."""
+
+        kwargs = {
+            "name": name,
+            "description": description,
+            "encodingType": encoding_type,
+            "methodType": method_type,
+            "manufacturer": manufacturer,
+            "model": sensor_model,
+            "modelLink": sensor_model_link,
+            "methodLink": method_link,
+            "methodCode": method_code,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        description: str = ...,
+        encoding_type: str = ...,
+        method_type: str = ...,
+        manufacturer: Optional[str] = ...,
+        sensor_model: Optional[str] = ...,
+        sensor_model_link: Optional[str] = ...,
+        method_link: Optional[str] = ...,
+        method_code: Optional[str] = ...,
+    ) -> "Sensor":
+        """Update a sensor."""
+
+        kwargs = {
+            "name": name,
+            "description": description,
+            "encodingType": encoding_type,
+            "methodType": method_type,
+            "manufacturer": manufacturer,
+            "model": sensor_model,
+            "modelLink": sensor_model_link,
+            "methodLink": method_link,
+            "methodCode": method_code,
+        }
+
+        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 a sensor."""
+
+        super()._delete(uid=str(uid))

hydroserverpy/api/services/sta/thing.py

@@ -0,0 +1,188 @@
+import json
+from typing import TYPE_CHECKING, Union, IO, List, Dict, Optional
+from uuid import UUID
+from ..base import SensorThingsService
+from hydroserverpy.api.models import Thing
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class ThingService(SensorThingsService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = Thing
+        self._api_route = "api/data"
+        self._endpoint_route = "things"
+        self._sta_route = "api/sensorthings/v1.1/Things"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+        page: int = 1,
+        page_size: int = 100,
+    ) -> List["Thing"]:
+        """Fetch a collection of things."""
+
+        params = {
+            "$top": page_size,
+            "$skip": page_size * (page - 1),
+            "$expand": "Locations",
+        }
+
+        if workspace:
+            params["$filter"] = (
+                f"properties/workspace/id eq '{str(getattr(workspace, 'uid', workspace))}'"
+            )
+
+        return super()._list(params=params)
+
+    def get(
+        self, uid: Union[UUID, str], fetch_by_datastream_uid: bool = False
+    ) -> "Thing":
+        """Get a thing by ID."""
+
+        params = {"$expand": "Locations"}
+        return self._get(
+            uid=str(uid),
+            path=(
+                f"api/sensorthings/v1.1/Datastreams('{str(uid)}')/Thing"
+                if fetch_by_datastream_uid
+                else None
+            ),
+            params=params,
+        )
+
+    def create(
+        self,
+        workspace: Union["Workspace", UUID, str],
+        name: str,
+        description: str,
+        sampling_feature_type: str,
+        sampling_feature_code: str,
+        site_type: str,
+        is_private: False,
+        latitude: float,
+        longitude: float,
+        elevation_m: Optional[float] = None,
+        elevation_datum: Optional[str] = None,
+        state: Optional[str] = None,
+        county: Optional[str] = None,
+        country: Optional[str] = None,
+        data_disclaimer: Optional[str] = None,
+    ) -> "Thing":
+        """Create a new thing."""
+
+        kwargs = {
+            "name": name,
+            "description": description,
+            "samplingFeatureType": sampling_feature_type,
+            "samplingFeatureCode": sampling_feature_code,
+            "siteType": site_type,
+            "isPrivate": is_private,
+            "latitude": latitude,
+            "longitude": longitude,
+            "elevation_m": elevation_m,
+            "elevationDatum": elevation_datum,
+            "state": state,
+            "county": county,
+            "country": country,
+            "dataDisclaimer": data_disclaimer,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        description: str = ...,
+        sampling_feature_type: str = ...,
+        sampling_feature_code: str = ...,
+        site_type: str = ...,
+        is_private: False = ...,
+        latitude: float = ...,
+        longitude: float = ...,
+        elevation_m: Optional[float] = ...,
+        elevation_datum: Optional[str] = ...,
+        state: Optional[str] = ...,
+        county: Optional[str] = ...,
+        country: Optional[str] = ...,
+        data_disclaimer: Optional[str] = ...,
+    ) -> "Thing":
+        """Update a thing."""
+
+        kwargs = {
+            "name": name,
+            "description": description,
+            "samplingFeatureType": sampling_feature_type,
+            "samplingFeatureCode": sampling_feature_code,
+            "siteType": site_type,
+            "isPrivate": is_private,
+            "latitude": latitude,
+            "longitude": longitude,
+            "elevation_m": elevation_m,
+            "elevationDatum": elevation_datum,
+            "state": state,
+            "county": county,
+            "country": country,
+            "dataDisclaimer": data_disclaimer,
+        }
+
+        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 a thing."""
+
+        super()._delete(uid=str(uid))
+
+    def add_tag(self, uid: Union[UUID, str], key: str, value: str) -> Dict[str, str]:
+        """Tag a HydroServer thing."""
+
+        return self._connection.request(
+            "post",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/tags",
+            data=json.dumps({"key": key, "value": value}),
+        ).json()
+
+    def update_tag(self, uid: Union[UUID, str], key: str, value: str) -> Dict[str, str]:
+        """Update the tag of a HydroServer thing."""
+
+        return self._connection.request(
+            "put",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/tags",
+            data=json.dumps({"key": key, "value": value}),
+        ).json()
+
+    def delete_tag(self, uid: Union[UUID, str], key: str) -> None:
+        """Remove a tag from a HydroServer thing."""
+
+        self._connection.request(
+            "delete",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/tags",
+            data=json.dumps({"key": key}),
+        )
+
+    def add_photo(self, uid: Union[UUID, str], file: IO[bytes]) -> Dict[str, str]:
+        """Add a photo of a HydroServer thing."""
+
+        return self._connection.request(
+            "post",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/photos",
+            files={"file": file},
+        ).json()
+
+    def delete_photo(self, uid: Union[UUID, str], name: str) -> None:
+        """Delete a photo of a HydroServer thing."""
+
+        self._connection.request(
+            "delete",
+            f"{self._api_route}/{self._endpoint_route}/{str(uid)}/photos",
+            data=json.dumps({"name": name}),
+        )

hydroserverpy/api/services/sta/unit.py

@@ -0,0 +1,82 @@
+from typing import Optional, Union, List, TYPE_CHECKING
+from uuid import UUID
+from ..base import EndpointService
+from hydroserverpy.api.models import Unit
+
+
+if TYPE_CHECKING:
+    from hydroserverpy import HydroServer
+    from hydroserverpy.api.models import Workspace
+
+
+class UnitService(EndpointService):
+    def __init__(self, connection: "HydroServer"):
+        self._model = Unit
+        self._api_route = "api/data"
+        self._endpoint_route = "units"
+
+        super().__init__(connection)
+
+    def list(
+        self,
+        workspace: Optional[Union["Workspace", UUID, str]] = None,
+    ) -> List["Unit"]:
+        """Fetch a collection of units."""
+
+        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]) -> "Unit":
+        """Get a unit by ID."""
+
+        return super()._get(uid=str(uid))
+
+    def create(
+        self,
+        workspace: Union["Workspace", UUID, str],
+        name: str,
+        symbol: str,
+        definition: str,
+        unit_type: str,
+    ) -> "Unit":
+        """Create a new unit."""
+
+        kwargs = {
+            "name": name,
+            "symbol": symbol,
+            "definition": definition,
+            "type": unit_type,
+            "workspaceId": str(getattr(workspace, "uid", workspace)),
+        }
+
+        return super()._create(**kwargs)
+
+    def update(
+        self,
+        uid: Union[UUID, str],
+        name: str = ...,
+        symbol: str = ...,
+        definition: str = ...,
+        unit_type: str = ...,
+    ) -> "Unit":
+        """Update a unit."""
+
+        kwargs = {
+            "name": name,
+            "symbol": symbol,
+            "definition": definition,
+            "type": unit_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 a unit."""
+
+        super()._delete(uid=str(uid))

hydroserverpy/etl/loaders/hydroserver_loader.py

@@ -1,4 +1,4 @@
-from hydroserverpy.core.service import HydroServer
+from hydroserverpy import HydroServer
 from typing import Dict, Optional
 from .base import Loader
 import logging

hydroserverpy/etl_csv/hydroserver_etl_csv.py

@@ -10,7 +10,7 @@ from .exceptions import HeaderParsingError, TimestampParsingError
 import warnings
 
 if TYPE_CHECKING:
-    from ..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,40 @@ 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")
+                == "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(
+                                "timestampFormat"
+                            )[:-2]
                             + ":"
-                            + self._data_source.timestamp_offset[3:],
+                            + self._data_source.settings["transformer"].get(
+                                "timestampFormat"
+                            )[3:],
                             "%z",
                         ).tzinfo
                     )
@@ -264,12 +286,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 +308,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.4.0.dist-info → hydroserverpy-0.5.0b2.dist-info}/METADATA

@@ -1,10 +1,11 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: hydroserverpy
-Version: 0.4.0
+Version: 0.5.0b2
 Requires-Python: <4,>=3.9
 License-File: LICENSE
 Requires-Dist: requests>=2
 Requires-Dist: pydantic>=2.6
+Requires-Dist: pydantic[email]>=2.6
 Requires-Dist: pandas>=2.2
 Requires-Dist: numpy>=2.0
 Requires-Dist: pyyaml>=5
@@ -12,7 +13,7 @@ Requires-Dist: simplejson>=3
 Requires-Dist: crontab>=1
 Requires-Dist: python-dateutil>=2.8.2
 Requires-Dist: croniter>=2.0.1
-Requires-Dist: country-list>=1.1.0
 Requires-Dist: jmespath>=1.0.1
 Provides-Extra: docs
 Requires-Dist: sphinx_autodoc_typehints; extra == "docs"
+Dynamic: license-file

hydroserverpy-0.5.0b2.dist-info/RECORD

@@ -0,0 +1,66 @@
+hydroserverpy/__init__.py,sha256=FgaGFyhCjwmpJYEKNzOZxvfRx2neWMaOybj1z02_VSE,218
+hydroserverpy/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=s9u1oZyOdxM7txjJARFcIBrWMHQSDxODdreiatFsXJs,7331
+hydroserverpy/api/models/sta/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=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=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
+hydroserverpy/api/services/sta/thing.py,sha256=QL7IBwHHIgDFBpXnQF-LOUpxiRlm_HFWB1qqe7Iqq9s,5972
+hydroserverpy/api/services/sta/unit.py,sha256=ksO-3g___9pPNBNbgM0jyDf1NeBqX79fjeJjCshrftY,2138
+hydroserverpy/etl/__init__.py,sha256=qK2m4LZl8czR3VE8SxrlipSy5tLGLNB60lxD7dD0GjU,659
+hydroserverpy/etl/hydroserver_etl.py,sha256=FSdvM3T7QHEWWulWRT8t-FMHSxAGB4GvleUXtSk5IWc,1507
+hydroserverpy/etl/types.py,sha256=4PY3CM-uoXIsf2lhcqtLC6HaRGXe7HKGDU22R8-H35c,135
+hydroserverpy/etl/extractors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/etl/extractors/base.py,sha256=GZKJfAhfJedRcNagnoqUiDZn286r-JzM7dW_F1dWsfY,275
+hydroserverpy/etl/extractors/ftp_extractor.py,sha256=5LwvHuvLk6LwRSVyE9EkV3DPgVlAvRrOBpl1a8B7dLg,1387
+hydroserverpy/etl/extractors/http_extractor.py,sha256=-duQwnsFBk4NQS2qhO55evcCUOnrBe3JX_LU9RyysX4,2709
+hydroserverpy/etl/extractors/local_file_extractor.py,sha256=T_Y9NTO0cC5L9mDPbIG6wYlXDQoatg8MobP97liFl4U,692
+hydroserverpy/etl/loaders/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/etl/loaders/base.py,sha256=DrA9u7SNBxkPKqaszlP368yNbxihdqIGzP8rA6NAp6U,295
+hydroserverpy/etl/loaders/hydroserver_loader.py,sha256=bl4Z5TkXgJyKEHuPdY7LSrKMKOoZW_EDFl8dIRwDkv4,2549
+hydroserverpy/etl/transformers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+hydroserverpy/etl/transformers/base.py,sha256=237oVBhS3HQ3fcE4bZT5U1437WzV2x5kOFC229DY53M,1741
+hydroserverpy/etl/transformers/csv_transformer.py,sha256=9DKSO4NfUUDlr_c6UnH4AU3-7LxwSSeuQdou0iiCjdM,3238
+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=1RRqZWXb8pMhkeg6Tn1IbQ8SdKNgOl78eqeBguEXnog,13849
+hydroserverpy/quality/__init__.py,sha256=GGBMkFSXciJLYrbV-NraFrj_mXWCy_GTcy9KKrKXU4c,84
+hydroserverpy/quality/service.py,sha256=U02UfLKVmFvr5ySiH0n0JYzUIabq5uprrHIiwcqBlqY,13879
+hydroserverpy-0.5.0b2.dist-info/licenses/LICENSE,sha256=xVqFxDw3QOEJukakL7gQCqIMTQ1dlSCTo6Oc1otNW80,1508
+hydroserverpy-0.5.0b2.dist-info/METADATA,sha256=IBrwK9SbCsLvo0JQyIEQmBCxSMpdkZ4i0uNTTVU96cY,532
+hydroserverpy-0.5.0b2.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+hydroserverpy-0.5.0b2.dist-info/top_level.txt,sha256=Zf37hrncXLOYvXhgCrf5mZdeq81G9fShdE2LfYbtb7w,14
+hydroserverpy-0.5.0b2.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+hydroserverpy-0.5.0b2.dist-info/RECORD,,

{hydroserverpy-0.4.0.dist-info → hydroserverpy-0.5.0b2.dist-info}/WHEEL

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