openmodule-test 14.2.0__tar.gz → 15.0.0__tar.gz

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/PKG-INFO

@@ -1,18 +1,23 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: openmodule_test
-Version: 14.2.0
+Version: 15.0.0
 Summary: Libraries for testing openmodule services
 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 openmodule_test test
-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.7
-Classifier: Programming Language :: Python :: 3.8
-
-UNKNOWN
-
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: multiprocessing_logging
+Requires-Dist: freezegun
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/core.py

@@ -1,5 +1,3 @@
-from typing import Dict
-
 from openmodule.core import init_openmodule, shutdown_openmodule, OpenModuleCore
 from openmodule_test.health import HealthTestMixin
 
@@ -9,7 +7,7 @@ class OpenModuleCoreTestMixin(HealthTestMixin):
     Mixin which creates a core, zmq, and health mixin
     """
 
-    init_kwargs: Dict = {}
+    init_kwargs: dict = {}
     core: OpenModuleCore
 
     def get_init_kwargs(self):

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/database.py

@@ -5,7 +5,7 @@ from unittest import TestCase
 
 from alembic import command
 from alembic.runtime.migration import MigrationContext
-from sqlalchemy import MetaData
+from sqlalchemy import MetaData, text
 from sqlalchemy.ext.automap import automap_base
 
 from openmodule.config import settings
@@ -19,8 +19,8 @@ _first_start = True
 
 def truncate_all_tables(database: Database, keep=("alembic_version",)):
     assert any(x in database.db_folder for x in ["/test/"]), "deleting all tables is only for testing"
-    metadata = MetaData(bind=database._engine)
-    metadata.reflect()
+    metadata = MetaData()
+    metadata.reflect(bind=database._engine)
     with database._engine.connect() as con:
         trans = con.begin()
         for table in reversed(metadata.sorted_tables):
@@ -123,7 +123,7 @@ class AlembicMigrationTestMixin(SQLiteTestMixin):
 
     def reload_models(self):
         self.base = automap_base()
-        self.base.prepare(self.connection, reflect=True)
+        self.base.prepare(autoload_with=self.connection)
 
     def alembic_config(self):
         alembic_path = self.alembic_path or os.path.join(os.getcwd(), "database")
@@ -134,13 +134,15 @@ class AlembicMigrationTestMixin(SQLiteTestMixin):
     def migrate_up(self, revision="head"):
         config = self.alembic_config()
         command.upgrade(config, revision)
-        assert self.connection.execute("PRAGMA foreign_keys").fetchone()[0] == 1, "foreign keys are not enabled"
+        with self.connection.connect() as connection:
+            assert connection.execute(text("PRAGMA foreign_keys")).fetchone()[0] == 1, "foreign keys are not enabled"
         self.reload_models()
 
     def migrate_down(self, revision="base"):
         config = self.alembic_config()
         command.downgrade(config, revision)
-        assert self.connection.execute("PRAGMA foreign_keys").fetchone()[0] == 1, "foreign keys are not enabled"
+        with self.connection.connect() as connection:
+            assert connection.execute(text("PRAGMA foreign_keys")).fetchone()[0] == 1, "foreign keys are not enabled"
         self.reload_models()
 
     def current_revision(self):

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/health.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from openmodule_test.zeromq import ZMQTestMixin
 
 
@@ -10,7 +8,7 @@ def _get_health_filter(name):
 
 
 class HealthTestMixin(ZMQTestMixin):
-    def get_health(self, name: Optional[str] = None, timeout: float = 3):
+    def get_health(self, name: str | None = None, timeout: float = 3):
         self.assertSubscription("healthpong")
         self.zmq_client.send("healthz", {"type": "ping", "ping": "ping"})
         _, message = self.zmq_client.wait_for_message(
@@ -29,7 +27,7 @@ class HealthTestMixin(ZMQTestMixin):
         pong = message.get("pong", {})
         self.assertEqual("error", pong.get("status"))
 
-    def wait_for_health(self, name: Optional[str] = None):
+    def wait_for_health(self, name: str | None = None):
         """
         :param name: if specified the function waits for a specific service name on startup
         """

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/interrupt.py

@@ -7,7 +7,7 @@ import traceback
 from multiprocessing import Process, Event
 from signal import SIGINT, SIGKILL
 from textwrap import dedent
-from typing import Callable, Union, Type, Optional
+from typing import Callable
 from unittest import TestCase
 
 import multiprocessing_logging
@@ -76,7 +76,7 @@ class InterruptTestMixin(TestCase):
     for usage, look at file tests/test_interrupt
     """
 
-    process: Optional[ExceptionProcess] = None
+    process: ExceptionProcess | None = None
 
     def _kill_process(self):
         # this is called in tear down and as a cleanup to make sure that under any circumstances the process is killed
@@ -132,13 +132,13 @@ class InterruptTestMixin(TestCase):
             else:
                 raise AssertionError("Process did not finish gracefully")
 
-    def send_signal_to_process(self, process: ExceptionProcess, signal: Union[Type[KeyboardInterrupt], int]):
+    def send_signal_to_process(self, process: ExceptionProcess, signal: type[KeyboardInterrupt] | int):
         self.assertFalse(process.is_finished.is_set(), msg="process crashed before we could send the signal")
         if signal == KeyboardInterrupt:
             signal = SIGINT
         os.kill(process.pid, signal)
 
