openmodule 15.2.0__tar.gz → 16.0.0__tar.gz

{openmodule-15.2.0 → openmodule-16.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openmodule
-Version: 15.2.0
+Version: 16.0.0
 Summary: Libraries for developing the arivo openmodule
 Home-page: https://gitlab.com/arivo-public/device-python/openmodule.git
 Author: ARIVO

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/alert.py

@@ -1,6 +1,6 @@
 import logging
 import threading
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from openmodule.models.alert import AlertHandleType, AlertMessage, AlertStatus
 
@@ -83,7 +83,7 @@ class AlertHandler(object):
             Returns True if alert was send else False"""
         assert status in [AlertStatus.error, AlertStatus.ok, AlertStatus.offline]
 
-        status_dict = {
+        status_dict: dict[str, Any] = {
             "status": status,
             "alert_meta": (meta or {}),
         }

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/core.py

@@ -51,7 +51,7 @@ class OpenModuleCore(threading.Thread):
         self.alerts = AlertHandler(self)
         self.connection_listener = ConnectionStatusListener(self._messages_internal, self.rpc_client)
         self._messages_internal.register_handler("healthz", HealthPingMessage, self.health.process_message,
-                                                 match_type=True, register_schema=False)
+                                                 match_type=True)
 
     def init_database(self):
         from openmodule.database.database import Database

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/database/custom_types.py

@@ -11,6 +11,7 @@ class CustomTypeImportRegistration(type):
     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)
 

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/database/migration.py

@@ -3,13 +3,12 @@ import shutil
 import sys
 import warnings
 from typing import Optional
-  
+
 from alembic import command, context
 from alembic.autogenerate import comparators, renderers
 from alembic.config import Config
 from alembic.operations import Operations, MigrateOperation
 from alembic.runtime.migration import MigrationContext
-
 from sqlalchemy import MetaData, DateTime, inspect, text
 from sqlalchemy.engine import Engine
 
@@ -21,13 +20,26 @@ class PreUpgradeOp(MigrateOperation):
     @classmethod
     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))
+        db_file = migration_context.connection.engine.url.database
+        db_dir = os.path.dirname(db_file)
+        basename, _ = os.path.splitext(os.path.basename(db_file))
         timestamp = utcnow().strftime('%Y%m%d%H%M%S')
         migration_revision = migration_context.get_current_revision()
         filename = f"{basename}_{timestamp}_{migration_revision}.sqlite3.backup"
 
-        shutil.copy(migration_context.connection.engine.url.database,
-                    os.path.join(os.path.dirname(migration_context.connection.engine.url.database), filename))
+        for file in os.listdir(db_dir):
+            if file.startswith(f"{basename}_") and file.endswith(".sqlite3.backup"):
+                try:
+                    file_timestamp = file[len(basename) + 1:len(basename) + 15]
+                    file_time = utcnow().strptime(file_timestamp, '%Y%m%d%H%M%S')
+                    if (utcnow() - file_time).seconds < 60:
+                        # No backup if we created one in the last 60 seconds
+                        break
+                except Exception:
+                    # ignore any issues here
+                    pass
+        else:
+            shutil.copy(db_file, os.path.join(db_dir, filename))
 
         op = PreUpgradeOp(**kw)
         return operations.invoke(op)

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/dispatcher.py

@@ -18,7 +18,6 @@ from sentry_sdk.utils import qualname_from_function
 from openmodule import sentry
 from openmodule.config import settings
 from openmodule.models.base import ZMQMessage
-from openmodule.utils.schema import Schema
 
 
 class DummyExecutor(Executor):
@@ -142,22 +141,11 @@ class MessageDispatcher:
             except ValueError:
                 pass
 
-    def _is_test_handler(self, handler):
-        """
-        this breaks separation a bit by including test specific code in the main module
-        but it improves developer usability drastically
-        """
-        if settings.TESTING and "Mock" in str(handler):
-            return True
-        else:
-            return False
-
     def register_handler(self, topic: str,
                          message_class: type[ZMQMessageSub],
                          handler: Callable[[ZMQMessageSub], None], *,
                          filter: dict | Callable[[dict], bool] | None = None,
-                         match_type=True,
-                         register_schema=True):
+                         match_type=True):
         """
         registers a message handler. without any filters all messages from the topic are
         sent to the message handler.
@@ -184,8 +172,9 @@ class MessageDispatcher:
         listener = Listener(message_class, type_, filter, handler)
         self.listeners[topic].append(listener)
 
-        if register_schema and not self._is_test_handler(handler):
-            Schema.save_message(topic, message_class, handler, filter)
+        if settings.TESTING and hasattr(handler, "__global__") and "/tests/" not in handler.__globals__['__file__']:
+            # only doc string necessary for functions or lambdas (so not for mocks) outside of tests folder
+            assert handler.__doc__, f"You need to describe the message handler {handler} with a doc string"
 
         return listener
 
@@ -243,13 +232,11 @@ class SubscribingMessageDispatcher(MessageDispatcher):
                          message_class: type[ZMQMessageSub],
                          handler: Callable[[ZMQMessageSub], None], *,
                          filter: dict | None = None,
-                         register_schema=True,
                          match_type=True):
         assert isinstance(topic, str), "channel must be a string"
 
         self.subscribe(topic)
