mercuto-client 0.3.0__py3-none-any.whl → 0.3.4a3__py3-none-any.whl

mercuto_client/modules/data.py

@@ -10,7 +10,7 @@ from pydantic import TypeAdapter
 
 from ..exceptions import MercutoClientException, MercutoHTTPException
 from ..util import batched
-from . import _PayloadType, _raise_for_response
+from . import PayloadType, raise_for_response
 from ._util import BaseModel, serialise_timedelta
 
 if TYPE_CHECKING:
@@ -145,14 +145,14 @@ class MercutoDataService:
         self._path = path
 
     def healthcheck(self) -> Healthcheck:
-        r = self._client._http_request(f"{self._path}/healthcheck", "GET")
+        r = self._client.request(f"{self._path}/healthcheck", "GET")
         return Healthcheck.model_validate_json(r.text)
 
     def refresh_continuous_aggregates(self) -> None:
         """
         Request a refresh of continuous aggregates on all tables
         """
-        self._client._http_request(f"{self._path}/meta/refresh-aggregates", "POST")
+        self._client.request(f"{self._path}/meta/refresh-aggregates", "POST")
 
     """
     Channels
@@ -174,9 +174,9 @@ class MercutoDataService:
         if metric:
             params['metric'] = metric
 
-        all_channels = []
+        all_channels: list[Channel] = []
         while True:
-            r = self._client._http_request(f'{self._path}/channels', 'GET', params=params)
+            r = self._client.request(f'{self._path}/channels', 'GET', params=params)
 
             channels = _ChannellistAdapter.validate_json(r.text)
             all_channels.extend(channels)
@@ -186,16 +186,16 @@ class MercutoDataService:
         return all_channels
 
     def get_channel(self, code: str) -> Optional[Channel]:
-        r = self._client._http_request(f'{self._path}/channels/{code}', 'GET', raise_for_status=False)
+        r = self._client.request(f'{self._path}/channels/{code}', 'GET', raise_for_status=False)
         if r.status_code == 404:
             return None
-        _raise_for_response(r)
+        raise_for_response(r)
         return Channel.model_validate_json(r.text)
 
     def update_channel(self, code: str, label: Optional[str] = None, units: Optional[str] = None,
                        metric: Optional[str] = None, multiplier: Optional[float] = None,
                        offset: Optional[float] = None) -> Channel:
-        payload: _PayloadType = {}
+        payload: PayloadType = {}
         if label is not None:
             payload['label'] = label
         if units is not None:
@@ -207,11 +207,11 @@ class MercutoDataService:
         if offset is not None:
             payload['offset'] = offset
 
-        r = self._client._http_request(f'{self._path}/channels/{code}', 'PATCH', json=payload)
+        r = self._client.request(f'{self._path}/channels/{code}', 'PATCH', json=payload)
         return Channel.model_validate_json(r.text)
 
     def delete_channel(self, code: str) -> bool:
-        r = self._client._http_request(f'{self._path}/channels/{code}', 'DELETE')
+        r = self._client.request(f'{self._path}/channels/{code}', 'DELETE')
         return r.status_code == 204
 
     def create_channel(self, project: str,
@@ -225,7 +225,7 @@ class MercutoDataService:
                        aggregate: Optional[str] = None,
                        source: Optional[str] = None,
                        metric: Optional[str] = None) -> Channel:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             'project': project,
             'label': label,
             'classification': classification.value,
@@ -249,7 +249,7 @@ class MercutoDataService:
         if metric is not None:
             payload['metric'] = metric
 
-        r = self._client._http_request(f'{self._path}/channels', 'PUT', json=payload)
+        r = self._client.request(f'{self._path}/channels', 'PUT', json=payload)
         return Channel.model_validate_json(r.text)
 
     """
@@ -265,7 +265,7 @@ class MercutoDataService:
         aggregate: Optional[str] = None,
         metric: Optional[str] = None
     ) -> Expression:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "project": project,
             "label": label,
             "expression": expression,
@@ -277,11 +277,11 @@ class MercutoDataService:
         if metric is not None:
             payload["metric"] = metric
 
