bedger 0.0.6__tar.gz → 0.0.7__tar.gz

{bedger-0.0.6 → bedger-0.0.7}/PKG-INFO

@@ -1,11 +1,10 @@
 Metadata-Version: 2.1
 Name: bedger
-Version: 0.0.6
+Version: 0.0.7
 Summary: 
 Author: Henk van den Brink
-Requires-Python: >=3.8.1,<4.0.0
+Requires-Python: >=3.8, !=2.7.*, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*, !=3.6.*, !=3.7.*
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12

{bedger-0.0.6 → bedger-0.0.7}/pyproject.toml

@@ -1,13 +1,13 @@
 [tool.poetry]
 name = "bedger"
-version = "0.0.6"
+version = "0.0.7"
 description = ""
 authors = ["Henk van den Brink"]
 readme = "README.md"
 packages = [{include = "bedger", from = "src"}]
 
 [tool.poetry.dependencies]
-python = "^3.8.1,<=4.0.0"
+python = ">=3.8.1,<3.9.0 || >3.9.0,<3.9.1 || >3.9.1,<4.0.0"
 
 [tool.isort]
 profile = "black"

bedger-0.0.7/src/bedger/edge/client.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import socket
+import logging
+from http.client import HTTPConnection
+from typing import Any
+
+from .config import Config
+from .entities.device_event import DeviceEvent
+from . import entities
+from .errors import (
+    ConnectionError,
+    SendError,
+    HTTPRequestError,
+    JSONSerializationError,
+    map_socket_error,
+)
+
+logger = logging.getLogger("bedger.edge.client")
+
+
+class UnixSocketHTTPConnection(HTTPConnection):
+    """HTTPConnection subclass that communicates via UNIX domain sockets."""
+
+    def __init__(self, unix_socket_path: str):
+        super().__init__("localhost")  # dummy host
+        self.unix_socket_path = unix_socket_path
+
+    def connect(self):
+        """Override to connect to a UNIX socket instead of TCP."""
+        try:
+            self.sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+            self.sock.connect(self.unix_socket_path)
+        except Exception as e:
+            raise map_socket_error(e, self.unix_socket_path)
+
+
+class Client:
+    """
+    Bedger Edge Client that communicates with the local agent's HTTP API
+    over a UNIX socket. Matches BedgerConnection interface.
+    """
+
+    def __init__(self, config: Config = Config()):
+        self._config = config
+        self._connection: UnixSocketHTTPConnection | None = None
+
+    def __enter__(self) -> Client:
+        self._connect()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self._disconnect()
+
+    def _connect(self) -> None:
+        socket_path = self._config.socket_path
+        logger.info(f"Connecting to Bedger Edge API at {socket_path}")
+        try:
+            self._connection = UnixSocketHTTPConnection(socket_path)
+        except Exception as e:
+            raise ConnectionError(socket_path, e)
+
+    def _disconnect(self) -> None:
+        if self._connection:
+            try:
+                self._connection.close()
+                logger.info("Connection closed")
+            except Exception as e:
+                logger.warning(f"Error closing connection: {e}")
+            finally:
+                self._connection = None
+
+    def send_event(
+        self, event_type: str, severity: entities.Severity, payload: dict[str, Any]
+    ) -> None:
+        """Send a DeviceEvent to /device/events."""
+        if not self._connection:
+            raise ConnectionError(self._config.socket_path)
+
+        try:
+            event = DeviceEvent(event_type=event_type, severity=severity, details=payload)
+            serialized = event.model_dump_json(by_alias=True).encode("utf-8")
+        except Exception as e:
+            raise JSONSerializationError(f"Failed to serialize DeviceEvent {event_type}") from e
+
+        try:
+            self._connection.request(
+                "POST",
+                "/device/events",
+                body=serialized,
+                headers={"Content-Type": "application/json"},
+            )
+
+            response = self._connection.getresponse()
+            response_data = response.read().decode("utf-8")
+
+            if response.status != 200:
+                raise HTTPRequestError(response.status, response_data)
+
+            logger.info(f"Event sent successfully: {response_data}")
+        except HTTPRequestError:
+            raise
+        except Exception as e:
+            raise SendError("Failed to send DeviceEvent", e)

bedger-0.0.7/src/bedger/edge/entities/__init__.py

@@ -0,0 +1,5 @@
+from .device_event import DeviceEvent
+from .severity import Severity
+
+
+__all__ = [DeviceEvent, Severity]

bedger-0.0.6/src/bedger/edge/entities/message.py → bedger-0.0.7/src/bedger/edge/entities/device_event.py

@@ -1,10 +1,18 @@
-from typing import Dict, Annotated
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Dict, Any, Annotated
 from pydantic import BaseModel, Field, field_validator, field_serializer
 from .severity import Severity
-import json
 
 
-class Message(BaseModel):
+class DeviceEvent(BaseModel):
+    """
+    Represents a stored or transmitted device event.
+    This model is compatible with the local /device/events API.
+    """
+
     event_type: Annotated[
         str,
         Field(
@@ -13,11 +21,14 @@ class Message(BaseModel):
         ),
     ]
     severity: Severity
-    details: Annotated[Dict, Field(description="Details of the message as a JSON serializable dictionary")]
+    details: Annotated[
+        Dict[str, Any],
+        Field(description="Event-specific details, must be JSON serializable"),
+    ]
 
     @field_validator("details")
     @classmethod
-    def validate_details(cls, value: Dict) -> Dict:
+    def validate_details(cls, value: Dict[str, Any]) -> Dict[str, Any]:
         try:
             json.dumps(value)
         except TypeError:
