espark-core 0.4.9__py3-none-any.whl → 0.5.0__py3-none-any.whl

{espark_core-0.4.9.dist-info → espark_core-0.5.0.dist-info}/METADATA

@@ -1,24 +1,24 @@
 Metadata-Version: 2.4
 Name: espark-core
-Version: 0.4.9
+Version: 0.5.0
 Summary: The core module of the Espark ESP32-based IoT device management framework.
 License: MIT
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiomqtt>=2.4.0
-Requires-Dist: apscheduler>=3.11.1
-Requires-Dist: fastapi>=0.124.4
+Requires-Dist: apscheduler>=3.11.2
+Requires-Dist: fastapi>=0.127.0
 Requires-Dist: packaging>=25.0
 Requires-Dist: slack-sdk==3.39.0
 Requires-Dist: sqlalchemy>=2.0.45
-Requires-Dist: sqlmodel>=0.0.27
-Requires-Dist: uvicorn[standard]>=0.38.0
+Requires-Dist: sqlmodel>=0.0.29
+Requires-Dist: uvicorn[standard]>=0.40.0
 Provides-Extra: dev
-Requires-Dist: aiosqlite==0.22.0; extra == "dev"
+Requires-Dist: aiosqlite==0.22.1; extra == "dev"
 Requires-Dist: autopep8==2.3.2; extra == "dev"
 Requires-Dist: build==1.3.0; extra == "dev"
-Requires-Dist: fastapi-cli[standard-no-fastapi-cloud-cli]==0.0.16; extra == "dev"
+Requires-Dist: fastapi-cli[standard-no-fastapi-cloud-cli]==0.0.20; extra == "dev"
 Requires-Dist: httpx==0.28.1; extra == "dev"
 Requires-Dist: pycodestyle==2.14.0; extra == "dev"
 Requires-Dist: pylint==4.0.4; extra == "dev"

{espark_core-0.4.9.dist-info → espark_core-0.5.0.dist-info}/RECORD

@@ -1,35 +1,41 @@
-espark_core-0.4.9.dist-info/licenses/LICENSE,sha256=wkIXJHYIspOGVvn_ajKyLucpIyw9_pO3QExFcNTCY78,1065
+espark_core-0.5.0.dist-info/licenses/LICENSE,sha256=wkIXJHYIspOGVvn_ajKyLucpIyw9_pO3QExFcNTCY78,1065
 esparkcore/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-esparkcore/constants.py,sha256=v5D_z1nST50FpA5FvpGYz9rk6wngQleCyFU1wtmk58I,417
+esparkcore/constants.py,sha256=2Bmx62j4kykkPhcQ9ygEJ08uyVlykXMNFhpO26-Czlg,417
 esparkcore/data/__init__.py,sha256=abMOPq6jC5qOQCl9j7iPDv8iyjzDF-oVd_gW0la5kL4,45
 esparkcore/data/database.py,sha256=OaJSBDW6Qge-rsKkSIksJXOg3xF_y6LuBew--6uFbG4,532
-esparkcore/data/models/__init__.py,sha256=9YBRwn7R_aovQjT-ZR64fBm7TPs0dsjoq3LzsUTaRtA,124
+esparkcore/data/models/__init__.py,sha256=hJwtKxw02gDB6jot_l8I47AeU2UwT9plrd5haIGB3fw,192
 esparkcore/data/models/device.py,sha256=a1Tfw8xHzDLEiVxANZ-lR2aVaWaWJFa8tZQwHBzDgu0,1135
+esparkcore/data/models/notification.py,sha256=NhkTZbNsY1ljTmVJNrDC68W0Jd2BcACxfWomrgkO4zM,621
 esparkcore/data/models/outbox.py,sha256=r5bgjIbj9H-OsGhE-CWKGRf4Tp88qMvmxPYHNGOApY4,1309
 esparkcore/data/models/telemetry.py,sha256=OfzGqGj2Y1sdK519sSOEXhfuErHoeEdpy5qmJMIc27A,652
+esparkcore/data/models/trigger.py,sha256=3gApG5RHtwIKL_CX_Fx8oqCaLfgYveqzHy5mSmFpWxM,986
 esparkcore/data/models/version.py,sha256=h2O_Owx-exx5tiQiiauCSELkUHDx-QZjiIGqFPybT4M,269
