openmodule 14.3.0__tar.gz → 15.0.0__tar.gz

{openmodule-14.3.0/openmodule.egg-info → openmodule-15.0.0}/PKG-INFO

@@ -1,23 +1,46 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: openmodule
-Version: 14.3.0
+Version: 15.0.0
 Summary: Libraries for developing the arivo openmodule
 Home-page: https://gitlab.com/arivo-public/device-python/openmodule.git
 Author: ARIVO
 Author-email: support@arivo.co
 License: GNU General Public License v2 (GPLv2)
 Keywords: arivo openmodule
-Platform: UNKNOWN
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v2 (GPLv2)
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown; charset=UTF-8
+License-File: LICENSE
+Requires-Dist: pydantic~=2.0
+Requires-Dist: sentry-sdk~=2.19.0
+Requires-Dist: orjson<4,>=3.4.7
+Requires-Dist: pyzmq~=26.2
+Requires-Dist: pyyaml<7,>=5.0
+Requires-Dist: editdistance>=0.8.1
+Requires-Dist: sqlalchemy~=2.0.0
+Requires-Dist: alembic<2,>=1.5.4
+Requires-Dist: requests<3,>=2.22
+Requires-Dist: python-dateutil>=2.7.2
+Requires-Dist: python-dotenv~=0.15
+Requires-Dist: arivo-settings_models~=2.2
 Provides-Extra: test
+Requires-Dist: openmodule_test; extra == "test"
 Provides-Extra: commands
-License-File: LICENSE
+Requires-Dist: openmodule_commands; extra == "commands"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 # OpenModule V2
 
@@ -130,5 +153,3 @@ pip install -e <path_to_openmodule_root>/openmodule_commands/
 
 - [Openmodule Commands](docs/commands.md)
 
-
-

{openmodule-14.3.0 → openmodule-15.0.0}/openmodule/alert.py

@@ -1,6 +1,6 @@
 import logging
 import threading
-from typing import List, Dict, Optional, TYPE_CHECKING
+from typing import TYPE_CHECKING
 
 from openmodule.models.alert import AlertHandleType, AlertMessage, AlertStatus
 
@@ -9,7 +9,7 @@ if TYPE_CHECKING:
 
 
 class AlertHandler(object):
-    _alerts: List[Dict]
+    _alerts: list[dict]
 
     def __init__(self, core: 'OpenModuleCore'):
         self._alerts = []
@@ -42,8 +42,8 @@ class AlertHandler(object):
         return False
 
     def get_or_add_alert_id(self, alert_type: str, handle_type: AlertHandleType, *,
-                            package_name: Optional[str] = None, version: Optional[str] = None,
-                            always_send_alert: Optional[bool] = None, source: str = ""):
+                            package_name: str | None = None, version: str | None = None,
+                            always_send_alert: bool | None = None, source: str = ""):
         """Define an alert with its name parameters
 
         Args:
@@ -78,7 +78,7 @@ class AlertHandler(object):
             self._alerts.append(alert)
             return alert["id"]
 
-    def send_with_alert_id(self, alert_id: int, status: AlertStatus, meta: Dict, value: Optional[float] = None):
+    def send_with_alert_id(self, alert_id: int, status: AlertStatus, meta: dict, value: float | None = None):
         """ Send a status message on the given alert with the corresponding meta/kwarg arguments
             Returns True if alert was send else False"""
         assert status in [AlertStatus.error, AlertStatus.ok, AlertStatus.offline]
@@ -93,9 +93,9 @@ class AlertHandler(object):
         return self._send_message(alert_id, status_dict)
 
     def send(self, alert_type: str, handle_type: AlertHandleType, *,
-             package_name: Optional[str] = None, version: Optional[str] = None,
-             always_send_alert: Optional[bool] = None, status: AlertStatus = AlertStatus.error,
-             meta: Optional[Dict] = None, value: Optional[float] = None, source: str = ""):
+             package_name: str | None = None, version: str | None = None,
+             always_send_alert: bool | None = None, status: AlertStatus = AlertStatus.error,
+             meta: dict | None = None, value: float | None = None, source: str = ""):
 
         """Sends an alert to the device serve
 