-    def signal_in_function(self, f: Callable, signal: Union[Type[KeyboardInterrupt], int], *,
+    def signal_in_function(self, f: Callable, signal: type[KeyboardInterrupt] | int, *,
                            raise_exception_after: float = 3.0, shutdown_timeout: float = 3.0):
         """
         wraps the helper functions into a single function because apparently everybody likes

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/io_simulator.py

@@ -1,12 +1,12 @@
 from collections import defaultdict
-from datetime import datetime
-from typing import Callable, Dict, Optional
+from typing import Callable
 
 from openmodule.models.base import Gateway
 from openmodule.models.io import IoMessage, IoState
+from openmodule.utils.misc_functions import utcnow
 
 
-def generate_example_states(count: Optional[int] = 8) -> Dict[str, IoState]:
+def generate_example_states(count: int | None = 8) -> dict[str, IoState]:
     """
     Creates a dict with pin as key and IoState as value.
     param count: how many pins should be created.
@@ -14,13 +14,13 @@ def generate_example_states(count: Optional[int] = 8) -> Dict[str, IoState]:
     Gateways with even x have direction in, odds have out.
     All pins created low and not inverted.
     """
-    states: Dict[str, IoState] = defaultdict(IoState)
+    states: dict[str, IoState] = defaultdict(IoState)
     for i in range(count):
         gate = int(i/4)
         direction = "in" if gate % 2 == 0 else "out"
         gateway = Gateway(gate="gate_{}".format(gate), direction=direction)
         state = IoState(pin="", gateway=gateway, value=0, physical=0, inverted=False, type="input",
-                        last_timestamp=datetime.utcnow())
+                        last_timestamp=utcnow())
         if i % 4 == 0:
             state.pin = "gate_{}_button".format(gate)
         elif i % 4 == 1:
@@ -45,14 +45,14 @@ class IoSimulator:
     There can be a race condition during init if the emitted messages have not yet been received by
     an io handler. See tests.test_io_listen.IoTest's comment in setUp()
     """
-    def __init__(self, states: Dict[str, IoState], emit: Callable[[IoMessage], None]):
+    def __init__(self, states: dict[str, IoState], emit: Callable[[IoMessage], None]):
         self.pin_states = states
         self.emit = emit
         for state in self.pin_states.values():
             self.emit(IoMessage(gateway=state.gateway, type=state.type, pin=state.pin, value=state.value,
                                 inverted=state.inverted, physical=state.physical, edge=1))
 
-    def get_pin_states(self) -> Dict[str, IoState]:
+    def get_pin_states(self) -> dict[str, IoState]:
         return self.pin_states
 
     def change_pin_sate(self, pin: str):

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/openmodule_test.egg-info/PKG-INFO

@@ -1,18 +1,23 @@
-Metadata-Version: 2.1
-Name: openmodule-test
-Version: 14.2.0
+Metadata-Version: 2.4
+Name: openmodule_test
+Version: 15.0.0
 Summary: Libraries for testing openmodule services
 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 openmodule_test test
-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.7
-Classifier: Programming Language :: Python :: 3.8
-
-UNKNOWN
-
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: multiprocessing_logging
+Requires-Dist: freezegun
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/openmodule_test.egg-info/SOURCES.txt

@@ -1,6 +1,3 @@
-AUTHORS
-ChangeLog
-requirements.txt
 setup.cfg
 setup.py
 ./__init__.py
@@ -26,6 +23,5 @@ openmodule_test.egg-info/PKG-INFO
 openmodule_test.egg-info/SOURCES.txt
 openmodule_test.egg-info/dependency_links.txt
 openmodule_test.egg-info/not-zip-safe
-openmodule_test.egg-info/pbr.json
 openmodule_test.egg-info/requires.txt
 openmodule_test.egg-info/top_level.txt

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/package_reader.py

@@ -1,6 +1,5 @@
 import json
 import random
-from typing import Optional, Dict, List
 
 from openmodule.utils.package_reader import ServiceSetting, PackageReader, PackageData
 
@@ -28,9 +27,9 @@ class FakeServiceRepo(dict):
         self[settings.name] = settings
         self._resolve_parents()
 
-    def add_hardware_package(self, name, env: Optional[Dict] = None, yml: Optional[Dict] = None,
-                             hardware_type: Optional[List[str]] = None, ip: Optional[str] = None,
-                             revision: Optional[int] = None, package_data: Optional[PackageData] = None):
+    def add_hardware_package(self, name, env: dict | None = None, yml: dict | None = None,
+                             hardware_type: list[str] | None = None, ip: str | None = None,
+                             revision: int | None = None, package_data: PackageData | None = None):
         revision = revision or random.randint(0, 1000000000)
         merged_yml = {}
         if ip:
@@ -51,10 +50,10 @@ class FakeServiceRepo(dict):
         self.add_package(ServiceSetting(env=merged_env, yml=merged_yml, name=name,
                                         revision=revision, package_data=package_data))
 
-    def add_software_package(self, name, env: Optional[Dict] = None, yml: Optional[Dict] = None,
-                             parent_type: Optional[List[str]] = None, revision: Optional[int] = None,
-                             parent: Optional[str] = None, package_data: Optional[PackageData] = None,
-                             software_type: Optional[List[str]] = None):
+    def add_software_package(self, name, env: dict | None = None, yml: dict | None = None,
+                             parent_type: list[str] | None = None, revision: int | None = None,
+                             parent: str | None = None, package_data: PackageData | None = None,
+                             software_type: list[str] | None = None):
         revision = revision or random.randint(0, 1000000000)
         merged_env = {
             "NAME": name,
@@ -83,10 +82,10 @@ class MockPackageReader(PackageReader):
 
         self._services = FakeServiceRepo()
 
-    def get_service_by_name(self, service: str) -> Optional[ServiceSetting]:
+    def get_service_by_name(self, service: str) -> ServiceSetting | None:
         return self._services.get(service)
 
-    def list_all_services(self, prefix: Optional[str] = None, compute_id: Optional[int] = None) -> List[ServiceSetting]:
+    def list_all_services(self, prefix: str | None = None, compute_id: int | None = None) -> list[ServiceSetting]:
         """
         :param compute_id: compute unit id, if None packages from all units are returned
         :param prefix: prefix of the package id, if none is passed all are returned
@@ -98,7 +97,7 @@ class MockPackageReader(PackageReader):
                (compute_id is None or (x.env.get("COMPUTE_ID") or '1') == compute_id_str)
         ]
 
-    def list_by_hardware_type(self, prefix: str, compute_id: Optional[int] = None):
+    def list_by_hardware_type(self, prefix: str, compute_id: int | None = None):
         """
         lists all packages with a certain hardware type (prefix). Note that these can only be hardware packages
         i.e. their name starts with "hw_"
@@ -115,7 +114,7 @@ class MockPackageReader(PackageReader):
                (compute_id is None or (x.env.get("COMPUTE_ID") or '1') == compute_id_str)
         ]
 
-    def list_by_parent_type(self, prefix: str, compute_id: Optional[int] = None):
+    def list_by_parent_type(self, prefix: str, compute_id: int | None = None):
         """
         lists all packages with a certain parent type (prefix). Note that these can only be software packages
         i.e. their name starts with "om_"
@@ -132,7 +131,7 @@ class MockPackageReader(PackageReader):
                (compute_id is None or (x.env.get("COMPUTE_ID") or '1') == compute_id_str)
         ]
 
-    def list_by_software_type(self, prefix: str, compute_id: Optional[int] = None):
+    def list_by_software_type(self, prefix: str, compute_id: int | None = None):
         """
         lists all packages with a certain software type (prefix). Note that these can only be software packages
         i.e. their name starts with "om_"

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/presence.py

@@ -1,13 +1,14 @@
 import random
 import time
 from datetime import datetime
-from typing import Optional, Callable
+from typing import Callable
 
 from openmodule.models.base import Direction, Gateway, datetime_to_timestamp
 from openmodule.models.presence import PresenceBaseMessage, PresenceEnterMessage, PresenceLeaveMessage, \
     PresenceForwardMessage, PresenceBackwardMessage, PresenceMedia, PresenceChangeMessage
 from openmodule.models.vehicle import LPRMedium, LPRCountry, Medium, Vehicle, MakeModel, PresenceAllIds, \
     EnterDirection, QRMedium, MediumType
+from openmodule.utils.misc_functions import utcnow
 
 
 class VehicleBuilder:
@@ -19,7 +20,7 @@ class VehicleBuilder:
         self.medium = PresenceMedia()
         self.make_model = MakeModel(make="UNKNOWN", make_confidence=0.7, model="UNKNOWN", model_confidence=-1.0)
         self.enter_direction = EnterDirection.unknown
-        self.enter_time = datetime.utcnow()
+        self.enter_time = utcnow()
         self.leave_time = None
 
     def vehicle(self) -> Vehicle:
@@ -39,7 +40,7 @@ class VehicleBuilder:
         self.vehicle_id = id
         return self
 
-    def lpr(self, country: Optional[str], plate: Optional[str] = None, state="") -> 'VehicleBuilder':
+    def lpr(self, country: str | None, plate: str | None = None, state="") -> 'VehicleBuilder':
         if country is None:
             self.medium.lpr = None
         else:
@@ -49,21 +50,21 @@ class VehicleBuilder:
             )
         return self
 