@@ -27,3 +38,7 @@ class Message(BaseModel):
     @field_serializer("severity")
     def serialize_severity(self, severity: Severity) -> str:
         return severity.value
+
+    @field_serializer("timestamp")
+    def serialize_timestamp(self, timestamp: datetime) -> str:
+        return timestamp.isoformat()

bedger-0.0.7/src/bedger/edge/errors.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+import socket
+
+
+class BedgerError(Exception):
+    """Base class for all Bedger-related exceptions."""
+    pass
+
+
+# --- Configuration and Initialization ---
+
+
+class ConfigurationError(BedgerError):
+    """Raised when configuration values are missing, invalid, or inconsistent."""
+    def __init__(self, message: str, path: str | None = None):
+        self.path = path
+        super().__init__(f"{message}{f' (path: {path})' if path else ''}")
+
+
+class EnvironmentError(BedgerError):
+    """Raised when the environment or system setup prevents operation (permissions, missing dirs, etc.)."""
+    pass
+
+
+# --- Networking / Socket Communication ---
+
+
+class ConnectionError(BedgerError):
+    """Raised when connection to a UNIX or network socket fails."""
+    def __init__(self, socket_path: str, original_error: Exception | None = None):
+        self.socket_path = socket_path
+        self.original_error = original_error
+        super().__init__(f"Failed to connect to socket at {socket_path}: {original_error}")
+
+
+class SendError(BedgerError):
+    """Raised when sending data to Bedger Edge fails."""
+    def __init__(self, message: str, original_error: Exception | None = None):
+        self.original_error = original_error
+        super().__init__(f"{message}{f' ({original_error})' if original_error else ''}")
+
+
+class ReceiveError(BedgerError):
+    """Raised when receiving acknowledgment or response fails."""
+    def __init__(self, message: str, original_error: Exception | None = None):
+        self.original_error = original_error
+        super().__init__(f"{message}{f' ({original_error})' if original_error else ''}")
+
+
+# --- HTTP API Errors ---
+
+
+class HTTPRequestError(BedgerError):
+    """Raised for failed HTTP requests to the local Bedger Edge API."""
+    def __init__(self, status_code: int, response: str):
+        self.status_code = status_code
+        self.response = response
+        super().__init__(f"Bedger API returned HTTP {status_code}: {response}")
+
+
+class JSONSerializationError(BedgerError):
+    """Raised when JSON encoding or decoding fails."""
+    pass
+
+
+# --- Certificates / Security ---
+
+
+class CaCertificateError(BedgerError):
+    """Raised when fetching or validating a CA certificate fails."""
+    pass
+
+
+class AuthenticationError(BedgerError):
+    """Raised when authentication or provisioning fails."""
+    pass
+
+
+# --- Device Twin / State Sync ---
+
+
+class DeviceTwinError(BedgerError):
+    """Raised when device twin synchronization or persistence fails."""
+    pass
+
+
+class DeviceEventError(BedgerError):
+    """Raised when processing or storing device events fails."""
+    pass
+
+
+# --- Utilities ---
+
+
+def map_socket_error(err: Exception, socket_path: str) -> BedgerError:
+    """Map low-level socket errors to Bedger-friendly errors."""
+    if isinstance(err, FileNotFoundError):
+        return ConnectionError(socket_path, original_error=err)
+    elif isinstance(err, PermissionError):
+        return EnvironmentError(f"Permission denied on socket {socket_path}")
+    elif isinstance(err, socket.timeout):
+        return ConnectionError(socket_path, original_error=err)
+    else:
+        return BedgerError(str(err))

bedger-0.0.6/src/bedger/edge/connection.py

@@ -1,65 +0,0 @@
-from __future__ import annotations
-
-import json
-import socket
-from .config import Config
-from . import entities
-import logging
-
-
-logger = logging.getLogger("bedger.edge.connection")
-
-
-class BedgerConnection:
-    def __init__(self, config: Config = Config()):
-        self._config = config
-
-        self._socket = None
-
-    def __enter__(self) -> BedgerConnection:
-        self._connect()
-        return self
-
-    def _connect(self) -> None:
-        logger.info(f"Connecting to socket at {self._config.socket_path}")
-        try:
-            self._socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-            self._socket.connect(self._config.socket_path)
-            logger.info("Connected to socket")
-        except Exception as e:
-            logger.error(f"Error connecting to socket: {e}")
-            raise e
-
-    def __exit__(self, exc_type, exc_value, traceback) -> None:
-        self._socket.close()
-
-    def send_event(self, event_type, severity, payload):
-        message = entities.Message(
-            event_type=event_type,
-            severity=severity,
-            details=payload,
-        )
-
-        try:
-            logger.debug("Sending message")
-            self._socket.sendall(json.dumps(message).encode())
-
-            ack = self._socket.recv(1024)
-            logger.info(f"Received acknowledgment: {ack.decode()}")
-        except Exception as e:
-            logger.error(f"Error sending message: {e}")
-            raise e
-
-
-# Example usage
-if __name__ == "__main__":
-    import time
-
-    connection = BedgerConnection()
-
-    with connection:
-        for i in range(5):
-            connection.send_event(
-                event_type="TestEvent", severity=entities.Severity.INFO, payload={"message": f"Test message {i}"}
-            )
-            time.sleep(1)

bedger-0.0.6/src/bedger/edge/entities/__init__.py

@@ -1,5 +0,0 @@
-from .message import Message
-from .severity import Severity
-
-
-__all__ = [Message, Severity]