{openmodule-14.3.0 → openmodule-15.0.0}/openmodule/config.py

@@ -1,14 +1,14 @@
 import builtins
 import functools
 import glob
-import importlib.util
+import importlib
 import inspect
 import logging
 import os
 import warnings
 from contextlib import contextmanager
 from socket import gethostname
-from typing import Optional, Type, TypeVar
+from typing import TypeVar
 
 import yaml
 from pydantic import ValidationError
@@ -49,7 +49,7 @@ def bool(key: str, default: bool = False) -> bool:
     return val in ["T", "TRUE", "1", "Y", "YES", "J", "JA", "ON"]
 
 
-def get(key: str, default: Optional[str] = "") -> str:
+def get(key: str, default: str | None = "") -> str:
     return os.environ.get(key, default)
 
 
@@ -213,7 +213,7 @@ def config_yaml_path():
     return yaml_path
 
 
-def yaml(model: Type[YamlType], path: str = None) -> YamlType:
+def yaml(model: type[YamlType], path: str | None = None) -> YamlType:
     yaml_path = path or config_yaml_path()
 
     try:
@@ -221,7 +221,7 @@ def yaml(model: Type[YamlType], path: str = None) -> YamlType:
             import yaml
             with open(yaml_path, "r") as f:
                 a = yaml.load(f, SafeLoaderIgnoreUnknown)
-                return model.parse_obj(a or {})
+                return model.model_validate(a or {})
         else:
             return model()
     except ValidationError as e:

{openmodule-14.3.0 → openmodule-15.0.0}/openmodule/connection_status.py

@@ -1,41 +1,40 @@
 import logging
 import threading
 import time
-from enum import Enum
-from typing import Optional, Set
+from enum import StrEnum
 
 from openmodule import sentry
 from openmodule.dispatcher import MessageDispatcher
 from openmodule.models.base import ZMQMessage, OpenModuleModel
 
 
-class ConnectionStatus(Enum):
+class ConnectionStatus(StrEnum):
     startup = "startup"
     online = "online"
     shutdown = "shutdown"
     offline = "offline"
 
 
-class BridgeStatus(str, Enum):
+class BridgeStatus(StrEnum):
     online = "online"
     offline = "offline"
 
 
 class ConnectionStatusMessage(ZMQMessage):
     connected: ConnectionStatus
-    bridge_status: Optional[BridgeStatus]
+    bridge_status: BridgeStatus | None = None
     type: str = "connection_status"
 
 
 class ConnectionRPCResponse(OpenModuleModel):
     connected: ConnectionStatus
-    bridge_status: Optional[BridgeStatus]
+    bridge_status: BridgeStatus | None = None
 
 
 class ConnectionStatusListener:
     def __init__(self, dispatcher: MessageDispatcher, rpc_client):
         self._log = logging.getLogger(self.__class__.__name__)
-        self._status: Optional[ConnectionRPCResponse] = None
+        self._status: ConnectionRPCResponse | None = None
         self._previous_status: ConnectionRPCResponse = ConnectionRPCResponse(connected=ConnectionStatus.shutdown)
         self._changed = threading.Condition(threading.Lock())
         self.last_changed_time = 0.0
@@ -44,7 +43,7 @@ class ConnectionStatusListener:
         self.rpc_client = rpc_client
         self._listener = dispatcher.register_handler("connection_internal", ConnectionStatusMessage,
                                                      self._process_connection_status)
-        self._got_change_ids: Set[str] = set()
+        self._got_change_ids: set[str] = set()
         self._got_change_ids_lock = threading.Lock()
 
     def wait_for_change(self, timeout: float = None) -> bool:
@@ -115,7 +114,7 @@ class ConnectionStatusListener:
                 self._status = ConnectionRPCResponse(connected=ConnectionStatus.shutdown)
                 return self._status
 