-    def nfc(self, id: Optional[str]) -> 'VehicleBuilder':
+    def nfc(self, id: str | None) -> 'VehicleBuilder':
         if id is None:
             self.medium.nfc = id
         else:
             self.medium.nfc = Medium(id=id, type=MediumType.nfc)
         return self
 
-    def qr(self, id: Optional[str], binary: Optional[str] = None) -> 'VehicleBuilder':
+    def qr(self, id: str | None, binary: str | None = None) -> 'VehicleBuilder':
         if id is None:
             self.medium.qr = id
         else:
             self.medium.qr = QRMedium(id=id, binary=binary)
         return self
 
-    def pin(self, id: Optional[str]) -> 'VehicleBuilder':
+    def pin(self, id: str | None) -> 'VehicleBuilder':
         if id is None:
             self.medium.pin = id
         else:
@@ -88,10 +89,10 @@ class VehicleBuilder:
 
 
 class PresenceSimulator:
-    current_present: Optional[VehicleBuilder] = None
+    current_present: VehicleBuilder | None = None
 
     def __init__(self, gate: str, direction: Direction, emit: Callable[[PresenceBaseMessage], None],
-                 present_area_name: Optional[str] = None):
+                 present_area_name: str | None = None):
         self.gateway = Gateway(gate=gate, direction=direction)
         self.emit = emit
         self.present_area_name = present_area_name or f"{self.gateway.gate}-present"