-        return super().register_handler(topic, message_class, handler, filter=filter,
-                                        register_schema=register_schema, match_type=match_type)
+        return super().register_handler(topic, message_class, handler, filter=filter, match_type=match_type)
 
     def unregister_handler(self, listener: Listener):
         super().unregister_handler(listener)

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/health.py

@@ -34,25 +34,26 @@ class HealthMetricType(StrEnum):
 
 
 class HealthMetric(OpenModuleModel):
-    id: str = Field(..., description="A identifier for this metric. Must be unique per `package` this check is "
-                                     "assigned to, independently of the source service which is returning the metric.")
-    name: str = Field(..., description="Human readable name of the Metric.")
-    description: str = Field(..., description="Human-readable description of the metric. The same description will be"
-                                              "displayed when the metric is displayed.")
-    type: HealthMetricType = Field(..., description="The type of this metric. This is used to determine how the metric"
-                                                    "is used.")
-    labels: list[str] = Field(..., description="List of label names for this metric. In debug and testing mode exactly"
-                                               "those labels are required for the metric to be valid. In production"
-                                               "wrong labels are still accepted.")
-    values: dict[str, Any] = Field(
-        {}, description="Contains the values for this metric, grouped by labels. The labels are "
-                        "represented as a the string of the sorted list of label items. str(list(<label_dict>.items()))"
-                        "'[(<label_name>, <label_value>), (<label_name>, <label_value>), ...]: <metric_value>'")
-    package: str = Field(..., description="The package this metric is assigned to. It may be your own service"
-                                          "but can also be any other hardware or software service.")
-    source: str | None = Field(None,
+    id: str = Field(description="A identifier for this metric. Must be unique per `package` this check is "
+                                "assigned to, independently of the source service which is returning the metric.")
+    name: str = Field(description="Human readable name of the Metric.")
+    description: str = Field(description="Human-readable description of the metric. The same description will be"
+                                         "displayed when the metric is displayed.")
+    type: HealthMetricType = Field(description="The type of this metric. This is used to determine how the metric"
+                                               "is used.")
+    labels: list[str] = Field(description="List of label names for this metric. In debug and testing mode exactly"
+                                          "those labels are required for the metric to be valid. In production"
+                                          "wrong labels are still accepted.")
+    values: dict[str, Any] = Field(default={},
+                                   description="Contains the values for this metric, grouped by labels. The labels are "
+                                               "represented as a the string of the sorted list of label items. "
+                                               "str(list(<label_dict>.items()))'[(<label_name>, <label_value>), "
+                                               "(<label_name>, <label_value>), ...]: <metric_value>'")
+    package: str = Field(description="The package this metric is assigned to. It may be your own service"
+                                     "but can also be any other hardware or software service.")
+    source: str | None = Field(default=None,
                                description="The service which reported the health check. This value is "
-                               "automatically set by health service and must not be set manually.")
+                                           "automatically set by health service and must not be set manually.")
 
 
 class HealthCheckState(StrEnum):