-esparkcore/data/repositories/__init__.py,sha256=R4cFUr137IxhyQVwFaXRHikPkTBE_4nUAAFRchxcohA,248
+esparkcore/data/repositories/__init__.py,sha256=zlTYJ_KKBqkY7KpIi1kJlCG5UA6zXlLm5wK9INLpZQY,358
 esparkcore/data/repositories/base_repository.py,sha256=L5APTp8SczndbWqgJyEqKe-4NQoL_YYOapUN6i572cM,2097
 esparkcore/data/repositories/device_repository.py,sha256=P9KK-Ta9MgMdrnct5hbGEoipPOPrrDQ4wINQnZZ6iZY,1131
+esparkcore/data/repositories/notification_repository.py,sha256=N-bcprhnG6noTdhIzLMBJtCmGeMtnZw2bPx8JdjamW8,205
 esparkcore/data/repositories/outbox_repository.py,sha256=PdPyKq2Km4_7732O6HhA4BlV_zBjYF91GkMltNKUovg,1015
-esparkcore/data/repositories/telemetry_repository.py,sha256=5UBBmY-ugcgP0Xji7cu58_nGt8MWKeHz9DHNVJxk0BY,1116
+esparkcore/data/repositories/telemetry_repository.py,sha256=9wkgE2SU6_fqJMxpnG_IOF_ONxi9qi0coy_gVSJG2q8,2105
+esparkcore/data/repositories/trigger_repository.py,sha256=xHYky1ZAT2H0cLPGTjVbmnH6ZHPgFXzga2SeOx-xSNo,185
 esparkcore/data/repositories/version_repository.py,sha256=QZZX2BpFx1i0oeFJ6j0nZvlZH7cViKU8VERBE8AU3ZY,395
 esparkcore/notifications/__init__.py,sha256=WrdUPsRS0tg2rAhv4aj4eGDekkfAsKjcRPRlT6btzQs,77
 esparkcore/notifications/notifier.py,sha256=d4a8leU-oTwWe7ZTLw-vxfCrYlFnCIvbcXabiXkT6Lc,446
 esparkcore/notifications/slack_notifier.py,sha256=-H-3YYm0CRTV8pZgggrNPJKz6815HTumKvE7VsvvSAA,644
-esparkcore/routers/__init__.py,sha256=K8-S0hugkQT5DB8i8O5YqeRsu9fGfLep6UQzCIpdgGg,131
+esparkcore/routers/__init__.py,sha256=sZv812GJl-JEWJQ7IR1gAQ5BdCf5nTkfbJZXv5jZv_4,225
 esparkcore/routers/base_router.py,sha256=t-x8tYZVzBk9bD__9yaGYhm66glq_oM_lAHn0eplM2M,3902
-esparkcore/routers/device_router.py,sha256=mIBAyTyxl9AF8Os_Sms6Bb0vEvWfljyElbTWEGLo0iU,1172
-esparkcore/routers/telemetry_router.py,sha256=sLO5-oN73IjdGC_ASNif5xmVZHjka_iLv0BKZ_deZP0,1981
+esparkcore/routers/device_router.py,sha256=KM6MI6BaxDbZJaqDPEi6iJYPwnOIujtAFG8J1oGRq3I,2506
+esparkcore/routers/notification_router.py,sha256=vLG99eW-b9UlO9NiV1yZZeqkG4XLVv5Yj5JvHZLP6Dg,411
+esparkcore/routers/telemetry_router.py,sha256=3690D4603gVK3-yaJT-sAVKwhIYEYKxQZpIu84a9flg,2584
+esparkcore/routers/trigger_router.py,sha256=YSNYrLTQYeGToVBOlSK4PtDKpdFpesk-ZnNn_lXu6Ec,366
 esparkcore/routers/version_router.py,sha256=7HYD6sbGWow3DDvK62RXPZu5Qz8DCTTs7wkksQKBq9c,383
 esparkcore/schedules/__init__.py,sha256=v5Wy3Cbt2AnudGMGXv_Cyaa10s6NAmP66rDjcMSvf0o,74
 esparkcore/schedules/outbox.py,sha256=GGANvjkI7w1BdmmVRgKog498ASD_xRN0g8bG6yC_SN4,811
 esparkcore/schedules/scheduler.py,sha256=aYQXImLZ4tW-hRavn3ObuV3lYjmOZD813YkeG1NsYfY,170
 esparkcore/services/__init__.py,sha256=RIZOHBfkWn3HsApdA5rH9EZbbXGq0NfiGoOWDO_JX1k,30
