openmodule 16.0.0rc0__tar.gz → 16.0.2__tar.gz

{openmodule-16.0.0rc0 → openmodule-16.0.2}/PKG-INFO

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

{openmodule-16.0.0rc0 → openmodule-16.0.2}/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, ClassVar
 
 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,7 +158,11 @@ def datetime_to_timestamp(dt: datetime):
 
 
 class ZMQMessage(OpenModuleModel):
+    _ALLOW_CUSTOM_TIMESTAMP: ClassVar[bool] = False  # set to true for tools scripts, where you need to set the timestamp manually
+
     timestamp: Datetime = Field(default_factory=lambda: utcnow())
+    _using_default_timestamp: bool = PrivateAttr()
+
     name: str = Field(default_factory=lambda: settings.NAME)
     type: str
     baggage: str | None = None
@@ -179,6 +183,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) is True
+        using_default_timestamp = cls._using_default_timestamp is True
+        custom_constructor_timestamp_allowed = cls._ALLOW_CUSTOM_TIMESTAMP is True
+
+        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-16.0.0rc0 → openmodule-16.0.2}/openmodule/rpc/server.py

@@ -185,7 +185,7 @@ class RPCServer(object):
         handler: HandlerEntry = self.find_handler(channel, message.type)
         if handler:
             try:
-                request = handler.request_class(**message.request)
+                request = handler.request_class.model_validate(message.request)
             except ValidationError as e:
                 self.log.exception("exception in parsing request. request not processed and error returned")
                 return {"status": RPCServerError.validation_error, "exception": e.json()}
@@ -225,7 +225,7 @@ class RPCServer(object):
                     return
 
                 try:
-                    message = RPCRequest(**message)
+                    message = RPCRequest.model_validate(message)
                     message_type = message.type
                     rpc_id = message.rpc_id
                 except ValidationError as e:

{openmodule-16.0.0rc0 → openmodule-16.0.2}/openmodule/utils/presence.py

@@ -210,7 +210,7 @@ class PresenceListener:
         present_vehicle = self.present_vehicles.get(message.gateway.gate)
         if present_vehicle and present_vehicle.id == message.vehicle_id:
             self.log.error(f"Got {message.type} without a leave. We generate a leave ourself.")
-            self._on_leave(PresenceLeaveMessage(**message.model_dump()))
+            self._on_leave(PresenceLeaveMessage.model_validate(message.model_dump()))
 
     def _execute_leave(self, vehicle: Vehicle, gateway: Gateway):
         if vehicle.leave_time is None:

{openmodule-16.0.0rc0 → openmodule-16.0.2}/openmodule/utils/validation.py

@@ -25,7 +25,7 @@ class Validation:
         rpc_server.register_handler("validation_provider", "validate", request_class=ValidateRequest,
                                     response_class=ValidateResponse, handler=self.rpc_validate_ticket)
 
-    def _validation_provider_filter(self, request, message, handler) -> bool:
+    def _validation_provider_filter(self, request, _message, _handler) -> bool:
         validation_provider = request.name
         if not validation_provider:
             return False

{openmodule-16.0.0rc0 → openmodule-16.0.2}/openmodule.egg-info/PKG-INFO

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

{openmodule-16.0.0rc0 → openmodule-16.0.2}/tests/test_model.py

@@ -16,6 +16,12 @@ class TestModel(OpenModuleModel):
 
 
 class ModelTestCase(TestCase):
+    def setUp(self):
+        ZMQMessage._ALLOW_CUSTOM_TIMESTAMP = True
+
+    def tearDown(self):
+        ZMQMessage._ALLOW_CUSTOM_TIMESTAMP = False
+
     def test_json_is_forbidden(self):
         instance = TestModel(value="Hello World")
         with self.assertRaises(AssertionError):
@@ -72,6 +78,12 @@ class ModelTestCase(TestCase):
 
 
 class ZMQMessageTestCase(TestCase):
+    def setUp(self):
+        ZMQMessage._ALLOW_CUSTOM_TIMESTAMP = True
+
+    def tearDown(self):
+        ZMQMessage._ALLOW_CUSTOM_TIMESTAMP = False
+
     def test_timestamp_to_datetime(self):
         instance = ZMQMessage(timestamp=1607586354631, name="test", type="test")
         self.assertEqual(instance.timestamp.isoformat(), "2020-12-10T07:45:54.631000")
@@ -136,3 +148,14 @@ class ZMQMessageTestCase(TestCase):
 
         res1.pop("timestamp")
         self.assertDictEqual(res1, {"name": "tä\nst", "type": "tö\tst"})