-    def _set(self, status: ConnectionStatus, bridge_status: Optional[BridgeStatus] = None):
+    def _set(self, status: ConnectionStatus, bridge_status: BridgeStatus | None = None):
         if not self._status or status != self._status.connected or \
                 (bridge_status and bridge_status != self._status.bridge_status):
             self._previous_status = self._status or self._previous_status  # initial status is None

{openmodule-14.3.0 → openmodule-15.0.0}/openmodule/core.py

@@ -7,7 +7,6 @@ import warnings
 from concurrent.futures.thread import ThreadPoolExecutor
 
 import zmq
-from typing import Optional
 
 from openmodule import sentry
 from openmodule.alert import AlertHandler
@@ -65,7 +64,7 @@ class OpenModuleCore(threading.Thread):
         super().start()
         self.internal_thread.start()
 
-    def join(self, timeout: Optional[float] = None) -> None:
+    def join(self, timeout: float | None = None) -> None:
         super().join(timeout)
         self.internal_thread.join(timeout)
 
@@ -97,7 +96,6 @@ class OpenModuleCore(threading.Thread):
     @sentry.trace(op="topic.send")
     def publish(self, message: ZMQMessage, topic: str):
         assert isinstance(topic, str), "topic must be a string"
-
         with self.pub_lock:
             message.publish_on_topic(self.pub_socket, topic)
 
@@ -109,7 +107,7 @@ class OpenModuleCore(threading.Thread):
         self.context.term()
 
 
-_core_thread: Optional[OpenModuleCore] = None
+_core_thread: OpenModuleCore | None = None
 
 
 def sigterm_handler(*_):
@@ -137,7 +135,7 @@ def print_environment(core: OpenModuleCore):
 
 
 def init_openmodule(config, *, dsn: str = None, sentry=None, logging=True, dsgvo=True,
-                    health_handler: Optional[HealthHandlerType] = None,
+                    health_handler: HealthHandlerType | None = None,
                     context=None, database=False, catch_sigterm=True,
                     dispatcher_max_threads=1, wait_for_broker=True, **sentry_kwargs) -> OpenModuleCore:
     if health_handler:
@@ -227,8 +225,7 @@ def shutdown_openmodule():
             os._exit(99)
 
     if not (current_core.config.TESTING or current_core.config.DEBUG):
-        last_will_thread = threading.Thread(target=last_will)
-        last_will_thread.setDaemon(True)
+        last_will_thread = threading.Thread(target=last_will, daemon=True)
         last_will_thread.start()
 
     current_core.shutdown()

{openmodule-14.3.0 → openmodule-15.0.0}/openmodule/database/custom_types.py

@@ -3,30 +3,25 @@ from datetime import datetime
 import orjson
 from sqlalchemy import DateTime
 from sqlalchemy import VARCHAR
-from sqlalchemy.sql.visitors import VisitableType
 from sqlalchemy.types import TypeDecorator
 
 
-class MetaOptions(VisitableType):
+class CustomTypeImportRegistration(type):
     """
-    this behaves similarly to django's meta classes, but without any edge cases covered
-    it is used for simple single inheritance without anything special in the alert type
-    and package info classes
+    This metaclass is used to register custom types with their module names.
+    This is used in generating alembic migrations.
     """
-
     def __new__(cls, name, bases, dct):
         x = super().__new__(cls, name, bases, dct)
 
-        # EventModel
         if len(bases) == 1:
             if not getattr(bases[0], "_registry", None):
                 setattr(bases[0], "_registry", dict())
-
             bases[0]._registry[x] = x.__module__
         return x
 
 
-class CustomType(TypeDecorator, metaclass=MetaOptions):
+class CustomType(TypeDecorator, metaclass=CustomTypeImportRegistration):
     @classmethod
     def custom_import(cls, obj):
         for custom, mod in cls._registry.items():
@@ -37,6 +32,7 @@ class CustomType(TypeDecorator, metaclass=MetaOptions):
 
 class TZDateTime(CustomType):
     impl = DateTime
+    cache_ok = True
 
     def process_bind_param(self, value, dialect):
         if value is not None:
@@ -48,6 +44,7 @@ class TZDateTime(CustomType):
 
 class JSONEncodedDict(CustomType):
     impl = VARCHAR
+    cache_ok = True
 
     def process_bind_param(self, value, dialect):
         if value is not None:

{openmodule-14.3.0 → openmodule-15.0.0}/openmodule/database/env.py

@@ -1,7 +1,7 @@
 from logging.config import fileConfig
 
 from alembic import context
-from sqlalchemy import engine_from_config
+from sqlalchemy import engine_from_config, text
 from sqlalchemy import pool
 
 from openmodule.database.custom_types import CustomType
@@ -55,7 +55,7 @@ def run_migrations_online():
         with context.begin_transaction():
             context.run_migrations()
 
-        connection.execute("PRAGMA foreign_keys=ON")
+        connection.execute(text("PRAGMA foreign_keys=ON"))
 
 
 if context.is_offline_mode():

{openmodule-14.3.0 → openmodule-15.0.0}/openmodule/database/migration.py

@@ -1,4 +1,3 @@
-import datetime
 import os
 import shutil
 import sys
@@ -11,9 +10,10 @@ from alembic.config import Config
 from alembic.operations import Operations, MigrateOperation
 from alembic.runtime.migration import MigrationContext
 
-from sqlalchemy import MetaData, DateTime
+from sqlalchemy import MetaData, DateTime, inspect, text
 from sqlalchemy.engine import Engine
-from sqlalchemy.engine.reflection import Inspector
+
+from openmodule.utils.misc_functions import utcnow
 
 
 @Operations.register_operation("pre_upgrade")
@@ -22,7 +22,7 @@ class PreUpgradeOp(MigrateOperation):
     def pre_upgrade(cls, operations, **kw):
         migration_context: MigrationContext = operations.migration_context
         basename, _ = os.path.splitext(os.path.basename(migration_context.connection.engine.url.database))
-        timestamp = datetime.datetime.utcnow().strftime('%Y%m%d%H%M%S')
+        timestamp = utcnow().strftime('%Y%m%d%H%M%S')
         migration_revision = migration_context.get_current_revision()
         filename = f"{basename}_{timestamp}_{migration_revision}.sqlite3.backup"
 
@@ -78,12 +78,12 @@ def pre_upgrade(operations, operation):
     # NOTE: This is currently in sync with pre_downgrade, if you want to have
     # different behavior, you'll need to change th pre_downgrade function below
     conn = operations.get_bind()
-    inspector = Inspector.from_engine(conn)
+    inspector = inspect(conn)
     tables = inspector.get_table_names()
     for table in tables:
         if table.startswith("_alembic_tmp_"):
             operations.drop_table(table)
-    operations.execute("PRAGMA foreign_keys = OFF")
+    operations.execute(text("PRAGMA foreign_keys=OFF"))
 
 
 @Operations.implementation_for(PostUpgradeOp)
@@ -139,14 +139,15 @@ def alembic_config(connection: Engine, alembic_path: str):
     return alembic_cfg
 
 
-def migrate_database(connection: Engine, alembic_path: Optional[str] = None):
+def migrate_database(engine: Engine, alembic_path: Optional[str] = None):
     if alembic_path is None:
         alembic_path = os.path.join(os.getcwd(), "database")
     assert os.path.exists(os.path.abspath(alembic_path)), f"alembic path {os.path.abspath(alembic_path)} does not exist"
-    config = alembic_config(connection, alembic_path)
+    config = alembic_config(engine, alembic_path)
     command.upgrade(config, "head")
 
-    check = connection.execute("PRAGMA foreign_keys").fetchone()
+    with engine.connect() as connection:
+        check = connection.execute(text("PRAGMA foreign_keys")).fetchone()
     assert check is not None and check[0] == 1, "foreign keys are not enabled"
 
 
@@ -167,7 +168,7 @@ def register_bases(bases, show_deprecation_warning=True):
         for table in base.metadata.tables.values():
             for x in table.columns:
                 check_invalid_database_column_type(x.type)