-esparkcore/services/mqtt.py,sha256=EFRVT7QYEpWFhTopS2T6J5O69NWbxeuBQnytCjvd23k,6379
+esparkcore/services/mqtt.py,sha256=5h_mhXhFt11TyhGwNhaY08Y4tttvSTPkiR3veTqpb3A,8972
 esparkcore/utils/__init__.py,sha256=rzuCJUAaQl-yPhM1vcWB_1zVXqtA71ChYP2aM_3UfKk,42
 esparkcore/utils/logging.py,sha256=sRO8uOcPkFH-DwepqLOTS2qGaopXpMdVOjzZL6RpGs4,257
-espark_core-0.4.9.dist-info/METADATA,sha256=kCGaK8PkyR5DMoJCxhwk56RN4sz91l9lJS5CW-bB2xo,6329
-espark_core-0.4.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-espark_core-0.4.9.dist-info/top_level.txt,sha256=hXVyhIPB4aGskFm5queWALxDPhcDkrN7_8vcjwA1iE4,11
-espark_core-0.4.9.dist-info/RECORD,,
+espark_core-0.5.0.dist-info/METADATA,sha256=Ez2PWfUcMCe7__fNBbp9bl0cGAGdPuyqfaL3OXYcNfg,6329
+espark_core-0.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+espark_core-0.5.0.dist-info/top_level.txt,sha256=hXVyhIPB4aGskFm5queWALxDPhcDkrN7_8vcjwA1iE4,11
+espark_core-0.5.0.dist-info/RECORD,,

esparkcore/constants.py

@@ -7,5 +7,5 @@ TOPIC_ACTION       : str = 'espark/action'
 TOPIC_DEVICE       : str = 'espark/device'
 TOPIC_REGISTRATION : str = 'espark/registration'
 TOPIC_TELEMETRY    : str = 'espark/telemetry'
-TOPIC_OTP          : str = 'espark/otp'
+TOPIC_OTA          : str = 'espark/ota'
 TOPIC_CRASH        : str = 'espark/crash'

esparkcore/data/models/__init__.py

@@ -1,4 +1,6 @@
 from .device import Device
+from .notification import Notification
 from .outbox import OutboxEvent
 from .telemetry import Telemetry
+from .trigger import Trigger
 from .version import AppVersion

esparkcore/data/models/notification.py

@@ -0,0 +1,11 @@
+from typing import Dict
+
+from sqlalchemy import Column
+from sqlmodel import SQLModel, Field, JSON
+
+
+class Notification(SQLModel, table=True):
+    id       : int            = Field(primary_key=True, description='Unique identifier for the notification')
+    name     : str            = Field(index=True, unique=True, description='Name of the notification')
+    provider : str            = Field(index=True, description='Notification provider (e.g., Slack, Twilio)')
+    config   : Dict[str, str] = Field(default_factory=dict, sa_column=Column(JSON), description='JSON string of provider-specific configuration parameters')

esparkcore/data/models/trigger.py

@@ -0,0 +1,13 @@
+from typing import Optional
+
+from sqlmodel import Field, SQLModel
+
+
+class Trigger(SQLModel, table=True):
+    id               : str           = Field(primary_key=True, description='Unique identifier for the trigger')
+    name             : str           = Field(index=True, unique=True, description='Name of the trigger')
+    device_id        : Optional[str] = Field(index=True, default=None, description='Identifier of the associated device')
+    data_type        : Optional[str] = Field(index=True, default=None, description='Type of telemetry data the trigger monitors (e.g., temperature, humidity)')
+    condition        : str           = Field(description='Condition to evaluate (e.g., ">", "<=")')
+    value            : int           = Field(description='Value to compare against for the trigger condition')
+    notification_ids : Optional[str] = Field(default=None, description='Comma-separated list of associated notification IDs to be sent when the trigger condition is met')

