ul-data-logger-api-sdk 3.0.0__tar.gz → 3.1.1__tar.gz

{ul_data_logger_api_sdk-3.0.0 → ul_data_logger_api_sdk-3.1.1}/.gitignore

@@ -271,6 +271,7 @@ tags
 .envs/*
 !.envs/.local/
 !srv/merge_dotenvs.py
+*.env
 
 
 .ipynb_checkpoints/
@@ -291,5 +292,8 @@ _*.ipynb
 
 /srv/*.retry
 
+# Локальный overlay для demo-стенда (пароли, адреса Patroni)
+srv/docker_compose/docker-compose.demo.yml
+
 # Swagger spec
 /src/conf/*docs.yml

{ul_data_logger_api_sdk-3.0.0 → ul_data_logger_api_sdk-3.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: ul-data-logger-api-sdk
-Version: 3.0.0
+Version: 3.1.1
 Summary: Data logger API sdk
 Author: Unic-lab
 License-Expression: MIT

ul_data_logger_api_sdk-3.1.1/data_logger_api_sdk.py

@@ -0,0 +1,316 @@
+import json
+import time
+from datetime import date, datetime
+from functools import lru_cache
+from typing import Any, Dict, List, Type
+from uuid import UUID
+
+from ul_api_utils.internal_api.internal_api import InternalApi
+from ul_api_utils.internal_api.internal_api_response import TPyloadType
+from ul_api_utils.utils.api_method import ApiMethod
+
+from data_logger_api_sdk.data_logger_sdk_config import DataLoggerApiSdkConfig
+from data_logger_api_sdk.types.api_base_stations import (
+    ApiBaseStationDetailResponse,
+    ApiBaseStationDeviceLogsResponse,
+    ApiBaseStationDevicesResponse,
+    ApiBaseStationLogsStatForIntervalsResponse,
+    ApiBaseStationLogsStatResponse,
+    ApiBaseStationLogResponse,
+    ApiBaseStationLogsListResult,
+    ApiBaseStationsListResult,
+    ApiBaseStationResponse,
+    ApiBaseStationSystemLogResponse,
+    ApiBaseStationSystemLogsListResult,
+)
+from data_logger_api_sdk.types.api_bs_traffic_stats import ApiBsTrafficStatsResponse, ApiDeviceTrafficStatsQuery
+from data_logger_api_sdk.types.api_device_data_history import ApiDeviceDataHistoryBody, ApiDeviceDataHistoryResponse
+from data_logger_api_sdk.types.api_last_bs_data_by_device_macs import ApiDeviceLastBsDataResponse, ApiDeviceMacsListBodyModel
+from data_logger_api_sdk.types.api_packet_types import ApiPacketTypesListResponse
+from data_logger_api_sdk.types.api_protocol_types import ApiProtocolTypesListResponse
+
+
+class DataLoggerApiSdk:
+
+    def __init__(self, config: DataLoggerApiSdkConfig) -> None:
+        self._config = config
+        self._api = InternalApi(entry_point=self._config.api_url, default_auth_token=self._config.api_token)
+
+    @lru_cache(maxsize=None)  # there should not be leaks memory leaks. flake8 just scared inmemory cache ;)
+    def request_payload(
+        self,
+        _: int,
+        method: ApiMethod,
+        endpoint: str,
+        typed_as: Type[TPyloadType],
+        body: str | None,
+        query: str | None = None,
+    ) -> TPyloadType:
+        return (
+            self._api.request(
+                method=method,
+                path=endpoint,
+                json=json.loads(body) if body is not None else None,
+                q=json.loads(query) if query is not None else None,
+            )
+            .typed(typed_as)
+            .check()
+            .payload
+        )
+
+    def _get_cache_post_payload(
+        self,
+        method: ApiMethod,
+        path: str,
+        typed: Type[TPyloadType],
+        body: str | None = None,
+        query: str | None = None,
+    ) -> TPyloadType:
+        ttl_status = round(time.time() / self._config.cache_ttl_s)
+        return self.request_payload(ttl_status, method, path, typed, body, query)  # type: ignore  # Type[TPyloadType] is hashable
+
+    def _request_payload_once(
+        self,
+        method: ApiMethod,
+        path: str,
+        typed: Type[TPyloadType],
+        query: Dict[str, Any] | None = None,
+    ) -> TPyloadType:
+        response = self._api.request(
+            method=method,
+            path=path,
+            json=None,
+            q=query,
+        ).typed(typed).check()
+        return response.payload
+
+    def _request_list_payload_once(
+        self,
+        method: ApiMethod,
+        path: str,
+        typed: Type[TPyloadType],
+        query: Dict[str, Any] | None = None,
+    ) -> tuple[TPyloadType, int]:
+        response = self._api.request(
+            method=method,
+            path=path,
+            json=None,
+            q=query,
+        ).typed(typed).check()
+        total_count = response.total_count
+        assert total_count is not None, "total_count must be present for array payloads"
+        return response.payload, total_count
+
+    def get_protocol_types_list(self, mac: int) -> List[str]:
+        return self._get_cache_post_payload(
+            ApiMethod.GET,
+            f"/devices/mac/{mac}/logs/protocol-types",
+            ApiProtocolTypesListResponse,
+        ).protocol_types
+
+    def get_packet_types_list(self, mac: int) -> List[str]:
+        return self._get_cache_post_payload(
+            ApiMethod.GET,
+            f"/devices/mac/{mac}/logs/packet-types",
+            ApiPacketTypesListResponse,
+        ).packet_types
+
+    def get_device_data_history(
+        self,
+        period_from: datetime,
+        period_to: datetime,
+        mac: int,
+        protocol_type: str | None = None,
+        packet_type: str | None = None,
+    ) -> List[ApiDeviceDataHistoryResponse]:
+        api_device_history_body = ApiDeviceDataHistoryBody(
+            period_from=period_from,
+            period_to=period_to,
+            mac=mac,
+            protocol_type=protocol_type,
+            packet_type=packet_type,
+        ).model_dump_json()
+        return self._get_cache_post_payload(
+            ApiMethod.POST,
+            "/device-data-history",
+            List[ApiDeviceDataHistoryResponse],  # type: ignore
+            api_device_history_body,
+        )
+
+    def get_last_bs_data_by_device_macs(
+        self,
+        macs: set[int],
+    ) -> List[ApiDeviceLastBsDataResponse]:
+        return self._get_cache_post_payload(
+            ApiMethod.POST,
+            "/devices/last-bs-data",
+            List[ApiDeviceLastBsDataResponse],  # type: ignore
+            ApiDeviceMacsListBodyModel(macs=macs).model_dump_json(),
+        )
+
+    def get_bs_traffic_stats(
+        self,
+        base_station_id: UUID,
+        start_at: datetime,
+        end_at: datetime,
+    ) -> List[ApiBsTrafficStatsResponse]:
+        api_bs_traffic_stats_query = ApiDeviceTrafficStatsQuery(
+            start_at=start_at,
+            end_at=end_at,
+        )
+        return self._get_cache_post_payload(
+            ApiMethod.GET,
+            f"/base-stations/{base_station_id}/traffic-stats",
+            List[ApiBsTrafficStatsResponse],  # type: ignore
+            None,
+            api_bs_traffic_stats_query.model_dump_json(),
+        )
+
+    def get_base_stations(
+        self,
+        limit: int,
+        offset: int = 0,
+        serial_number: int | None = None,
+        log_stat_days: int = 0,
+    ) -> ApiBaseStationsListResult:
+        """GET /base-stations — список базовых станций Data Logger."""
+        query: Dict[str, Any] = {
+            "limit": limit,
+            "offset": offset,
+            "log_stat_days": log_stat_days,
+        }
+        if serial_number is not None:
+            query["serial_number"] = serial_number
+        items, total_count = self._request_list_payload_once(
+            ApiMethod.GET,
+            "/base-stations",
+            List[ApiBaseStationResponse],  # type: ignore
+            query,
+        )
+        return ApiBaseStationsListResult(items=items, total_count=total_count)
+
+    def get_base_station(
+        self,
+        base_station_id: UUID,
+        log_stat_days: int = 0,
+    ) -> ApiBaseStationDetailResponse:
+        """GET /base-stations/<uuid> — карточка базовой станции Data Logger."""
+        return self._request_payload_once(
+            ApiMethod.GET,
+            f"/base-stations/{base_station_id}",
+            ApiBaseStationDetailResponse,
+            {"log_stat_days": log_stat_days},
+        )
+
+    def get_base_station_logs(
+        self,
+        base_station_id: UUID,
+        start_at: datetime | None = None,
+        end_at: datetime | None = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> ApiBaseStationLogsListResult:
+        """GET /base-stations/<uuid>/logs — журнал логов базовой станции."""
+        query: Dict[str, Any] = {"limit": limit, "offset": offset}
+        if start_at is not None:
+            query["start_at"] = start_at.isoformat()
+        if end_at is not None:
+            query["end_at"] = end_at.isoformat()
+        items, total_count = self._request_list_payload_once(
+            ApiMethod.GET,
+            f"/base-stations/{base_station_id}/logs",
+            List[ApiBaseStationLogResponse],  # type: ignore
+            query,
+        )
+        return ApiBaseStationLogsListResult(items=items, total_count=total_count)
+
+    def get_base_station_system_logs(
+        self,
+        base_station_id: UUID,
+        start_at: datetime | None = None,
+        end_at: datetime | None = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> ApiBaseStationSystemLogsListResult:
+        """GET /base-stations/<uuid>/system-logs — журнал системных логов базовой станции."""
+        query: Dict[str, Any] = {"limit": limit, "offset": offset}
+        if start_at is not None:
+            query["start_at"] = start_at.isoformat()
+        if end_at is not None:
+            query["end_at"] = end_at.isoformat()
+        items, total_count = self._request_list_payload_once(
+            ApiMethod.GET,
+            f"/base-stations/{base_station_id}/system-logs",
+            List[ApiBaseStationSystemLogResponse],  # type: ignore
+            query,
+        )
+        return ApiBaseStationSystemLogsListResult(items=items, total_count=total_count)
+
+    def get_base_station_logs_stat(
+        self,
+        base_station_id: UUID,
+        day: date,
+    ) -> ApiBaseStationLogsStatResponse:
+        """GET /base-stations/<uuid>/logs-stat — статистика логов базовой станции за сутки."""
+        return self._request_payload_once(
+            ApiMethod.GET,
+            f"/base-stations/{base_station_id}/logs-stat",
+            ApiBaseStationLogsStatResponse,
+            {"day": day.isoformat()},
+        )
+
+    def get_base_station_logs_stat_for_intervals(
+        self,
+        base_station_id: UUID,
+        start_at: datetime,
+        end_at: datetime | None = None,
+    ) -> ApiBaseStationLogsStatForIntervalsResponse:
+        """GET /base-stations/<uuid>/logs-stat-for-intervals — метки времени логов за интервал."""
+        query: Dict[str, Any] = {"start_at": start_at.isoformat()}
+        if end_at is not None:
+            query["end_at"] = end_at.isoformat()
+        return self._request_payload_once(
+            ApiMethod.GET,
+            f"/base-stations/{base_station_id}/logs-stat-for-intervals",
+            ApiBaseStationLogsStatForIntervalsResponse,
+            query,
+        )
+
+    def get_base_station_devices(
+        self,
+        base_station_id: UUID,
+        start_at: datetime,
+        end_at: datetime | None = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> ApiBaseStationDevicesResponse:
+        """GET /base-stations/<uuid>/devices — устройства, работающие через базовую станцию."""
+        query: Dict[str, Any] = {"start_at": start_at.isoformat(), "limit": limit, "offset": offset}
+        if end_at is not None:
+            query["end_at"] = end_at.isoformat()
+        return self._request_payload_once(
+            ApiMethod.GET,
+            f"/base-stations/{base_station_id}/devices",
+            ApiBaseStationDevicesResponse,
+            query,
+        )
+
+    def get_base_station_device_logs(
+        self,
+        base_station_id: UUID,
+        start_at: datetime,
+        end_at: datetime | None = None,
+        limit: int = 100,
+        offset: int = 0,
+    ) -> ApiBaseStationDeviceLogsResponse:
+        """GET /base-stations/<uuid>/device-logs — логи устройств базовой станции."""
+        query: Dict[str, Any] = {"start_at": start_at.isoformat(), "limit": limit, "offset": offset}
+        if end_at is not None:
+            query["end_at"] = end_at.isoformat()
+        return self._request_payload_once(
+            ApiMethod.GET,
+            f"/base-stations/{base_station_id}/device-logs",
+            ApiBaseStationDeviceLogsResponse,
+            query,
+        )
+

{ul_data_logger_api_sdk-3.0.0 → ul_data_logger_api_sdk-3.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ul-data-logger-api-sdk"
-version = "3.0.0"
+version = "3.1.1"
 description = "Data logger API sdk"
 license = "MIT"
 requires-python = ">=3.14"

ul_data_logger_api_sdk-3.1.1/types/api_base_stations.py

@@ -0,0 +1,184 @@
+from datetime import datetime
+from typing import Any, Dict, List, NamedTuple, Tuple
+
+from pydantic.types import UUID4
+from ul_api_utils.api_resource.api_response import JsonApiResponsePayload
+
+BS__LOG_TYPE__DEVICE_DATA = "device_data"
+BS__LOG_TYPE__HEARTBIT = "heartbit"
+
+
+class ApiBaseStationsListResult(NamedTuple):
+    """Результат спискового вызова BS-endpoint Data Logger: страница элементов и total_count."""
+
+    items: List["ApiBaseStationResponse"]
+    total_count: int
+
+
+class ApiBaseStationLogsListResult(NamedTuple):
+    """Результат вызова GET /base-stations/<uuid>/logs."""
+
+    items: List["ApiBaseStationLogResponse"]
+    total_count: int
+
+
+class ApiBaseStationSystemLogsListResult(NamedTuple):
+    """Результат вызова GET /base-stations/<uuid>/system-logs."""
+
+    items: List["ApiBaseStationSystemLogResponse"]
+    total_count: int
+
+
+class ApiBaseStationResponse(JsonApiResponsePayload):
+    """Элемент ответа GET /base-stations (BsListShortResponse на стороне Data Logger)."""
+
+    id: UUID4
+    date_created: datetime
+    date_modified: datetime
+    is_alive: bool
+
+    api_user_modified_id: UUID4 | None = None
+    note: str = ""
+    permission_id: int
+
+    type: str
+    serial_number: int
+
+    latest_log_datetime: datetime | None = None
+    latest_geo_latitude: float | None = None
+    latest_geo_longitude: float | None = None
+    latest_soft_version: str | None = None
+    latest_geo_is_actual: bool | None = None
+    latest_sdr_config_id: UUID4 | None = None
+
+    logs_stat: List[Tuple[datetime, int]] | None = None
+
+
+class ApiBaseStationDetailResponse(ApiBaseStationResponse):
+    """Ответ GET /base-stations/<uuid> (BsResponse на стороне Data Logger)."""
+
+    latest_sdr_config: Dict[str, Any] | None = None
+    device_counts: List[Tuple[datetime, int]] | None = None
+    system_logs_stat: List[Tuple[datetime, int]] | None = None
+    environment_spectrums_stat: List[Tuple[datetime, int]] | None = None
+    sdr_config_data_list: List[Dict[str, Any] | None] | None = None
+
+
+class ApiBaseStationLogResponse(JsonApiResponsePayload):
+    """Элемент ответа GET /base-stations/<uuid>/logs (ApiBsLogsResponse на стороне Data Logger)."""
+
+    id: UUID4
+    date_created: datetime
+
+    bs_id: UUID4 | None = None
+    protocol: str | None = None
+    log_type: str
+
+    date_sending: datetime
+
+    latitude: float | None = None
+    longitude: float | None = None
+    soft_version: str | None = None
+    uptime_s: int | None = None
+
+    external_document_id: UUID4 | None = None
+
+
+class ApiBaseStationSystemLogResponse(JsonApiResponsePayload):
+    """Элемент ответа GET /base-stations/<uuid>/system-logs (ApiBsSystemLogsResponse)."""
+
+    id: UUID4
+    date_created: datetime
+
+    bs_id: UUID4 | None = None
+    bs_log_id: UUID4 | None = None
+    date: datetime
+    type: str
+    mdl: str | None = None
+    text: str | None = None
+
+
+class ApiBaseStationLogsStatResponse(JsonApiResponsePayload):
+    """Ответ GET /base-stations/<uuid>/logs-stat (ApiBsLogsStatResponse)."""
+
+    stats: List[Tuple[datetime, int]]
+
+
+class ApiBaseStationLogsStatForIntervalsResponse(JsonApiResponsePayload):
+    """Ответ GET /base-stations/<uuid>/logs-stat-for-intervals (ApiBsLogsStatForIntervalsGraphResponse)."""
+
+    stats: List[datetime]
+
+
+class ApiBaseStationDeviceResponse(JsonApiResponsePayload):
+    """Элемент devices ответа GET /base-stations/<uuid>/devices (ApiDeviceResponse без вложенной БС)."""
+
+    id: UUID4
+    date_created: datetime
+    date_modified: datetime
+    is_alive: bool
+
+    api_user_modified_id: UUID4
+    note: str
+
+    device_id: UUID4
+    device_network_id: UUID4
+    device_network_mac: int
+
+    latest_device_gateway_id: UUID4 | None = None
+    latest_device_protocol_id: UUID4
+    latest_device_protocol_type: str | None = None
+    latest_device_network_sys_type: str | None = None
+    latest_log_datetime: datetime
+    latest_bs_id: UUID4 | None = None
+    latest_signal_rssi: int | None = None
+    latest_signal_snr: int | None = None
+
+    logs_stat: List[Tuple[datetime, int]] | None = None
+
+
+class ApiBaseStationDevicesResponse(JsonApiResponsePayload):
+    """Ответ GET /base-stations/<uuid>/devices (ApiBsDevicesResponse)."""
+
+    devices: List[ApiBaseStationDeviceResponse]
+    device_count: int
+
+
+class ApiBaseStationDeviceLogResponse(JsonApiResponsePayload):
+    """Элемент device_logs ответа GET /base-stations/<uuid>/device-logs (ApiDeviceLogsResponse)."""
+
+    id: UUID4
+    date_created: datetime
+
+    bs_id: UUID4 | None = None
+    device_id: UUID4
+
+    device_gateway_id: UUID4 | None = None
+    device_protocol_id: UUID4
+
+    signal_rssi: int | None = None
+    signal_snr: int | None = None
+
+    date_sending: datetime
+
+    is_verified: bool | None = None
+    protocol_type: str | None = None
+    packet_type_name: str | None = None
+    network_id: UUID4 | None = None
+    network_sys_type: str | None = None
+    decrypted_payload: str | None = None
+    raw_payload: str | None = None
+
+    error_message: str | None = None
+    error_type: str | None = None
+
+    device: Dict[str, Any] | None = None
+    external_document_id: UUID4 | None = None
+
+
+class ApiBaseStationDeviceLogsResponse(JsonApiResponsePayload):
+    """Ответ GET /base-stations/<uuid>/device-logs (ApiBsDeviceLogsResponse)."""
+
+    device_logs: List[ApiBaseStationDeviceLogResponse]
+    device_logs_count: int
+    device_count: int

ul_data_logger_api_sdk-3.0.0/data_logger_api_sdk.py

@@ -1,123 +0,0 @@
-import json
-import time
-from datetime import datetime
-from functools import lru_cache
-from typing import List, Type
-from uuid import UUID
-
-from ul_api_utils.internal_api.internal_api import InternalApi
-from ul_api_utils.internal_api.internal_api_response import TPyloadType
-from ul_api_utils.utils.api_method import ApiMethod
-
-from data_logger_api_sdk.data_logger_sdk_config import DataLoggerApiSdkConfig
-from data_logger_api_sdk.types.api_bs_traffic_stats import ApiBsTrafficStatsResponse, ApiDeviceTrafficStatsQuery
-from data_logger_api_sdk.types.api_device_data_history import ApiDeviceDataHistoryBody, ApiDeviceDataHistoryResponse
-from data_logger_api_sdk.types.api_last_bs_data_by_device_macs import ApiDeviceLastBsDataResponse, ApiDeviceMacsListBodyModel
-from data_logger_api_sdk.types.api_packet_types import ApiPacketTypesListResponse
-from data_logger_api_sdk.types.api_protocol_types import ApiProtocolTypesListResponse
-
-
-class DataLoggerApiSdk:
-
-    def __init__(self, config: DataLoggerApiSdkConfig) -> None:
-        self._config = config
-        self._api = InternalApi(entry_point=self._config.api_url, default_auth_token=self._config.api_token)
-
-    @lru_cache(maxsize=None)  # there should not be leaks memory leaks. flake8 just scared inmemory cache ;)
-    def request_payload(
-        self,
-        _: int,
-        method: ApiMethod,
-        endpoint: str,
-        typed_as: Type[TPyloadType],
-        body: str | None,
-        query: str | None = None,
-    ) -> TPyloadType:
-        return (
-            self._api.request(
-                method=method,
-                path=endpoint,
-                json=json.loads(body) if body is not None else None,
-                q=json.loads(query) if query is not None else None,
-            )
-            .typed(typed_as)
-            .check()
-            .payload
-        )
-
-    def _get_cache_post_payload(
-        self,
-        method: ApiMethod,
-        path: str,
-        typed: Type[TPyloadType],
-        body: str | None = None,
-        query: str | None = None,
-    ) -> TPyloadType:
-        ttl_status = round(time.time() / self._config.cache_ttl_s)
-        return self.request_payload(ttl_status, method, path, typed, body, query)  # type: ignore  # Type[TPyloadType] is hashable
-
-    def get_protocol_types_list(self, mac: int) -> List[str]:
-        return self._get_cache_post_payload(
-            ApiMethod.GET,
-            f"/devices/mac/{mac}/logs/protocol-types",
-            ApiProtocolTypesListResponse,
-        ).protocol_types
-
-    def get_packet_types_list(self, mac: int) -> List[str]:
-        return self._get_cache_post_payload(
-            ApiMethod.GET,
-            f"/devices/mac/{mac}/logs/packet-types",
-            ApiPacketTypesListResponse,
-        ).packet_types
-
-    def get_device_data_history(
-        self,
-        period_from: datetime,
-        period_to: datetime,
-        mac: int,
-        protocol_type: str | None = None,
-        packet_type: str | None = None,
-    ) -> List[ApiDeviceDataHistoryResponse]:
-        api_device_history_body = ApiDeviceDataHistoryBody(
-            period_from=period_from,
-            period_to=period_to,
-            mac=mac,
-            protocol_type=protocol_type,
-            packet_type=packet_type,
-        ).model_dump_json()
-        return self._get_cache_post_payload(
-            ApiMethod.POST,
-            "/device-data-history",
-            List[ApiDeviceDataHistoryResponse],  # type: ignore
-            api_device_history_body,
-        )
-
-    def get_last_bs_data_by_device_macs(
-        self,
-        macs: set[int],
-    ) -> List[ApiDeviceLastBsDataResponse]:
-        return self._get_cache_post_payload(
-            ApiMethod.POST,
-            "/devices/last-bs-data",
-            List[ApiDeviceLastBsDataResponse],  # type: ignore
-            ApiDeviceMacsListBodyModel(macs=macs).model_dump_json(),
-        )
-
-    def get_bs_traffic_stats(
-        self,
-        base_station_id: UUID,
-        start_at: datetime,
-        end_at: datetime,
-    ) -> List[ApiBsTrafficStatsResponse]:
-        api_bs_traffic_stats_query = ApiDeviceTrafficStatsQuery(
-            start_at=start_at,
-            end_at=end_at,
-        )
-        return self._get_cache_post_payload(
-            ApiMethod.GET,
-            f"/base-stations/{base_station_id}/traffic-stats",
-            List[ApiBsTrafficStatsResponse],  # type: ignore
-            None,
-            api_bs_traffic_stats_query.model_dump_json(),
-        )
-