-            table.tometadata(target_metadata)
+            table.to_metadata(target_metadata)
     context.config.attributes["target_metadata"] = target_metadata
 
 

{openmodule-14.3.0 → openmodule-15.0.0}/openmodule/dispatcher.py

@@ -8,10 +8,11 @@ from concurrent.futures._base import Executor
 from concurrent.futures.process import ProcessPoolExecutor
 from concurrent.futures.thread import ThreadPoolExecutor
 from pathlib import Path
-from typing import Union, Optional, Callable, DefaultDict, List, Dict, TypeVar, Type, Generic
+from typing import Callable, DefaultDict, TypeVar, Generic
 
+from pydantic_core import PydanticUndefined
 import zmq
-from pydantic import ValidationError, BaseModel, parse_obj_as
+from pydantic import ValidationError, BaseModel
 from sentry_sdk.utils import qualname_from_function
 
 from openmodule import sentry
@@ -41,14 +42,14 @@ class DummyExecutor(Executor):
 
 
 class Listener:
-    def __init__(self, message_class: Type[ZMQMessage], type: Optional[str], filter: Optional[Callable],
+    def __init__(self, message_class: type[ZMQMessage], type: str | None, filter: Callable | None,
                  handler: Callable):
         self.filter = filter
         self.handler = sentry.trace(f"message_handler.{qualname_from_function(handler)}")(handler)
         self.type = type
         self.message_class = message_class
 
-    def matches(self, message: Dict):
+    def matches(self, message: dict):
         if self.type and message.get("type") != self.type:
             return False
 
@@ -66,7 +67,7 @@ class EventListener(Generic[EventArgs], list):
     note: the generic may not work as intended, but it is nevertheless a nice way to document the event
     handler arguments
     """
-    log: Optional[logging.Logger]
+    log: logging.Logger | None = None
 
     def __init__(self, *args, log=None, raise_exceptions=False):
         super().__init__(args)
@@ -91,7 +92,7 @@ ZMQMessageSub = TypeVar('ZMQMessageSub', bound=ZMQMessage)
 
 class MessageDispatcher:
     def __init__(self, name=None, *, raise_validation_errors=False, raise_handler_errors=False,
-                 executor: Optional[Executor] = None):
+                 executor: Executor | None = None):
         """
         :param name: optionally name the dispatcher for logging purposes
         :param raise_validation_errors: if true and received messages do not match a validation error is raised,
@@ -106,7 +107,7 @@ class MessageDispatcher:
 
         self.name = name
         self.log = logging.getLogger(f"{self.__class__.__name__}({self.name})")
-        self.listeners: DefaultDict[str, List[Listener]] = defaultdict(list)
+        self.listeners: DefaultDict[str, list[Listener]] = defaultdict(list)
         self.raise_validation_errors = raise_validation_errors
         self.raise_handler_errors = raise_handler_errors
         self.executor = executor or DummyExecutor()
@@ -152,9 +153,9 @@ class MessageDispatcher:
             return False
 
     def register_handler(self, topic: str,
-                         message_class: Type[ZMQMessageSub],
+                         message_class: type[ZMQMessageSub],
                          handler: Callable[[ZMQMessageSub], None], *,
-                         filter: Optional[Union[Dict, Callable[[Dict], bool]]] = None,
+                         filter: dict | Callable[[dict], bool] | None = None,
                          match_type=True,
                          register_schema=True):
         """
@@ -169,16 +170,18 @@ class MessageDispatcher:
         assert isinstance(topic, str), "topic must be a string"
 
         if match_type:
-            assert "type" in message_class.__fields__ and message_class.__fields__["type"].default, (
+            if valid_type := "type" in message_class.model_fields:
+                valid_type &= message_class.model_fields["type"].default is not PydanticUndefined
+            assert valid_type, (
                 "\n\nYour message class definition does not set a `type` field, or the type field "
                 "does not have a default value! To receive all message type pass `match_type=False` to "
                 "`register_handler`. Otherwise please define a `type` for your message class."
             )
-            type = message_class.__fields__["type"].default
+            type_ = message_class.model_fields["type"].default
         else:
-            type = None
+            type_ = None
 
-        listener = Listener(message_class, type, filter, handler)
+        listener = Listener(message_class, type_, filter, handler)
         self.listeners[topic].append(listener)
 
         if register_schema and not self._is_test_handler(handler):
@@ -186,7 +189,7 @@ class MessageDispatcher:
 
         return listener
 
-    def dispatch(self, topic: str, message: Union[Dict, BaseModel]):
+    def dispatch(self, topic: str, message: dict | BaseModel):
         with self._shutdown_lock:
             if self._shutdown:
                 # We need to drop messages after shutdown somewhere.
@@ -197,7 +200,7 @@ class MessageDispatcher:
             assert isinstance(topic, str), "topic must be a string"
 
             if isinstance(message, BaseModel):
-                message = message.dict()
+                message = message.model_dump()
 
             listeners = self.listeners.get(topic, [])
             for listener in listeners:
@@ -205,11 +208,11 @@ class MessageDispatcher:
                     message.update(sentry.get_trace_headers())
                     self.executor.submit(self.execute, topic, listener, message)
 
-    def execute(self, topic: str, listener: Listener, message: Dict):
+    def execute(self, topic: str, listener: Listener, message: dict):
         with sentry.continue_trace_zmq_message_process(
                 topic, message, force_new_transaction=self._new_transactions):
             try:
-                parsed_message = parse_obj_as(listener.message_class, message)
+                parsed_message = listener.message_class.model_validate(message)
             except ValidationError as e:
                 if self.raise_validation_errors:
                     raise e from None
@@ -229,17 +232,17 @@ class MessageDispatcher:
 
 class SubscribingMessageDispatcher(MessageDispatcher):
     def __init__(self, subscribe: Callable[[str], None], name=None, *, raise_validation_errors=False,
-                 raise_handler_errors=False, unsubscribe: Optional[Callable[[str], None]] = None,
-                 executor: Optional[Executor] = None):
+                 raise_handler_errors=False, unsubscribe: Callable[[str], None] | None = None,
+                 executor: Executor | None = None):
         super().__init__(name=name, raise_validation_errors=raise_validation_errors,
                          raise_handler_errors=raise_handler_errors, executor=executor)
         self.subscribe = subscribe
         self.unsubscribe = unsubscribe
 
     def register_handler(self, topic: str,
-                         message_class: Type[ZMQMessageSub],
+                         message_class: type[ZMQMessageSub],
                          handler: Callable[[ZMQMessageSub], None], *,
-                         filter: Optional[Dict] = None,
+                         filter: dict | None = None,
                          register_schema=True,
                          match_type=True):
         assert isinstance(topic, str), "channel must be a string"
@@ -268,7 +271,7 @@ class SubscribingMessageDispatcher(MessageDispatcher):
 
 class ZMQMessageDispatcher(SubscribingMessageDispatcher):
     def __init__(self, sub_socket: zmq.Socket, name=None, *, raise_validation_errors=False, raise_handler_errors=False,
-                 executor: Optional[Executor] = None):
+                 executor: Executor | None = None):
         super().__init__(
             subscribe=lambda x: sub_socket.subscribe(x.encode("utf8")),
             unsubscribe=lambda x: sub_socket.unsubscribe(x.encode("utf8")),
@@ -280,8 +283,8 @@ class ZMQMessageDispatcher(SubscribingMessageDispatcher):
 
 
 class DeeplogMessageDispatcher(MessageDispatcher):
-    def __init__(self, path: Union[Path, str], name=None, *, raise_validation_errors=False, raise_handler_errors=False,
-                 executor: Optional[Executor] = None):
+    def __init__(self, path: Path | str, name=None, *, raise_validation_errors=False, raise_handler_errors=False,
+                 executor: Executor | None = None):
         super().__init__(name, raise_validation_errors=raise_validation_errors,
                          raise_handler_errors=raise_handler_errors, executor=executor)
         if not isinstance(path, Path):