-        r = self._client._http_request(f'{self._path}/expressions', 'PUT', json=payload)
+        r = self._client.request(f'{self._path}/expressions', 'PUT', json=payload)
         return Expression.model_validate_json(r.text)
 
     def delete_expression(self, code: str) -> bool:
-        r = self._client._http_request(f'{self._path}/expressions/{code}', 'DELETE')
+        r = self._client.request(f'{self._path}/expressions/{code}', 'DELETE')
         return r.status_code == 202
 
     """
@@ -289,24 +289,24 @@ class MercutoDataService:
     """
 
     def create_datatable(self, project: str, name: str, sampling_period: timedelta, column_labels: Collection[str]) -> Datatable:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "project": project,
             "name": name,
             "sampling_period": serialise_timedelta(sampling_period),
             "column_labels": list(column_labels),
         }
-        r = self._client._http_request(f'{self._path}/datatables', 'PUT', json=payload)
+        r = self._client.request(f'{self._path}/datatables', 'PUT', json=payload)
         return Datatable.model_validate_json(r.text)
 
     def list_datatables(self, project: str) -> list[Datatable]:
-        datatables = []
+        datatables: list[Datatable] = []
         params: dict[str, Any] = {
             "project": project,
             "limit": 100,
             "offset": 0,
         }
         while True:
-            r = self._client._http_request(f'{self._path}/datatables', 'GET', params=params)
+            r = self._client.request(f'{self._path}/datatables', 'GET', params=params)
 
             batch = _DatatablelistAdapter.validate_json(r.text)
             datatables.extend(batch)
@@ -320,15 +320,15 @@ class MercutoDataService:
     """
 
     def list_units(self) -> list[Units]:
-        r = self._client._http_request(f'{self._path}/units', 'GET')
+        r = self._client.request(f'{self._path}/units', 'GET')
         return _UnitslistAdapter.validate_json(r.text)
 
     def create_unit(self, name: str, unit: str) -> Units:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "name": name,
             "unit": unit,
         }
-        r = self._client._http_request(f'{self._path}/units', 'PUT', json=payload)
+        r = self._client.request(f'{self._path}/units', 'PUT', json=payload)
         return Units.model_validate_json(r.text)
 
     """
@@ -354,7 +354,7 @@ class MercutoDataService:
         if channels is None and classification is None:
             raise ValueError("Must supply either channels or classification.")
 
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "start_time": start_time.isoformat(),
             "end_time": end_time.isoformat(),
             "frame_format": frame_format.value,
@@ -374,7 +374,7 @@ class MercutoDataService:
         if aggregation is not None:
             payload["aggregation"] = aggregation.model_dump(mode='json')
 