+
+    def test_allow_custom_timestamp(self):
+        ZMQMessage._ALLOW_CUSTOM_TIMESTAMP = False
+        with self.assertRaises(ValueError):
+            ZMQMessage(timestamp=1607586354631, name="test", type="test")
+        instance = ZMQMessage(name="test", type="test")
+        instance.type="asdf"
+        with self.assertRaises(ValueError):
+            instance.timestamp = datetime.datetime(2020, 1, 1, 0, 0, 0, 0)
+        ZMQMessage._ALLOW_CUSTOM_TIMESTAMP = True
+        instance.timestamp = datetime.datetime(2020, 1, 1, 0, 0, 0, 0)

{openmodule-16.0.0rc0 → openmodule-16.0.2}/tests/test_rpc.py

@@ -148,7 +148,7 @@ class RPCServerTestCase(RPCServerTestMixin, OpenModuleCoreTestMixin):
         self.assertTrue(self.called_types.get("test-type"))
 
     def test_exception_in_filter_function(self):
-        def bad_filter(*args, **kwargs) -> bool:
+        def bad_filter(_request, _message, _handler) -> bool:
             raise Exception("Error123")
 
         self.server.register_handler("channel", "test-type", TestRPCRequest, TestRPCResponse, self.set_called)
@@ -160,7 +160,7 @@ class RPCServerTestCase(RPCServerTestMixin, OpenModuleCoreTestMixin):
         self.assertEqual("Error123", str(e.exception))
 
     def test_filter(self):
-        def allow_only_type_test(_request: OpenModuleModel, message: RPCRequest, _handler: None) -> bool:
+        def allow_only_type_test(_request: None, message: RPCRequest, _handler: None) -> bool:
             return message.type == "test-type"
 
         self.server.register_handler("channel", "test-type", TestRPCRequest, TestRPCResponse, self.set_called)
@@ -188,7 +188,7 @@ class RPCServerTestCase(RPCServerTestMixin, OpenModuleCoreTestMixin):
         self.assertNotIn("test-type2", self.called_types)
 
     def test_filter_channel_type(self):
-        def f(*args, **kwargs):
+        def f(_request: None, _message: None, _handler: None):
             return False
 
         def check_ok():
@@ -511,7 +511,7 @@ class RpcClientTest(RPCServerTestMixin, OpenModuleCoreTestMixin):
         return TestRPCResponse2(some_payload="abc")
 
     @staticmethod
-    def broken_filter(message: RPCRequest, **kwargs) -> bool:
+    def broken_filter(_request: None, _message: None, _handler: None) -> bool:
         assert False
 
     @staticmethod

{openmodule-16.0.0rc0 → openmodule-16.0.2}/tests/test_utils_eventlog.py

@@ -1,5 +1,6 @@
 from datetime import datetime
 
+from openmodule.models.base import ZMQMessage
 from openmodule.utils.eventlog import send_event, EventInfo, MessageKwarg, EventlogMessage, AnonymizationType, \
     PlateFormatData
 from openmodule_test.core import OpenModuleCoreTestMixin
@@ -19,7 +20,7 @@ class TestEvents(OpenModuleCoreTestMixin):
         self.assertIn("INFO:Eventlog:Sending event at gate1: LPR plate='G ARIVO 1' country='A': "
                       "customer Test User, medium QR1, price 1", cm.output)
 
-        msg = EventlogMessage(**self.zmq_client.wait_for_message_on_topic("eventlog"))
+        msg = EventlogMessage.model_validate(self.zmq_client.wait_for_message_on_topic("eventlog"))
         self.assertEqual(msg.event.infos.type, "test_1")
         self.assertEqual(msg.event.infos.timestamp, datetime.min)
         self.assertEqual(msg.event.infos.gate, "gate1")
@@ -47,5 +48,5 @@ class TestEvents(OpenModuleCoreTestMixin):
         with self.assertLogs("Eventlog") as cm:
             send_event(EventInfo.create("test_1"), "test")
         self.assertIn("INFO:Eventlog:Sending event: test", cm.output)
-        msg = EventlogMessage(**self.zmq_client.wait_for_message_on_topic("eventlog"))
+        msg = EventlogMessage.model_validate(self.zmq_client.wait_for_message_on_topic("eventlog"))
         self.assertIsNotNone(msg.event.infos.timestamp)

{openmodule-16.0.0rc0 → openmodule-16.0.2}/tests/test_utils_vehicle.py

@@ -66,6 +66,6 @@ class VehicleTestCase(TestCase):
             "id":"ZH 614198","no_countrylogic_id":"ZH 614198","track_id":1638169339870027893,"type":"lpr"}},"name":
             "forward-om_alpr_tracking_3","present-area-name":"einfahrt-garage","source":"einfahrt-garage",
             "timestamp":1638169352.606454,"type":"forward","unsure":false,"vehicle_id":1638169340812374101}"""
-            parsed_message = PresenceForwardMessage(**orjson.loads(message))
+            parsed_message = PresenceForwardMessage.model_validate(orjson.loads(message))
         except ValidationError as e:
             assert False, "Parsing Presence Message failed"