@@ -100,7 +101,7 @@ class PresenceSimulator:
         return VehicleBuilder()
 
     def _common_kwargs(self, vehicle):
-        timestamp = datetime_to_timestamp(datetime.utcnow())
+        timestamp = datetime_to_timestamp(utcnow())
         all_ids = PresenceAllIds(lpr=None if vehicle.medium.lpr is None else [vehicle.medium.lpr],
                                  qr=None if vehicle.medium.qr is None else [vehicle.medium.qr],
                                  nfc=None if vehicle.medium.nfc is None else [vehicle.medium.nfc],
@@ -120,45 +121,45 @@ class PresenceSimulator:
             "leave_time": vehicle.leave_time
         }
 
-    def enter(self, vehicle: VehicleBuilder, enter_time: Optional[datetime] = None):
+    def enter(self, vehicle: VehicleBuilder, enter_time: datetime | None = None):
         vehicle.enter_time = enter_time or vehicle.enter_time
         if self.current_present:
             self.leave()
         self.current_present = vehicle
         self.emit(PresenceEnterMessage(**self._common_kwargs(vehicle)))
 
-    def enter_without_dropping_present_vehicle(self, vehicle: VehicleBuilder, enter_time: Optional[datetime] = None):
+    def enter_without_dropping_present_vehicle(self, vehicle: VehicleBuilder, enter_time: datetime | None = None):
         vehicle.enter_time = enter_time or vehicle.enter_time
         self.current_present = vehicle
         self.emit(PresenceEnterMessage(**self._common_kwargs(vehicle)))
 
-    def leave(self, leave_time: Optional[datetime] = None) -> VehicleBuilder:
-        self.current_present.leave_time = leave_time or self.current_present.leave_time or datetime.utcnow()
+    def leave(self, leave_time: datetime | None = None) -> VehicleBuilder:
+        self.current_present.leave_time = leave_time or self.current_present.leave_time or utcnow()
         self.emit(PresenceLeaveMessage(**self._common_kwargs(self.current_present)))
         temp = self.current_present
         self.current_present = None
         return temp
 
-    def leave_without_present(self, vehicle: VehicleBuilder, leave_time: Optional[datetime] = None):
-        vehicle.leave_time = leave_time or vehicle.leave_time or datetime.utcnow()
+    def leave_without_present(self, vehicle: VehicleBuilder, leave_time: datetime | None = None):
+        vehicle.leave_time = leave_time or vehicle.leave_time or utcnow()
         self.emit(PresenceLeaveMessage(**self._common_kwargs(vehicle)))
 
-    def forward(self, vehicle: Optional[VehicleBuilder] = None):
+    def forward(self, vehicle: VehicleBuilder | None = None):
         assert vehicle or self.current_present, "a vehicle must be present, or you have to pass a vehicle"
         if not vehicle:
             vehicle = self.leave()
         if vehicle.leave_time is None:  # if leave was not called for this vehicle
-            vehicle.leave_time = datetime.utcnow()
+            vehicle.leave_time = utcnow()
         self.emit(PresenceForwardMessage(
             **self._common_kwargs(vehicle)
         ))
 
-    def backward(self, vehicle: Optional[VehicleBuilder] = None):
+    def backward(self, vehicle: VehicleBuilder | None = None):
         assert vehicle or self.current_present, "a vehicle must be present, or you have to pass a vehicle"
         if not vehicle:
             vehicle = self.leave()
         if vehicle.leave_time is None:  # if leave was not called for this vehicle
-            vehicle.leave_time = datetime.utcnow()
+            vehicle.leave_time = utcnow()
         self.emit(PresenceBackwardMessage(
             **self._common_kwargs(vehicle)
         ))

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/rpc.py

@@ -3,7 +3,7 @@ import string
 import threading
 import time
 from functools import partial
-from typing import Dict, Tuple, Any, Callable, Type, Optional
+from typing import Any, Callable
 
 from pydantic.main import BaseModel
 
@@ -18,7 +18,7 @@ class _EmptyModel(BaseModel):
 
 
 class RPCServerTestMixin(ZMQTestMixin):
-    def wait_for_rpc_response(self, channel: str, type: str, request: BaseModel, response_type: Type[OpenModuleModel]):
+    def wait_for_rpc_response(self, channel: str, type: str, request: BaseModel, response_type: type[OpenModuleModel]):
         """
         waits until a rpc server is responding to the channel/type
         """
@@ -67,21 +67,21 @@ class MockRPCEntry(RPCClient.RPCEntry):
     def _run_callback(self):
         try:
             res = self.callback()
-            self.response = {"status": "ok", **(res if isinstance(res, dict) else res.dict())}
+            self.response = {"status": "ok", **(res if isinstance(res, dict) else res.model_dump())}
         except Exception:
-            self.response = RPCErrorResult(status=RPCServerError.handler_error).dict()
+            self.response = RPCErrorResult(status=RPCServerError.handler_error).model_dump()
         self.ready.set()
 