esparkcore/data/repositories/__init__.py

@@ -1,5 +1,7 @@
 from .base_repository import AsyncRepository
 from .device_repository import DeviceRepository
+from .notification_repository import NotificationRepository
 from .outbox_repository import OutboxRepository
 from .telemetry_repository import TelemetryRepository
+from .trigger_repository import TriggerRepository
 from .version_repository import AppVersionRepository

esparkcore/data/repositories/notification_repository.py

@@ -0,0 +1,7 @@
+from ..models import Notification
+from .base_repository import AsyncRepository
+
+
+class NotificationRepository(AsyncRepository[Notification]):
+    def __init__(self):
+        super().__init__(Notification)

esparkcore/data/repositories/telemetry_repository.py

@@ -2,7 +2,7 @@ from typing import Optional, Sequence
 
 from sqlalchemy import ColumnElement
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import and_
+from sqlmodel import and_, select
 
 from ..models import Telemetry
 from .base_repository import AsyncRepository
@@ -23,3 +23,26 @@ class TelemetryRepository(AsyncRepository[Telemetry]):
             order_by = Telemetry.timestamp.desc()
 
         return await super().list(session, *conditions, offset=offset, order_by=order_by, limit=limit)
+
+    async def search(self, session: AsyncSession, device_id: str = None, data_type: str = None, condition: str = None, value: int = None):
+        query = select(self.model)
+
+        if device_id is not None:
+            query = query.where(Telemetry.device_id == device_id)
+
+        if data_type is not None:
+            query = query.where(Telemetry.data_type == data_type)
+
+        if condition is not None and value is not None:
+            if condition == '<':
+                query = query.where(Telemetry.value < value)
+            elif condition == '<=':
+                query = query.where(Telemetry.value <= value)
+            elif condition == '==':
+                query = query.where(Telemetry.value == value)
+            elif condition == '>=':
+                query = query.where(Telemetry.value >= value)
+            elif condition == '>':
+                query = query.where(Telemetry.value > value)
+
+        return (await session.execute(query)).scalars().all()

esparkcore/data/repositories/trigger_repository.py

@@ -0,0 +1,7 @@
+from ..models import Trigger
+from .base_repository import AsyncRepository
+
+
+class TriggerRepository(AsyncRepository[Trigger]):
+    def __init__(self):
+        super().__init__(Trigger)

esparkcore/routers/__init__.py

@@ -1,3 +1,5 @@
 from .device_router import DeviceRouter
+from .notification_router import NotificationRouter
 from .telemetry_router import TelemetryRouter
+from .trigger_router import TriggerRouter
 from .version_router import AppVersionRouter

esparkcore/routers/device_router.py

@@ -2,11 +2,12 @@ from json import dumps
 from os import getenv
 
 from aiomqtt import Client
+from fastapi import Depends, Query, Response
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from ..constants import ENV_MQTT_HOST, ENV_MQTT_PORT, TOPIC_DEVICE
 from ..data.models import Device
-from ..data.repositories import DeviceRepository
+from ..data.repositories import DeviceRepository, TelemetryRepository
 from ..utils import log_debug
 from .base_router import BaseRouter
 
@@ -27,3 +28,30 @@ class DeviceRouter(BaseRouter):
         await super()._after_update(entity, session)
 
         await self._publish_update(entity)
+
+    def _setup_routes(self) -> None:
+        @self.router.get('/all')
+        async def list_all(response: Response, session: AsyncSession = Depends(BaseRouter._get_session), offset: int = Query(None, ge=0), limit: int = Query(None, ge=1, le=100)):
+            response.headers['X-Total-Count'] = str(await self.repo.count(session))
+
+            devices                = await self.repo.list(session, offset=offset, limit=limit)
+            devices_with_telemetry = []
+            telemetry_repo         = TelemetryRepository()
+
+            for device in devices:
+                battery = await telemetry_repo.get_latest_for_device(session, device.id, 'battery')
+
+                devices_with_telemetry.append({
+                    'id'           : device.id,
+                    'display_name' : device.display_name,
+                    'app_name'     : device.app_name,
+                    'app_version'  : device.app_version,
+                    'capabilities' : device.capabilities,
+                    'parameters'   : device.parameters,
+                    'last_seen'    : device.last_seen,
+                    'battery'      : battery.value if battery else None,
+                })
+
+            return devices_with_telemetry
+
+        super()._setup_routes()