@@ -62,25 +63,24 @@ class HealthCheckState(StrEnum):
 
 
 class HealthCheck(OpenModuleModel):
-    id: str = Field(..., description="A identifier for this check. Must be unique per `package` this check is "
-                                     "assigned to, independently of the source service which is returning the check.")
-    package: str = Field(..., description="The package this check is assigned to. It may be your own service"
-                                          "but can also be any other hardware or software service.")
-    state: HealthCheckState = Field(HealthCheckState.no_data, description="The state of this check")
-    name: str = Field(..., description="Human readable name of the check. ")
-    description: str | None = Field(...,
-                                    description="Human-readable description of the check. The same description"
-                                    "will be displayed when the check fails or succeeds. Consider this"
-                                    "when choosing the wording.")
-    message: str | None = Field(None,
+    id: str = Field(description="A identifier for this check. Must be unique per `package` this check is "
+                                "assigned to, independently of the source service which is returning the check.")
+    package: str = Field(description="The package this check is assigned to. It may be your own service"
+                                     "but can also be any other hardware or software service.")
+    state: HealthCheckState = Field(default=HealthCheckState.no_data, description="The state of this check")
+    name: str = Field(description="Human readable name of the check. ")
+    description: str | None = Field(description="Human-readable description of the check. The same description"
+                                                "will be displayed when the check fails or succeeds. Consider this"
+                                                "when choosing the wording.")
+    message: str | None = Field(default=None,
                                 description="A human readable text which is displayed next to the check in the "
-                                "user interface. Can be used to convey more information. Please "
-                                "note that no efforts are taken to notify the user about changes "
-                                "in this value (i.e. no new e-mails are sent if the message "
-                                "changes).")
-    source: str | None = Field(None,
+                                            "user interface. Can be used to convey more information. Please "
+                                            "note that no efforts are taken to notify the user about changes "
+                                            "in this value (i.e. no new e-mails are sent if the message "
+                                            "changes).")
+    source: str | None = Field(default=None,
                                description="The service which reported the health check. This value is "
-                               "automatically set by health service and must not be set manually.")
+                                           "automatically set by health service and must not be set manually.")
 
 
 class HealthPongMessage(ZMQMessage):
@@ -262,6 +262,9 @@ class Healthz:
             metric.values[self._labels_string(labels)] = value
 
     def process_message(self, _: HealthPingMessage):
+        """
+        Process a health ping message and respond with the current health status.
+        """
         checks = list(self.checks.values())
         status = "ok"
         message = None

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/messaging.py

@@ -4,6 +4,7 @@ import random
 import string
 import time
 from contextlib import contextmanager
+from typing import Generator
 
 import orjson
 import zmq