-        r = self._client._http_request(
+        r = self._client.request(
             f'{self._path}/requests', 'POST',
             json=payload,
             params={"timeout": timeout}
@@ -382,7 +382,7 @@ class MercutoDataService:
         return GetStatusRequestResponse.model_validate_json(r.text)
 
     def get_request(self, request_id: str) -> GetStatusRequestResponse:
-        r = self._client._http_request(f'{self._path}/requests/{request_id}', 'GET')
+        r = self._client.request(f'{self._path}/requests/{request_id}', 'GET')
         return GetStatusRequestResponse.model_validate_json(r.text)
 
     """
@@ -425,8 +425,6 @@ class MercutoDataService:
             poll_interval=poll_interval,
             timeout=timeout
         )
-        if result.result_url is None:
-            raise MercutoClientException("Failed to obtain presigned URL.")
         return result.result_url
 
     def load_data_request(
@@ -499,7 +497,7 @@ class MercutoDataService:
         """
         for batch in batched(samples, 5000):
             payload = _SecondarySamplelistAdapter.dump_python(list(batch), mode='json')
-            self._client._http_request(
+            self._client.request(
                 f'{self._path}/samples/secondary', 'PUT', json=payload, params={"project": project}
             )
 
@@ -515,7 +513,7 @@ class MercutoDataService:
         """
         for batch in batched(samples, 5000):
             payload = _MetricSamplelistAdapter.dump_python(list(batch), mode='json')
-            self._client._http_request(
+            self._client.request(
                 f'{self._path}/samples/metric', 'PUT', json=payload, params={"project": project}
             )
 
@@ -531,13 +529,13 @@ class MercutoDataService:
         """
         Load up to 100 secondary samples.
         """
-        params: _PayloadType = {
+        params: PayloadType = {
             "channels": list(channels),
             "start_time": start_time.isoformat(),
             "end_time": end_time.isoformat(),
             "limit": limit
         }
-        r = self._client._http_request(
+        r = self._client.request(
             f'{self._path}/samples/secondary', 'GET', params=params
         )
 
@@ -555,7 +553,7 @@ class MercutoDataService:
         """
         Load up to 100 metric samples.
         """
-        params: _PayloadType = {
+        params: PayloadType = {
             "limit": limit
         }
         if project is not None:
@@ -568,7 +566,7 @@ class MercutoDataService:
             params["end_time"] = end_time.isoformat()
         if events is not None:
             params["event"] = list(events)
-        r = self._client._http_request(
+        r = self._client.request(
             f'{self._path}/samples/metric', 'GET', params=params
         )
 
@@ -582,10 +580,10 @@ class MercutoDataService:
         return samples[0].value if samples else None
 
     def delete_metric_samples(self, project: str, event: str, channels: Optional[Collection[str]] = None) -> None:
-        params: _PayloadType = {"project": project, "event": event}
+        params: PayloadType = {"project": project, "event": event}
         if channels is not None:
             params["channels"] = list(channels)
-        self._client._http_request(
+        self._client.request(
             f'{self._path}/samples/metric', 'DELETE', params=params
         )
 
@@ -599,7 +597,7 @@ class MercutoDataService:
             ctx = nullcontext(file)  # type: ignore
             filename = filename or 'file.dat'
 
-        params: _PayloadType = {
+        params: PayloadType = {
             "project": project,
             "datatable": datatable,
         }
@@ -607,16 +605,16 @@ class MercutoDataService:
             params["timezone"] = timezone
 
         with ctx as f:
-            self._client._http_request(f'{self._path}/files/upload/small', 'POST',
-                                       params=params,
-                                       files={'file': (filename, f, 'text/csv')})
+            self._client.request(f'{self._path}/files/upload/small', 'POST',
+                                 params=params,
+                                 files={'file': (filename, f, 'text/csv')})
 
     def get_latest_samples(self, project: str, include_primary: bool = True) -> list[LatestDataSample]:
-        params: _PayloadType = {
+        params: PayloadType = {
             "project": project,
             "include_primary": include_primary
         }
-        r = self._client._http_request(
+        r = self._client.request(
             f'{self._path}/statistics/latest-samples', 'GET', params=params
         )
 

mercuto_client/modules/fatigue.py

@@ -6,7 +6,7 @@ from pydantic import Field, TypeAdapter
 if TYPE_CHECKING:
     from ..client import MercutoClient
 
-from . import _PayloadType
+from . import PayloadType
 from ._util import BaseModel
 
 
@@ -55,14 +55,14 @@ class MercutoFatigueService:
         self._path = path
 
     def healthcheck(self) -> Healthcheck:
-        r = self._client._http_request(f"{self._path}/healthcheck", "GET")
+        r = self._client.request(f"{self._path}/healthcheck", "GET")
         return Healthcheck.model_validate_json(r.text)
 
     # --- Rainflow routes ---
 
     def list_rainflow_config(self, project: str) -> list[RainflowConfiguration]:
-        params: _PayloadType = {"project": project}
-        r = self._client._http_request(f"{self._path}/rainflow/setup", "GET", params=params)
+        params: PayloadType = {"project": project}
+        r = self._client.request(f"{self._path}/rainflow/setup", "GET", params=params)
         return _RainflowConfigurationlistAdapter.validate_json(r.text)
 
     def setup_rainflow(
@@ -74,7 +74,7 @@ class MercutoFatigueService:
         reservoir_adjustment: bool,
         sources: list[str]
     ) -> RainflowConfiguration:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "project": project,
             "max_bins": max_bins,
             "bin_size": bin_size,
@@ -82,18 +82,18 @@ class MercutoFatigueService:
             "reservoir_adjustment": reservoir_adjustment,
             "sources": sources,
         }
-        r = self._client._http_request(f"{self._path}/rainflow/setup", "PUT", json=payload)
+        r = self._client.request(f"{self._path}/rainflow/setup", "PUT", json=payload)
         return RainflowConfiguration.model_validate_json(r.text)
 
     def get_cycle_counts(
         self, project: str, start_time: datetime, end_time: datetime
     ) -> bytes:
-        params: _PayloadType = {
+        params: PayloadType = {
             "project": project,
             "start_time": start_time.isoformat(),
             "end_time": end_time.isoformat(),
         }
-        r = self._client._http_request(
+        r = self._client.request(
             f"{self._path}/rainflow/cycle_counts", "GET", params=params, stream=True
         )
         return r.content
@@ -101,13 +101,13 @@ class MercutoFatigueService:
     def delete_cycle_counts(
         self, project: str, start_time: datetime, end_time: datetime, ignore_if_not_configured: bool = False
     ) -> None:
-        params: _PayloadType = {
+        params: PayloadType = {
             "project": project,
             "start_time": start_time.isoformat(),
             "end_time": end_time.isoformat(),
             "ignore_if_not_configured": ignore_if_not_configured,
         }
-        self._client._http_request(
+        self._client.request(
             f"{self._path}/rainflow/cycle_counts", "DELETE", params=params
         )
 
@@ -120,7 +120,7 @@ class MercutoFatigueService:
         url_expiry: Optional[datetime] = None,
         ignore_if_not_configured: bool = False
     ) -> None:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "project": project,
             "event": event,
             "presigned_url": presigned_url,
@@ -129,15 +129,15 @@ class MercutoFatigueService:
         if url_expiry is not None:
             payload["url_expiry"] = url_expiry.isoformat()
         params = {"ignore_if_not_configured": ignore_if_not_configured}
-        self._client._http_request(
+        self._client.request(
             f"{self._path}/rainflow/cycle_counts/calculate", "PUT", json=payload, params=params
         )
 
     # --- Fatigue Connections routes ---
 
     def get_connections(self, project: str) -> list[FatigueConnection]:
-        params: _PayloadType = {"project": project}
-        r = self._client._http_request(f"{self._path}/connections", "GET", params=params)
+        params: PayloadType = {"project": project}
+        r = self._client.request(f"{self._path}/connections", "GET", params=params)
         return _FatigueConnectionlistAdapter.validate_json(r.text)
 
     def add_connection(
@@ -154,7 +154,7 @@ class MercutoFatigueService:
         initial_damage: float,
         sources: list[str]
     ) -> FatigueConnection:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "project": project,
             "label": label,
             "multiplier": multiplier,
@@ -167,23 +167,23 @@ class MercutoFatigueService:
             "initial_damage": initial_damage,
             "sources": sources,
         }
-        r = self._client._http_request(f"{self._path}/connections", "PUT", json=payload)
+        r = self._client.request(f"{self._path}/connections", "PUT", json=payload)
         return FatigueConnection.model_validate_json(r.text)
 
     def delete_connection(self, connection_code: str) -> None:
-        self._client._http_request(f"{self._path}/connections/{connection_code}", "DELETE")
+        self._client.request(f"{self._path}/connections/{connection_code}", "DELETE")
 
     # --- Connection Data routes ---
 
     def get_connection_remnant_capacity(
         self, project: str, start_time: datetime, end_time: datetime
     ) -> list[ConnectionRemnantCapacity]:
-        params: _PayloadType = {
+        params: PayloadType = {
             "project": project,
             "start_time": start_time.isoformat(),
             "end_time": end_time.isoformat(),
         }
-        r = self._client._http_request(
+        r = self._client.request(
             f"{self._path}/connection_data/remnant-capacity", "GET", params=params
         )
         return _ConnectionRemnantCapacitylistAdapter.validate_json(r.text)

mercuto_client/modules/identity.py

@@ -5,7 +5,7 @@ from pydantic import TypeAdapter
 if TYPE_CHECKING:
     from ..client import MercutoClient
 
-from . import _PayloadType
+from . import PayloadType
 from ._util import BaseModel
 
 
@@ -86,22 +86,22 @@ class MercutoIdentityService:
         self._path = path
 
     def healthcheck(self) -> Healthcheck:
-        r = self._client._http_request(f"{self._path}/healthcheck", "GET")
+        r = self._client.request(f"{self._path}/healthcheck", "GET")
         return Healthcheck.model_validate_json(r.text)
 
     # --- Verify routes ---
 
     def get_my_permissions(self) -> VerifyMyPermissions:
-        r = self._client._http_request(f"{self._path}/verify/me", "GET")
+        r = self._client.request(f"{self._path}/verify/me", "GET")
         return VerifyMyPermissions.model_validate_json(r.text)
 
     # --- User routes ---
 
     def list_users(self, tenant: Optional[str] = None) -> list[User]:
-        params: _PayloadType = {}
+        params: PayloadType = {}
         if tenant is not None:
             params["tenant"] = tenant
-        r = self._client._http_request(f"{self._path}/users", "GET", params=params)
+        r = self._client.request(f"{self._path}/users", "GET", params=params)
         return _UserlistAdapter.validate_json(r.text)
 
     def create_user(
@@ -112,26 +112,26 @@ class MercutoIdentityService:
         group: str,
         default_password: Optional[str] = None
     ) -> User:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "username": username,
             "tenant_code": tenant,
             "description": description,
             "group_code": group,
             "default_password": default_password,
         }
-        r = self._client._http_request(f"{self._path}/users", "PUT", json=payload)
+        r = self._client.request(f"{self._path}/users", "PUT", json=payload)
         return User.model_validate_json(r.text)
 
     def get_current_user(self) -> CurrentUser:
-        r = self._client._http_request(f"{self._path}/users/me", "GET")
+        r = self._client.request(f"{self._path}/users/me", "GET")
         return CurrentUser.model_validate_json(r.text)
 
     def get_user(self, code: str) -> User:
-        r = self._client._http_request(f"{self._path}/users/{code}", "GET")
+        r = self._client.request(f"{self._path}/users/{code}", "GET")
         return User.model_validate_json(r.text)
 
     def delete_user(self, code: str) -> None:
-        self._client._http_request(f"{self._path}/users/{code}", "DELETE")
+        self._client.request(f"{self._path}/users/{code}", "DELETE")
 
     def edit_user(
         self,
@@ -139,15 +139,15 @@ class MercutoIdentityService:
         description: str,
         group: str
     ) -> User:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "description": description,
             "group_code": group,
         }
-        r = self._client._http_request(f"{self._path}/users/{code}", "PATCH", json=payload)
+        r = self._client.request(f"{self._path}/users/{code}", "PATCH", json=payload)
         return User.model_validate_json(r.text)
 
     def get_user_details(self, code: str) -> UserDetails:
-        r = self._client._http_request(f"{self._path}/users/{code}/details", "GET")
+        r = self._client.request(f"{self._path}/users/{code}/details", "GET")
         return UserDetails.model_validate_json(r.text)
 
     def set_user_details(
@@ -158,17 +158,17 @@ class MercutoIdentityService:
         first_name: Optional[str] = None,
         last_name: Optional[str] = None
     ) -> UserDetails:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "email_address": email_address,
             "mobile_number": mobile_number,
             "first_name": first_name,
             "last_name": last_name,
         }
-        r = self._client._http_request(f"{self._path}/users/{code}/details", "PATCH", json=payload)
+        r = self._client.request(f"{self._path}/users/{code}/details", "PATCH", json=payload)
         return UserDetails.model_validate_json(r.text)
 
     def get_user_api_keys(self, user: str) -> list[HiddenUserAPIKey]:
-        r = self._client._http_request(f"{self._path}/users/{user}/api_keys", "GET")
+        r = self._client.request(f"{self._path}/users/{user}/api_keys", "GET")
         return _HiddenUserAPIKeylistAdapter.validate_json(r.text)
 
     def generate_api_key_for_user(
@@ -177,24 +177,24 @@ class MercutoIdentityService:
         description: str,
         custom_policy: Optional[str] = None
     ) -> VisibleUserAPIKey:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "description": description,
             "custom_policy": custom_policy,
         }
-        r = self._client._http_request(f"{self._path}/users/{user}/api_keys", "POST", json=payload)
+        r = self._client.request(f"{self._path}/users/{user}/api_keys", "POST", json=payload)
         return VisibleUserAPIKey.model_validate_json(r.text)
 
     def delete_api_key(self, user: str, key_code: str) -> None:
-        self._client._http_request(f"{self._path}/users/{user}/api_keys/{key_code}", "DELETE")
+        self._client.request(f"{self._path}/users/{user}/api_keys/{key_code}", "DELETE")
 
     # --- Tenants routes ---
 
     def list_tenants(self) -> list[Tenant]:
-        r = self._client._http_request(f"{self._path}/tenants", "GET")
+        r = self._client.request(f"{self._path}/tenants", "GET")
         return _TenantlistAdapter.validate_json(r.text)
 
     def get_tenant(self, code: str) -> Tenant:
-        r = self._client._http_request(f"{self._path}/tenants/{code}", "GET")
+        r = self._client.request(f"{self._path}/tenants/{code}", "GET")
         return Tenant.model_validate_json(r.text)
 
     def create_tenant(
@@ -203,21 +203,21 @@ class MercutoIdentityService:
         description: str,
         logo_url: Optional[str] = None
     ) -> Tenant:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "name": name,
             "description": description,
             "logo_url": logo_url,
         }
-        r = self._client._http_request(f"{self._path}/tenants", "PUT", json=payload)
+        r = self._client.request(f"{self._path}/tenants", "PUT", json=payload)
         return Tenant.model_validate_json(r.text)
 
     # --- Permission Groups routes ---
 
     def get_permission_groups(self, tenant: Optional[str] = None) -> list[PermissionGroup]:
-        params = {}
+        params: PayloadType = {}
         if tenant is not None:
             params["tenant"] = tenant
-        r = self._client._http_request(f"{self._path}/permissions", "GET", params=params)
+        r = self._client.request(f"{self._path}/permissions", "GET", params=params)
         return _PermissionGrouplistAdapter.validate_json(r.text)
 
     def create_permission_group(
@@ -226,20 +226,20 @@ class MercutoIdentityService:
         label: str,
         acl_policy: str
     ) -> PermissionGroup:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "tenant": tenant,
             "label": label,
             "acl_policy": acl_policy,
         }
-        r = self._client._http_request(f"{self._path}/permissions", "PUT", json=payload)
+        r = self._client.request(f"{self._path}/permissions", "PUT", json=payload)
         return PermissionGroup.model_validate_json(r.text)
 
     def get_permission_group(self, group: str) -> PermissionGroup:
-        r = self._client._http_request(f"{self._path}/permissions/{group}", "GET")
+        r = self._client.request(f"{self._path}/permissions/{group}", "GET")
         return PermissionGroup.model_validate_json(r.text)
 
     def delete_permission_group(self, group: str) -> None:
-        self._client._http_request(f"{self._path}/permissions/{group}", "DELETE")
+        self._client.request(f"{self._path}/permissions/{group}", "DELETE")
 
     def modify_permission_group(
         self,
@@ -247,8 +247,8 @@ class MercutoIdentityService:
         label: str,
         acl_policy: str
     ) -> None:
-        payload: _PayloadType = {
+        payload: PayloadType = {
             "label": label,
             "acl_policy": acl_policy,
         }
-        self._client._http_request(f"{self._path}/permissions/{group}", "PATCH", json=payload)
+        self._client.request(f"{self._path}/permissions/{group}", "PATCH", json=payload)