-    def result(self, response_type: Type[OpenModuleModel], timeout=None):
+    def result(self, response_type: type[OpenModuleModel], timeout=None):
         thread = threading.Thread(target=self._run_callback, daemon=True)
         thread.start()
         return super().result(response_type, timeout)
 
 
 class MockRPCClient:
-    def __init__(self, callbacks: Optional[Dict[Tuple[str, str], Callable[[OpenModuleModel, Any], Any]]] = None,
-                 responses: Optional[Dict[Tuple[str, str], Any]] = None,
-                 immediate_callbacks: Optional[Dict[Tuple[str, str], Callable[[OpenModuleModel, Any], Any]]] = None,
+    def __init__(self, callbacks: dict[tuple[str, str], Callable[[OpenModuleModel, Any], Any]] | None = None,
+                 responses: dict[tuple[str, str], Any] | None = None,
+                 immediate_callbacks: dict[tuple[str, str], Callable[[OpenModuleModel, Any], Any]] | None = None,
                  default_timeout=1.0):
         """
         :param callbacks: callback functions executed on rpc_entry.result()
@@ -95,7 +95,7 @@ class MockRPCClient:
         self.last_request = {}
         self.default_timeout = default_timeout
 
-    def rpc_non_blocking(self, channel: str, type: str, request: [Dict, BaseModel], timeout: float = None) \
+    def rpc_non_blocking(self, channel: str, type: str, request: dict | BaseModel, timeout: float | None = None) \
             -> RPCClient.RPCEntry:
         self.last_request[(channel, type)] = request
         if timeout is None:
@@ -103,17 +103,17 @@ class MockRPCClient:
         if (channel, type) in self.callbacks:
             entry = MockRPCEntry(timeout, partial(self.callbacks[(channel, type)], request, None))
         elif (channel, type) in self.immediate_callbacks:
-            res = self.immediate_callbacks[(channel, type)](request, None).dict()
+            res = self.immediate_callbacks[(channel, type)](request, None).model_dump()
             entry = RPCClient.RPCEntry(timeout)
-            entry.response = {"status": "ok", **(res if isinstance(res, dict) else res.dict())}
+            entry.response = {"status": "ok", **(res if isinstance(res, dict) else res.model_dump())}
         else:
             entry = RPCClient.RPCEntry(timeout)
             if (channel, type) in self.responses:
-                res = self.responses.get((channel, type)).dict()
-                entry.response = {"status": "ok", **(res if isinstance(res, dict) else res.dict())}
+                res = self.responses.get((channel, type)).model_dump()
+                entry.response = {"status": "ok", **(res if isinstance(res, dict) else res.model_dump())}
         return entry
 
-    def rpc(self, channel: str, type: str, request: [Dict, BaseModel], response_type: Type[OpenModuleModel],
+    def rpc(self, channel: str, type: str, request: dict | BaseModel, response_type: type[OpenModuleModel],
             timeout: float = None) -> OpenModuleModel:
         entry = self.rpc_non_blocking(channel, type, request, timeout)
         return entry.result(response_type, timeout=timeout)

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/sentry.py

@@ -1,5 +1,4 @@
 import threading
-from typing import List
 from unittest import TestCase, mock
 
 import sentry_sdk
@@ -16,14 +15,14 @@ class SentryTestTransport(sentry_sdk.transport.Transport):
 
     def __init__(self, options=None):
         super().__init__(options)
-        self.envelopes: List[Envelope] = []
+        self.envelopes: list[Envelope] = []
         self.envelopes_lock = threading.Lock()
 
     def capture_envelope(self, envelope: Envelope):
         with self.envelopes_lock:
             self.envelopes.append(envelope)
 
-    def get_envelopes(self, clear: bool = True) -> List[Envelope]:
+    def get_envelopes(self, clear: bool = True) -> list[Envelope]:
         with self.envelopes_lock:
             envelopes = self.envelopes
             if clear:
@@ -59,9 +58,9 @@ class SentryTestMixin(TestCase):
         self.assertIsInstance(transport, SentryTestTransport)
         return transport
 
-    def _get_envelopes(self) -> List[Envelope]:
+    def _get_envelopes(self) -> list[Envelope]:
         return self.sentry_transport.get_envelopes(clear=False)
 
-    def get_sent_envelopes(self, timeout: float = 0, clear: bool = True) -> List[Envelope]:
+    def get_sent_envelopes(self, timeout: float = 0, clear: bool = True) -> list[Envelope]:
         wait_for_value(self._get_envelopes, target=[], invert_target=True, timeout=timeout)
         return self.sentry_transport.get_envelopes(clear=clear)

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/settings.py

@@ -1,6 +1,6 @@
 import time
-from enum import Enum
-from typing import Dict, Any, Optional, Type, TypeVar, Tuple
+from enum import StrEnum
+from typing import Any, TypeVar
 
 from settings_models import serialization
 
@@ -20,7 +20,7 @@ class SettingsMocker:
     """
 
     # noinspection PyMissingConstructor
-    def __init__(self, settings: Dict[Tuple[str, str], Any],
+    def __init__(self, settings: dict[tuple[str, str], Any],
                  allow_unknown_settings: bool = False, allow_wrong_values: bool = False):
         if not allow_unknown_settings:
             for setting in settings:
@@ -32,7 +32,7 @@ class SettingsMocker:
         self.settings = settings
         self.exception = None
 
-    def get(self, key: str, scope: str = "", custom_type: Optional[Type[T]] = None) -> Optional[T]:
+    def get(self, key: str, scope: str = "", custom_type: type[T] | None = None) -> T | None:
         if self.exception:
             raise self.exception
         value = self.settings.get((key, scope))
@@ -43,7 +43,7 @@ class SettingsMocker:
         except Exception:
             return None
 
-    def get_many(self, keys_with_types: Dict[str, Type[T]], scope: str = "") -> Dict[str, T]:
+    def get_many(self, keys_with_types: dict[str, type[T]], scope: str = "") -> dict[str, T]:
         if self.exception:
             raise self.exception
         else:
@@ -69,14 +69,14 @@ class SettingsRPCMocker:
     use result_mode to simulate errors
     """
 
-    class ResultMode(str, Enum):
+    class ResultMode(StrEnum):
         ok = "ok"  # successful
         error = "error"  # raise error in callback
         timeout = "timeout"  # sleep in callback for 1 second
         fail = "fail"  # return success false
         first_fail = "first_fail"  # return success false for first in get_many
 
-    def __init__(self, rpc_server: RPCServer, settings: Dict[Tuple[str, str], Any],
+    def __init__(self, rpc_server: RPCServer, settings: dict[tuple[str, str], Any],
                  allow_unknown_settings: bool = False, allow_wrong_values: bool = False):
         if not allow_unknown_settings:
             for setting in settings:

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/setup.cfg

@@ -10,8 +10,7 @@ classifier =
 	Intended Audience :: Developers
 	License :: OSI Approved :: GNU General Public License v2 (GPLv2)
 	Programming Language :: Python
-	Programming Language :: Python :: 3.7
-	Programming Language :: Python :: 3.8
+	Programming Language :: Python :: 3.12
 
 [bdist_wheel]
 universal = 1

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/signal_simulator.py

@@ -1,4 +1,4 @@
-from typing import Callable, Optional
+from typing import Callable
 
 from openmodule.models.signals import SignalMessage, TriggerSignalsRequest, TriggerSignalsResponse, \
     GetSignalValueRequest, GetSignalValueResponse, SignalType
@@ -10,15 +10,15 @@ class SignalSimulator:
         self.emit = emit
         self._signals = {}
 
-    def add_signal(self, value: bool, additional_data: Optional[dict], signal_type: SignalType,
-                   gate: Optional[str] = None, parking_area_id: Optional[str] = None,
-                   signal_name: Optional[str] = None):
+    def add_signal(self, value: bool, additional_data: dict | None, signal_type: SignalType,
+                   gate: str | None = None, parking_area_id: str | None = None,
+                   signal_name: str | None = None):
         if signal_type == SignalType.custom:
             assert signal_name is not None
             signal_msg = SignalMessage(signal=signal_name, type=signal_type, gate=gate, parking_area_id=parking_area_id,
                                        value=value, additional_data=additional_data)
         elif signal_type == SignalType.parkinglot_full:
-            signal_name = "parkinglot_full"
+            signal_name = signal_type.value
             signal_msg = SignalMessage(signal=signal_name, type=signal_type,
                                        value=value, additional_data=additional_data)
         elif signal_type == SignalType.area_full:
@@ -36,7 +36,7 @@ class SignalSimulator:
     def remove_signal(self, signal: str):
         self._signals.pop(signal, None)
 
-    def set_signal(self, signal: str, value: bool, additional_data: Optional[dict] = None):
+    def set_signal(self, signal: str, value: bool, additional_data: dict | None = None):
         self._signals[signal].value = value
         self._signals[signal].additional_data = additional_data
         self.emit(self._signals[signal])

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/utils.py

@@ -1,5 +1,5 @@
 import time
-from typing import Optional, Callable, TypeVar
+from typing import Callable, TypeVar
 
 T = TypeVar("T")
 NoTarget = object()
@@ -16,7 +16,7 @@ class DeveloperError(Exception):
     """
 
 
-def wait_for_value(getter: Callable[[], Optional[T]], target: Optional[T] = NoTarget, invert_target: bool = False,
+def wait_for_value(getter: Callable[[], T | None], target: T | None = NoTarget, invert_target: bool = False,
                    timeout: float = 3, sleep_time: float = 0.01) -> T:
     """
     Waits until the getter returns the target value or the target value.

{openmodule_test-14.2.0 → openmodule_test-15.0.0}/zeromq.py

@@ -10,8 +10,8 @@ import types
 import warnings
 from _weakrefset import WeakSet
 from contextlib import closing
-from enum import Enum
-from typing import List, Tuple, Optional, Union, Dict, Type, Callable
+from enum import StrEnum
+from typing import Callable
 from unittest import TestCase
 from uuid import uuid4, UUID
 
@@ -141,7 +141,7 @@ class TestClient(threading.Thread):
 
     _command_topic: str
     subscribed_topics: set
-    pending_topics: Dict[str, None]
+    pending_topics: dict[str, None]
     zmq_dispatcher: SubscribingMessageDispatcher
 
     pub: zmq.Socket = None
@@ -251,7 +251,7 @@ class TestClient(threading.Thread):
 
         if isinstance(_message, BaseModel):
             with self.send_lock:
-                self.pub.send_multipart((topic.encode("utf8"), orjson.dumps(_message.dict())))
+                self.pub.send_multipart((topic.encode("utf8"), orjson.dumps(_message.model_dump())))
         else:
             assert not (_message and kwargs), (
                 "pass the message dict as the first parameter, or use the kwargs, not both"
@@ -270,7 +270,7 @@ class TestClient(threading.Thread):
                 self.has_messages.clear()
             return msg
 
-    def wait_for_message(self, filter: Callable[[str, dict], bool], timeout=3) -> Tuple[str, dict]:
+    def wait_for_message(self, filter: Callable[[str, dict], bool], timeout=3) -> tuple[str, dict]:
         """
         :param filter: filter function of type (topic: str, message: dict) -> bool
         :return: tuple containing [topic, message]
@@ -323,7 +323,7 @@ class TestClient(threading.Thread):
         self.join()
 
 
-def fake_config(broker: Optional[TestBroker] = None, **kwargs):
+def fake_config(broker: TestBroker | None = None, **kwargs):
     result = {
         "NAME": "test",
         "RESOURCE": "test-resource",
@@ -357,11 +357,11 @@ class _TestRPCRequest(BaseModel):
     we do not want to depend on openmodule, this is a minimal version of the zmq message for the rpc function
     """
     timestamp: float = Field(default_factory=time.time)
-    resource: Optional[str] = None
+    resource: str | None = None
     name: str
     type: str
     rpc_id: UUID
-    request: Optional[Dict]
+    request: dict | None = None
 
     def __init__(self, **kwargs):
         resource = kwargs.pop("resource")
@@ -372,14 +372,14 @@ class _TestRPCRequest(BaseModel):
         super().__init__(resource=resource, **kwargs)
 
 
-class ZMQProcotol(str, Enum):
+class ZMQProcotol(StrEnum):
     inproc = "inproc://"
     tcp = "tcp://"
 
 
 class ZMQTestMixin(TestCase):
-    topics: List[str] = []
-    rpc_channels: List[str] = []
+    topics: list[str] = []
+    rpc_channels: list[str] = []
     protocol: ZMQProcotol = "inproc://"
 
     zmq_broker: TestBroker = None
@@ -433,7 +433,7 @@ class ZMQTestMixin(TestCase):
         and if it is connected, all previous subscriptions will also be connected
         """
         random_topic = "_test" + "".join(random.choices(string.ascii_letters, k=10))
-        dispatcher.register_handler(random_topic, BaseModel, handler, register_schema=False, match_type=False)
+        dispatcher.register_handler(random_topic, OpenModuleModel, handler, register_schema=False, match_type=False)
 
         for _ in range(self.zmq_client.startup_check_iterations):
             self.zmq_client.send(random_topic, {"type": "connection-check"})
@@ -471,25 +471,27 @@ class ZMQTestMixin(TestCase):
         super(ZMQTestMixin, self).tearDown()
         Schema.to_file()
 
-    def rpc(self, channel: str, type: str, request, response_type: Type[OpenModuleModel], timeout=3, resource=None) \
-            -> Union[str, OpenModuleModel]:
+    def rpc(self, channel: str, type: str, request, response_type: type[OpenModuleModel], timeout=3, resource=None) \
+            -> str | OpenModuleModel:
         """
         :return: the rpc response as parsed model
         """
         rpc_id = self.rpc_no_response(channel, type, request, resource)
         return self.receive_rpc_response(channel, rpc_id, response_type, timeout=timeout)
 
-    def rpc_no_response(self, channel: str, type: str, request, resource=None):
+    def rpc_no_response(self, channel: str, type_: str, request, resource=None):
         """
         :return: the rpc id, which can be used with `receive_rpc` to receive the response async
         """
         rpc_id = str(uuid4())
-        rpc_request = _TestRPCRequest(name="testclient", type=type, rpc_id=rpc_id,
+        if isinstance(request, BaseModel):
+            request = request.model_dump()
+        rpc_request = _TestRPCRequest(name="testclient", type=type_, rpc_id=rpc_id,
                                       resource=resource, request=request)
         self.zmq_client.send(f"rpc-req-{channel}", rpc_request)
         return rpc_id
 
-    def receive_rpc_response(self, channel: str, rpc_id: str, response_type: Type[OpenModuleModel], timeout=3) \
+    def receive_rpc_response(self, channel: str, rpc_id: str, response_type: type[OpenModuleModel], timeout=3) \
             -> OpenModuleModel:
         response_topic = f"rpc-rep-{channel}"
         if response_topic not in self.zmq_client.subscribed_topics:

openmodule_test-14.2.0/AUTHORS

@@ -1,11 +0,0 @@
-Bernhard Lippe <b.lippe@arivo.co>
-Kevin Koller <k.koller@accessio.at>
-Kevin Koller <k.koller@arivo.co>
-Matthias Mietschnig <m.mietschnig@arivo.co>
-Maximilian Bialek <m.bialek@arivo.co>
-Philipp Reitter <i@philipp.ninja>
-Philipp Reitter <p.reitter@accessio.at>
-Philipp Reitter <p.reitter@gmail.com>
-Stefan Bräuer <s.braeuer@arivo.co>
-Thomas Senfter <t.senfter@accessio.at>
-Thomas Senfter <t.senfter@arivo.co>

openmodule_test-14.2.0/ChangeLog

@@ -1,217 +0,0 @@
-CHANGES
-=======
-
-v14.2.0
--------
-
-* OM-1001: CostEntryData from settings models, added valid\_from and valid\_to to AccessCheckAccess and type hints for io/signals and io/inputs settings
-* docs
-* fixed testcase
-* maybe fixing openmodule\_test
-
-v14.2.0.rc0
------------
-
-* improvements for signal simulator
-* test util for signals
-* fixed testcase
-* added SignalListener
-
-v14.1.1
--------
-
-* OM-1000: added --library flag for openmodule commands so "\_\_READABLE\_NAME" and "\_\_DESCRIPTION" are not added there
-
-v14.1.0
--------
-
-* newer settings-models (non-breaking)
-* OM-901 Python 12 Support
-
-v14.0.4
--------
-
-* OM-945 Fix Trace parent in ZMQMessage
-
-v14.0.3
--------
-
-* OM-941 Sentry Bugfix
-
-v14.0.2
--------
-
-* Sentry improvements
-
-v14.0.1
--------
-
-* fixed sentry release name
-
-v14.0.0
--------
-
-* Add breaking changes to docs
-* OM-693 Openmodule sentry v2
-* Update known\_issues.md [skip ci]
-
-v13.6.0
--------
-
-* OM-697 OpenModule Verbesserungen
-
-v13.5.0
--------
-
-* document breaking changes
-* OM-405: remove database imports from non-database services + isolate migration process to exclude alembic import in the main process
-
-v13.4.0
--------
-
-* Om 164: settings-models update for enforcment settings changes
-
-v13.3.0
--------
-
-* [OM-359] cleanup helper function
-
-v13.2.0
--------
-
-* OM 187 Alembic migration test mixin
-* add a testcase for expiring session data while adding new models (noticed in OM-327)
-* OM-184 Openmodule Database: Migration Backups and Fix in Operations "pre\_downgrade()" and "post\_downgrade()"
-* Aktualisierung der Dokumentation
-* OM-255
-
-v13.1.4
--------
-
-* fixed missing leave time in got better vehicle fake leave
-
-v13.1.3
--------
-
-* [OM-134] small changes in AccessCheck Models
-
-v13.1.2
--------
-
-* [OM-117] fixed error output on RPCs not sent by this RPCClient
-
-v13.1.1
--------
-
-* fixed bugs in edge cases in PresenceListener
-
-v13.1.0
--------
-
-* fixed testcase race condition
-* improvements for PresenceSimulator and new commit to fix pipeline
-
-v13.1.0.rc1
------------
-
-* settings model update
-
-v13.1.0.rc0
------------
-
-* OM-61 Openmodule Anpassungen für Access Events
-* [OM-56] added enter\_time and leave\_time to vehicle and implemented presence message changes
-* fixes and refactoring of presencelistener
-* Resolve OM-78 improved KVStore performance
-* fixes INBOX-2510
-
-v13.0.3
--------
-
-* added garage\_settings mode "barrier\_bypass" in settings models removal of some unused imports
-
-v13.0.2
--------
-
-* added vehicle\_id to AccessCheckRequest removed unused code (AccessServiceWithSessions, AccessTime) fix in docs
-
-v13.0.1
--------
-
-* DEV-6522 Quick Task: Refactor für KVStore Update
-
-v13.0.0
--------
-
-* DEV-6382 KVSync Änderungen für mehrere Datenbank Models und DEV-6432 Access Service Anpassungen
-
-v12.1.5
--------
-
-* fixed crash when receiving broken messages
-
-v12.1.4
--------
-
-* fixed bug in presence listener with delayed forward and backward messages
-* removed invalid volumn check from column rendering, because base.meta is sufficient
-* fixed bug in the csv export documentation
-
-v12.1.3
--------
-
-* docs
-* use hashlib to compute hash
-
-v12.1.2
--------
-
-* databox changed to rpc\_no\_blocking -> no exceptions and no waiting added immediate\_callbacks to MockRPCClient
-
-v12.1.1
--------
-
-* trigger requirements update for changes in settings-models
-* docs and additional assertion in databox upload function
-
-v12.1.0
--------
-
-* additional test cases for export\_iterator
-* first version of export iterator
-
-v12.0.0
--------
-
-* SettingsProvider rework and small changes
-* docs update
-* settings model 1.0
-* small fix in test utils
-
-v12.0.0.rc1
------------
-
-* removed debug entries from kv store removed cost\_entries from AccessCheckAccess
-
-v12.0.0.rc0
------------
-
-* Removed parking\_area\_id from AccessCheckAccess changed gate permission check in AccessService to new behavior
-
-v11.1.1
--------
-
-* added state parameter to VehicleBuilder.lpr function
-
-v11.1.0
--------
-
-* csv export library, databox upload and schedule library tips
-* removed mock rpcs from schema
-
-v11.0.3
--------
-
-* Fixed typo, added compute\_id as label to all metrics, convert all label values to string
-* touch to get rid of skip ci on my commit
-* docs update [skip ci]

openmodule_test-14.2.0/openmodule_test.egg-info/pbr.json

@@ -1 +0,0 @@
-{"git_version": "3b899ae", "is_release": true}

openmodule_test-14.2.0/requirements.txt

@@ -1,2 +0,0 @@
-multiprocessing_logging
-freezegun