@@ -42,7 +43,10 @@ def wait_for_connection(dispatcher: MessageDispatcher, pub_socket=None, pub_lock
     """
     waits until the pub_socket's messages can be received at the dispatcher.
     This dispatcher needs to run in a separate thread as this method is blocking
+    :param dispatcher: message dispatcher
+    :param pub_socket: socket for message publishing (defaults to the core's pub socket, if None)
     :param pub_lock: optionally locks the lock during publishing
+    :param timeout: timeout in sec
     """
 
     if pub_socket is None:
@@ -56,13 +60,14 @@ def wait_for_connection(dispatcher: MessageDispatcher, pub_socket=None, pub_lock
     received = False
 
     def handler(_):
+        """ handler to set received true"""
         nonlocal received
         received = True
 
     # topic needs to start with __ping because these messages are ignored by the deeplog
     random_topic = "__ping_" + "".join(random.choices(string.ascii_letters, k=10))
 
-    listener = dispatcher.register_handler(random_topic, ZMQMessage, handler, register_schema=False, match_type=False)
+    listener = dispatcher.register_handler(random_topic, ZMQMessage, handler, match_type=False)
 
     check_delay = 0.1
     check_iterations = int(timeout / check_delay) + 1
@@ -82,7 +87,7 @@ def wait_for_connection(dispatcher: MessageDispatcher, pub_socket=None, pub_lock
 
 
 @contextmanager
-def receive_message_from_socket(sub_socket: zmq.Socket) -> tuple[str | None, dict | None]:
+def receive_message_from_socket(sub_socket: zmq.Socket) -> Generator[tuple[str | None, dict | None], None, None]:
     """
     :param sub_socket: zmq socket to receive
     Enters a sentry trace for the received message. For this reason, the function should be used as a context manager.

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/models/access_service.py

@@ -50,24 +50,24 @@ class AccessCheckRejectReason(StrEnum):  # see DEV-A-916
 
 
 class AccessCheckAccess(OpenModuleModel):
-    id: str                                         # id of the access
-    group_id: str | None = None                     # id for group-passback, in Digimon Contract ID, optional for 3rd Party Backends
-    group_limit: int | None = Field(None, ge=1)     # group_limit must be greater or equal 1
-    customer_id: str | None = None                  # in Digimon Customer ID, optional for 3rd Party Backends
-    car_id: str | None = None                       # in Digimon Customer Car ID, optional for 3rd Party Backends
-    source: str                                     # Access Service providing the access
-    access_infos: dict = {}                         # Infos, which are added everywhere for later usage
-    parksettings_id: str | None = None              # None is no cost entries and access at any gate
-    clearing: str | None = None                     # Clearing
-    clearing_infos: dict | None = None              # Infos, which are added everywhere for later usage when using clearing
-    category: AccessCategory                        # category used for sorting and eventlog
-    used_medium: Medium                             # medium of the access
-    access_data: dict                               # complete access data, will be used only for display and debug purposes
-    valid_from: Datetime | None = None              # access is valid from this time. Only used for reservations
-    valid_to: Datetime | None = None                # access is valid until this time. Only used for reservations
-
-    accepted: bool                                  # if access service decided access can enter
-    reject_reason: AccessCheckRejectReason | None = None  # only if not accepted: reason for not accepted
+    id: str                                                 # id of the access
+    group_id: str | None = None                             # id for group-passback, in Digimon Contract ID, optional for 3rd Party Backends
+    group_limit: int | None = Field(default=None, ge=1)     # group_limit must be greater or equal 1
+    customer_id: str | None = None                          # in Digimon Customer ID, optional for 3rd Party Backends
+    car_id: str | None = None                               # in Digimon Customer Car ID, optional for 3rd Party Backends
+    source: str                                             # Access Service providing the access
+    access_infos: dict = {}                                 # Infos, which are added everywhere for later usage
+    parksettings_id: str | None = None                      # None is no cost entries and access at any gate
+    clearing: str | None = None                             # Clearing
+    clearing_infos: dict | None = None                      # Infos, which are added everywhere for later usage when using clearing
+    category: AccessCategory                                # category used for sorting and eventlog
+    used_medium: Medium                                     # medium of the access
+    access_data: dict                                       # complete access data, will be used only for display and debug purposes
+    valid_from: Datetime | None = None                      # access is valid from this time. Only used for reservations
+    valid_to: Datetime | None = None                        # access is valid until this time. Only used for reservations
+
+    accepted: bool                                          # if access service decided access can enter
+    reject_reason: AccessCheckRejectReason | None = None    # only if not accepted: reason for not accepted
     # additional infos shown in events if reject reason is "custom". Required if reject_reason == "custom"
     supplementary_infos: str | None = None
 

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/models/base.py

@@ -5,13 +5,13 @@ from datetime import datetime
 from decimal import Decimal
 from enum import StrEnum
 from json.encoder import ESCAPE_ASCII
-from typing import Annotated
+from typing import Annotated, Optional, Any, Self
 
 import orjson
 from pydantic_core import PydanticUndefined
 import zmq
 from dateutil.tz import UTC
-from pydantic import AfterValidator, ConfigDict, Field, BaseModel, RootModel
+from pydantic import AfterValidator, ConfigDict, Field, BaseModel, PrivateAttr, RootModel, model_validator, field_validator
 
 from openmodule import sentry
 from openmodule.config import run_checks, settings
@@ -158,11 +158,18 @@ def datetime_to_timestamp(dt: datetime):
 
 
 class ZMQMessage(OpenModuleModel):
+    _ALLOW_CUSTOM_TIMESTAMP: bool = PrivateAttr(default=False)  # set to true for tools scripts, where you need to set the timestamp manually
+    _using_default_timestamp: bool = PrivateAttr()
+
     timestamp: Datetime = Field(default_factory=lambda: utcnow())
     name: str = Field(default_factory=lambda: settings.NAME)
     type: str
     baggage: str | None = None
-    sentry_trace: str | None = Field(None, alias="sentry-trace")
+    sentry_trace: str | None = Field(
+        default=None,
+        validation_alias="sentry-trace",
+        serialization_alias="sentry-trace",
+    )
 
     def publish_on_topic(self, pub_socket: zmq.Socket, topic: str):
         assert isinstance(topic, str), "topic must be a string"
@@ -175,6 +182,28 @@ class ZMQMessage(OpenModuleModel):
         data["timestamp"] = datetime_to_timestamp(data["timestamp"])
         return data
 
+    @classmethod
+    def model_validate(cls, obj: Any, *, context: Optional[Any] = None, **kwargs) -> Self:
+        context = {**(context or {}), "from_model_validate": True}
+        return super().model_validate(obj, context=context, **kwargs)
+
+    @model_validator(mode="before")
+    @classmethod
+    def check_default_timestamp(cls, data: dict):
+        cls._using_default_timestamp = "timestamp" not in data
+        return data
+
+    @field_validator("timestamp", mode="before")
+    @classmethod
+    def check_custom_timestamp(cls, v, info):
+        from_model_validate = (info.context or {}).get("from_model_validate", False)
+        using_default_timestamp = cls._using_default_timestamp
+        custom_constructor_timestamp_allowed = cls._ALLOW_CUSTOM_TIMESTAMP
+
+        if not using_default_timestamp and not custom_constructor_timestamp_allowed and not from_model_validate:
+            raise ValueError("timestamp must not be set manually")
+        return v
+
 
 class Direction(StrEnum):
     UNKNOWN = ""

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/models/presence.py

@@ -16,25 +16,23 @@ class PresenceMedia(OpenModuleModel):
 class PresenceBaseData(OpenModuleModel):
     vehicle_id: int
     source: str
-    present_area_name: str = Field(..., alias="present-area-name")
+    present_area_name: str = Field(
+        validation_alias="present-area-name",
+        serialization_alias="present-area-name",
+    )
     last_update: Datetime
     gateway: Gateway
     medium: PresenceMedia
     make_model: MakeModel | None = None
     all_ids: PresenceAllIds
     enter_direction: EnterDirection = EnterDirection.unknown
-    enter_time: Datetime
+    enter_time: Datetime | None = None
 
     model_config = ConfigDict(validate_by_name=True, validate_by_alias=True)
 
-    @model_validator(mode="before")
-    @classmethod
-    def set_enter_time_default(cls, values_dict: dict) -> dict:
-        """for backward compatibility, set enter_time based on vehicle_id"""
-        if values_dict.get("enter_time") is None:
-            utc_datetime = datetime.datetime.fromtimestamp(values_dict["vehicle_id"] / 1e9, datetime.timezone.utc)
-            values_dict["enter_time"] = utc_datetime  # timestamp from vehicle_id
-        return values_dict
+    def model_post_init(self, *_) -> None:
+        if self.enter_time is None:
+            self.enter_time = datetime.datetime.fromtimestamp(self.vehicle_id / 1e9, datetime.timezone.utc)
 
 
 class PresenceBaseMessage(PresenceBaseData, ZMQMessage):
@@ -44,21 +42,34 @@ class PresenceBaseMessage(PresenceBaseData, ZMQMessage):
 class PresenceBackwardMessage(PresenceBaseMessage):
     type: str = "backward"
     unsure: bool = False
-    leave_time: Datetime = Field(..., alias="leave-time")
+    leave_time: Datetime = Field(
+        validation_alias="leave-time",
+        serialization_alias="leave-time",
+    )
     bidirectional_inverse: bool = False
 
 
 class PresenceForwardMessage(PresenceBaseMessage):
     type: str = "forward"
     unsure: bool = False
-    leave_time: Datetime = Field(..., alias="leave-time")
+    leave_time: Datetime = Field(
+        validation_alias="leave-time",
+        serialization_alias="leave-time",
+    )
     bidirectional_inverse: bool = False
 
 
 class PresenceLeaveMessage(PresenceBaseMessage):
     type: str = "leave"
-    num_presents: int = Field(0, alias="num-presents")
-    leave_time: Datetime = Field(..., alias="leave-time")
+    num_presents: int = Field(
+        default=0,
+        validation_alias="num-presents",
+        serialization_alias="num-presents",
+    )
+    leave_time: Datetime = Field(
+        validation_alias="leave-time",
+        serialization_alias="leave-time",
+    )
 
     @model_validator(mode="before")
     @classmethod

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/rpc/server.py

@@ -2,10 +2,10 @@ import logging
 import threading
 import warnings
 from collections import namedtuple
-from typing import Callable, TypeVar
+from typing import Callable, TypeVar, Any
 
 import zmq
-from pydantic import ValidationError, BaseModel
+from pydantic import ValidationError
 from sentry_sdk.utils import qualname_from_function
 
 from openmodule import sentry
@@ -16,14 +16,22 @@ from openmodule.messaging import get_sub_socket, receive_message_from_socket
 from openmodule.models.rpc import RPCResponse, RPCRequest, RPCServerError
 from openmodule.rpc.common import channel_to_request_topic, channel_to_response_topic
 from openmodule.threading import get_thread_wrapper
-from openmodule.utils.schema import Schema
 
 CallbackEntry = namedtuple("CallbackEntry", ["timestamp", "result"])
 HandlerEntry = namedtuple("HandlerEntry", ["request_class", "response_class", "handler"])
 
+FilterFunction = Callable[[Any, Any, Any], bool]
+"""
+Each filter function must have 3 parameters:
+- request: OpenModuleModel | None
+- message: RPCRequest | None
+- handler: Callable[[OpenModuleModel, dict[str, Any]], OpenModuleModel | dict[str, Any]] | None
+(NOTE: Use 'None' if the parameter is ignored.)
+"""
+
 
 def gateway_filter(gate=None, direction=None):
-    def _filter(request, message, handler):
+    def _filter(request, _message, _handler):
         gateway = request.get("gateway")
         if not gateway:
             return False
@@ -34,14 +42,14 @@ def gateway_filter(gate=None, direction=None):
 
 
 class Filter:
-    def __init__(self, filter, channel, type):
+    def __init__(self, filter: FilterFunction, channel, type):
         self.filter = filter
         self.channel = channel
         self.type = type
 
     def check(self, request, message, handler, channel):
         if (self.channel is None or channel == self.channel) and (self.type is None or self.type == message.type):
-            if self.filter(request=request, message=message, handler=handler):
+            if self.filter(request, message, handler):
                 return True
             return False
         # filter does not apply
@@ -51,7 +59,6 @@ class Filter:
 RequestType = TypeVar("RequestType")
 ResponseType = TypeVar("ResponseType")
 
-
 class RPCServer(object):
     def __init__(self, context, config=None, *, filter_resource=True, executor=None):
         """
@@ -89,12 +96,12 @@ class RPCServer(object):
                     "This is ok for debugging / testing containers, but must not happen in production."
                 )
 
-    def add_filter(self, filter: Callable[..., bool], channel=None, type=None):
+    def add_filter(self, filter: FilterFunction, channel=None, type=None):
         """
-        :param filter: filter function with parameters (keyword arguments):
-            request: OpenModuleModel
-            message: RPCRequest
-            handler: Callable[[OpenModuleModel, dict[str, Any]], OpenModuleModel | dict[str, Any]]
+        :param filter: filter function with parameters (arguments in order, use 'None' if ignored):
+            - request: OpenModuleModel | None
+            - message: RPCRequest | None
+            - handler: Callable[[OpenModuleModel, dict[str, Any]], OpenModuleModel | dict[str, Any]] | None
         :param channel: specific channel to filter or all channels if None
         :param type: specific type to filter or all types if None
         """
@@ -111,8 +118,7 @@ class RPCServer(object):
     def register_handler(self, channel: str, type: str,
                          request_class: type[RequestType],
                          response_class: type[ResponseType],
-                         handler: Callable[[RequestType, BaseModel], ResponseType | dict | None],
-                         register_schema=True):
+                         handler: Callable[[RequestType, RPCRequest], ResponseType | dict | None]):
         """
         :param channel: rpc channel you want to subscribe to, patterns/wildcards are not supported
         :param type: the request type
@@ -122,7 +128,6 @@ class RPCServer(object):
                         if the handler returns a dict which contains the key "status",
                         then the value of "status" will be used as the rpc response status.
                         There are no other reserved keys except "status".
-        :param register_schema: register the schema and models of this rpc during testing to create an automatic doc
         """
         if (channel, type) in self.handlers:
             raise ValueError(f"handler for {channel}:{type} is already registered")
@@ -132,17 +137,18 @@ class RPCServer(object):
         traced_handler = sentry.trace(f"rpc_handler.{qualname_from_function(handler)}")(handler)
         self.handlers[(channel, type)] = HandlerEntry(request_class, response_class, traced_handler)
         self.registered_channels = set(x[0] for x in self.handlers.keys())
-        if register_schema:
-            Schema.save_rpc(channel, type, request_class, response_class, handler)
+        if settings.TESTING and hasattr(handler, "__global__") and "/tests/" not in handler.__globals__['__file__']:
+            # only doc string necessary for functions or lambdas (so not for mocks) outside of tests folder
+            assert handler.__doc__, f"You need to describe the RPC handler {handler} with a doc string"
 
     def _channel_from_topic(self, topic: str) -> str:
         return topic.split("-", 2)[-1]
 
-    def should_process_message(self, request, message, handler, channel: str):
+    def should_process_message(self, *args):
         if self.filters:
             result = True
             for filter in self.filters:
-                ok = filter.check(request=request, message=message, handler=handler, channel=channel)
+                ok = filter.check(*args)
                 if ok:
                     return True
                 # filter applies and is not ok

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/sentry.py

@@ -11,6 +11,7 @@ import orjson
 import requests
 import sentry_sdk.integrations.logging
 import sentry_sdk.tracing
+import sentry_sdk.utils
 import urllib3.exceptions
 from sentry_sdk.consts import EndpointType
 from sentry_sdk.envelope import Envelope

{openmodule-15.2.0 → openmodule-16.0.0}/openmodule/utils/charset.py

@@ -1,11 +1,18 @@
 from pydantic import field_validator, Field
+from pydantic import TypeAdapter
 
 from openmodule.models.base import OpenModuleModel
 
 
 class Replacement(OpenModuleModel):
-    c_from: str = Field(alias="from")
-    c_to: str = Field(alias="to")
+    c_from: str = Field(
+        validation_alias="from",
+        serialization_alias="from",
+    )
+    c_to: str = Field(
+        validation_alias="to",
+        serialization_alias="to",
+    )
 
     @field_validator("c_from")
     @classmethod
@@ -48,7 +55,9 @@ class CharsetConverter:
 def _build_charset(allowed: str, replacements: list | tuple) -> Charset:
     return Charset(
         allowed=allowed,
-        replacements=({"from": f, "to": t} for f, t in replacements)
+        replacements=TypeAdapter(list[Replacement]).validate_python(
+            {"from": f, "to": t} for f, t in replacements
+        )
     )