esparkcore/routers/notification_router.py

@@ -0,0 +1,10 @@
+from ..data.models import Notification
+from ..data.repositories import NotificationRepository
+from .base_router import BaseRouter
+
+
+class NotificationRouter(BaseRouter):
+    def __init__(self, repo: NotificationRepository = None) -> None:
+        self.repo : NotificationRepository = repo or NotificationRepository()
+
+        super().__init__(Notification, self.repo, '/api/v1/notifications', ['notification'])

esparkcore/routers/telemetry_router.py

@@ -3,6 +3,7 @@ from typing import Sequence
 
 from fastapi import Depends, Query, Response
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import and_
 
 from ..data.models import Telemetry
 from ..data.repositories import DeviceRepository, TelemetryRepository
@@ -16,6 +17,15 @@ class TelemetryRouter(BaseRouter):
         super().__init__(Telemetry, self.repo, '/api/v1/telemetry', ['telemetry'])
 
     def _setup_routes(self) -> None:
+        @self.router.get('/history', response_model=Sequence[Telemetry])
+        async def list_history(response: Response, session: AsyncSession = Depends(BaseRouter._get_session), device_id: int = Query(..., ge=1), offset: int = Query(..., min=0)) -> Sequence[Telemetry]:
+            from_date = datetime.now(timezone.utc) - timedelta(seconds=offset)
+            results   = await self.repo.list(session, and_(Telemetry.device_id == device_id, Telemetry.timestamp >= from_date))
+
+            response.headers['X-Total-Count'] = str(len(results))
+
+            return results
+
         @self.router.get('/recent', response_model=Sequence[Telemetry])
         async def list_recent(response: Response, session: AsyncSession = Depends(BaseRouter._get_session), offset: int = Query(..., min=0)) -> Sequence[Telemetry]:
             from_date   = datetime.now(timezone.utc) - timedelta(seconds=offset)

esparkcore/routers/trigger_router.py

@@ -0,0 +1,10 @@
+from ..data.models import Trigger
+from ..data.repositories import TriggerRepository
+from .base_router import BaseRouter
+
+
+class TriggerRouter(BaseRouter):
+    def __init__(self, repo: TriggerRepository = None) -> None:
+        self.repo : TriggerRepository = repo or TriggerRepository()
+
+        super().__init__(Trigger, self.repo, '/api/v1/triggers', ['trigger'])

esparkcore/services/mqtt.py

@@ -7,23 +7,26 @@ from uuid import getnode
 from aiomqtt import Client, MqttError
 from packaging.version import Version
 
-from ..constants import ENV_MQTT_HOST, ENV_MQTT_PORT, TOPIC_CRASH, TOPIC_OTP, TOPIC_REGISTRATION, TOPIC_TELEMETRY
+from ..constants import ENV_MQTT_HOST, ENV_MQTT_PORT, TOPIC_CRASH, TOPIC_OTA, TOPIC_REGISTRATION, TOPIC_TELEMETRY
 from ..data import async_session
 from ..data.models import AppVersion, Device, Telemetry
-from ..data.repositories import AppVersionRepository, DeviceRepository, TelemetryRepository
+from ..data.repositories import AppVersionRepository, DeviceRepository, NotificationRepository, TelemetryRepository, TriggerRepository
+from ..notifications import SlackNotifier
 from ..utils import log_debug, log_error
 
 MQTT_RETRY_DELAY: int = 5
 
 
 class MQTTManager:
-    def __init__(self, version_repo: AppVersionRepository = None, device_repo: DeviceRepository = None, telemetry_repo: TelemetryRepository = None):
-        self.mqtt_host      : str                  = getenv(ENV_MQTT_HOST, 'localhost')
-        self.mqtt_port      : int                  = int(getenv(ENV_MQTT_PORT, '1883'))
-        self.version_repo   : AppVersionRepository = version_repo if version_repo else AppVersionRepository()
-        self.device_repo    : DeviceRepository     = device_repo if device_repo else DeviceRepository()
-        self.telemetry_repo : TelemetryRepository  = telemetry_repo if telemetry_repo else TelemetryRepository()
-        self.queue          : Queue                = Queue()
+    def __init__(self, version_repo: AppVersionRepository = None, device_repo: DeviceRepository = None, notification_repo: NotificationRepository = None, telemetry_repo: TelemetryRepository = None, trigger_repo: TriggerRepository = None) -> None:
+        self.mqtt_host         : str                  = getenv(ENV_MQTT_HOST, 'localhost')
+        self.mqtt_port         : int                  = int(getenv(ENV_MQTT_PORT, '1883'))
+        self.version_repo      : AppVersionRepository = version_repo if version_repo else AppVersionRepository()
+        self.device_repo       : DeviceRepository     = device_repo if device_repo else DeviceRepository()
+        self.notification_repo : NotificationRepository = notification_repo if notification_repo else NotificationRepository()
+        self.telemetry_repo    : TelemetryRepository  = telemetry_repo if telemetry_repo else TelemetryRepository()
+        self.trigger_repo      : TriggerRepository    = trigger_repo if trigger_repo else TriggerRepository()
+        self.queue             : Queue                = Queue()
 
     async def _handle_registration(self, device_id: str, payload: dict) -> None:
         try:
@@ -61,11 +64,11 @@ class MQTTManager:
                     log_debug(f'Device {device_id} is running an outdated version ({current_version} < {latest_version.version})')
 
                     async with Client(self.mqtt_host, self.mqtt_port, identifier=f'espark-core-{hex(getnode())}') as client:
-                        await client.publish(f'{TOPIC_OTP}/{device_id}', dumps({
+                        await client.publish(f'{TOPIC_OTA}/{device_id}', dumps({
                             'device_id'    : device_id,
                             'app_name'     : payload['app_name'],
                             'app_version'  : latest_version.version,
-                            'download_url' : None,
+                            'download_url' : f'/downloads/{payload["app_name"]}/{latest_version.version}',
                         }), qos=1)
         # pylint: disable=broad-exception-caught
         except Exception as e:
@@ -88,6 +91,40 @@ class MQTTManager:
         except Exception as e:
             log_error(e)
 
+        await self._handle_triggers(device_id, payload.get('data_type'), payload.get('value'))
+
+    async def _handle_triggers(self, device_id: str, data_type: str, value: int) -> None:
+        async with async_session() as session:
+            triggers = await self.trigger_repo.list(session)
+            for trigger in triggers:
+                matched_device_id = trigger.device_id is None or trigger.device_id == device_id
+                matched_data_type = trigger.data_type is None or trigger.data_type == data_type
+                if matched_device_id and matched_data_type:
+                    condition_met = False
+                    if trigger.condition is None:
+                        condition_met = True
+                    elif trigger.condition == '==' and value == trigger.value:
+                        condition_met = True
+                    elif trigger.condition == '>' and value > trigger.value:
+                        condition_met = True
+                    elif trigger.condition == '>=' and value >= trigger.value:
+                        condition_met = True
+                    elif trigger.condition == '<' and value < trigger.value:
+                        condition_met = True
+                    elif trigger.condition == '<=' and value <= trigger.value:
+                        condition_met = True
+
+                    if condition_met:
+                        log_debug(f'Trigger {trigger.name} activated for device {device_id} with data type {data_type} and value {value}')
+
+                        notifications = await self.notification_repo.list(session)
+                        for notification in notifications:
+                            if trigger.notification_ids.index(str(notification.id)) != -1:
+                                log_debug(f'Sending notification {notification.name} for trigger {trigger.name}')
+
+                                if notification.provider == 'Slack':
+                                    await SlackNotifier(notification.config['slack_token'], notification.config['slack_channel']).notify(device_id, data_type, value)
+
     async def _process_queue(self) -> None:
         while True:
             topic, payload = await self.queue.get()