openmodule 14.1.1__tar.gz → 14.2.0__tar.gz

{openmodule-14.1.1 → openmodule-14.2.0}/ChangeLog

@@ -1,6 +1,22 @@
 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
 -------
 
@@ -181,8 +197,6 @@ v12.0.0.rc0
 -----------
 
 * Removed parking\_area\_id from AccessCheckAccess changed gate permission check in AccessService to new behavior
-* removed Gate and GateType (now from settings models)
-* fixed testcases and removed backend (deprecated in v11)
 
 v11.1.1
 -------
@@ -201,8 +215,3 @@ 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]
-* main test function deprecated and documentation for main tests added
-
-v11.0.2
--------
-

{openmodule-14.1.1 → openmodule-14.2.0}/PKG-INFO

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

{openmodule-14.1.1 → openmodule-14.2.0}/docs/testing.md

@@ -267,6 +267,23 @@ presence_sim.enter(self.presence_sim.vehicle().lpr("A", "G ARIVO1"))
 on_enter.wait_for_call()
 ```
 
+### SignalSimulator
+
+Util class for simulating signals
+
+```python
+signal_simulator = SignalSimulator(lambda x: core().publish(x, "signal"))
+# add_signal registers signals for RPC callbacks but does not emit signal message
+signal_simulator.add_signal(False, None, SignalType.open, gate="einfahrt")  # generates correct signal einfahrt-open
+signal_simulator.add_signal(True, {"a": "b"}, SignalType.custom, signal_name="custom1")
+# (change and) emit signals message
+signal_simulator.set_signal("einfahrt-open", True)
+signal_simulator.set_signal("custom1", True, {"a": "c"})
+# register signal RPCs with callbacks from signal_simulator, which will automatically answer with correct response
+rpc_server.register_handler("signal", "trigger_signals", TriggerSignalsRequest, TriggerSignalsResponse, 
+                            signal_simulator.trigger_signal_callback, register_schema=False)
+```
+
 ### MockRPCClient
 
 This is a fake RPCClient where you can either specify callback functions for RPCs or even the responses.

{openmodule-14.1.1 → openmodule-14.2.0}/docs/utils.md

@@ -15,7 +15,28 @@ presence_listener = PresenceListener(core.messages)
 presence_listener.on_enter.append(some_function)
 ```
 
-### Databox Upload
+## Signals
+
+Helper class for listening on signals. 
+```python
+from openmodule.utils.signal_listener import SignalListener, FilterType
+
+signal_listener = SignalListener(core.messages, core.rpc_client)
+# register a listener for a signal with a filter_type specifying when the function should be called and optional tag
+signal_listener.add_listener("gate1-open", FilterType.any_edge, some_function, tag="tag1")
+signal_listener.add_listener("gate2-present_decision", FilterType.any_change, some_function2, tag="tag2")
+# get the current value (and additional_data) of a signal, if unknown then RPC is called to get value
+value = signal_listener.get_value("gate1-open")  
+value, additional_data = signal_listener.get_value_and_additional_data("gate1-open")  
+# trigger resending of signals via trigger_signals RPC for registered signals with specific tag 
+# or all registered signals if tag is None
+signal_listener.trigger_signals(tag="tag1")
+# remove listeners with specific tag or all if tag is None
+signal_listener.remove_listener(tag="tag1")
+```
+
+
+## Databox Upload
 
 In the openmodule we have a utils function to simplify the upload with the databox service. The prerequisite is, 
 that the upload folder `/data/om_service_databox_1/upload` is mounted correctly in the compose file to the `settings.DATABOX_UPLOAD_DIR` (default: `/upload`)

{openmodule-14.1.1 → openmodule-14.2.0}/openmodule/models/access_service.py

@@ -65,12 +65,17 @@ class AccessCheckAccess(OpenModuleModel):
     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: Optional[datetime]     # access is valid from this time. Only used for reservations
+    valid_to: Optional[datetime]       # access is valid until this time. Only used for reservations
 
     accepted: bool                     # if access service decided access can enter
     reject_reason: Optional[AccessCheckRejectReason]  # 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: Optional[str]
 
+    _tz_valid_from = timezone_validator("valid_from")
+    _tz_valid_to = timezone_validator("valid_to")
+
     @root_validator(skip_on_failure=True)
     def root_validation(cls, values):
         # if category is handauf, medium_display_name must be set

{openmodule-14.1.1 → openmodule-14.2.0}/openmodule/models/base.py

@@ -5,16 +5,17 @@ from datetime import datetime
 from decimal import Decimal
 from enum import Enum
 from json.encoder import ESCAPE_ASCII
-from typing import Optional, Union
+from typing import Optional, Union, Dict
 
 import orjson
 import zmq
 from dateutil.tz import UTC
-from pydantic import Field, BaseModel, validator, root_validator
+from pydantic import Field, BaseModel, validator
 from pydantic.main import ROOT_KEY
 
 from openmodule import config, sentry
 from openmodule.config import settings
+from settings_models.settings.common import CostEntryData as SettingsModelsCostEntryData
 
 
 def _donotuse(v, *, default):
@@ -171,20 +172,5 @@ class Gateway(OpenModuleModel):
         return f"{self.gate}/{self.direction}"
 
 
-class CostEntryData(OpenModuleModel):
-    entry_type: str
-    value: Optional[Union[int, str]]
-    group: Optional[str]
-    account_id: str
-    source: Optional[str]  # if None, source will be set to service name on default: e.g. "service_iocontroller"
-    source_id: Optional[str]
-    idempotency_key: Optional[str]
-
-    @root_validator
-    def set_value_type(cls, values):
-        if values["entry_type"] in ["rate_change", "rate_validation", "partial_rate_change"]:
-            values["value"] = str(values["value"])
-        elif values["entry_type"] in ["static_cost", "pending_static_cost", "amount_validation", "time_validation"
-                                      "payment"]:
-            values["value"] = int(values["value"])
-        return values
+# to be not breaking
+CostEntryData = SettingsModelsCostEntryData

openmodule-14.2.0/openmodule/models/signals.py

@@ -0,0 +1,43 @@
+from enum import Enum
+from typing import Optional, Dict, Union, List
+
+from openmodule.models.base import ZMQMessage, OpenModuleModel
+
+
+class SignalType(str, Enum):
+    permanently_closed = "permanently_closed"
+    shortterm_full = "shortterm_full"
+    open = "open"
+    present_raw = "present_raw"
+    present_decision = "present_decision"
+    traffic_light_green = "traffic_light_green"
+    traffic_light_red = "traffic_light_red"
+    area_full = "area_full"
+    parkinglot_full = "parkinglot_full"
+    custom = "custom"
+
+
+class SignalMessage(ZMQMessage):
+    signal: str
+    type: Union[SignalType, str]  # union so we can add new types without updating all services using signals
+    gate: Optional[str]
+    parking_area_id: Optional[str]
+    value: bool
+    additional_data: Optional[Dict]
+
+
+class GetSignalValueRequest(OpenModuleModel):
+    signal: str
+
+
+class GetSignalValueResponse(OpenModuleModel):
+    value: bool
+    additional_data: Optional[Dict]
+
+
+class TriggerSignalsRequest(OpenModuleModel):
+    signals: List[str]  # list of signals which current value should be sent
+
+
+class TriggerSignalsResponse(OpenModuleModel):
+    success: bool

{openmodule-14.1.1 → openmodule-14.2.0}/openmodule/utils/settings.py

@@ -10,6 +10,7 @@ from settings_models.settings.device_keys import PairingKey, Certificate, Otp
 from settings_models.settings.enforcement import EnforcementSettings
 from settings_models.settings.gate_control import GateMode, DayMode
 from settings_models.settings.intercom import IntercomSettings
+from settings_models.settings.io import SignalDefinitions, InputDefinitions
 
 from openmodule import sentry
 from openmodule.core import core
@@ -195,6 +196,14 @@ class SettingsProvider:
     def get(self, key: Literal["feature_flags"]) -> dict:  # pragma: no cover
         ...
 
+    @overload
+    def get(self, key: Literal["io/signals"]) -> SignalDefinitions:  # pragma: no cover
+        ...
+
+    @overload
+    def get(self, key: Literal["io/inputs"]) -> InputDefinitions:  # pragma: no cover
+        ...
+
     def get(self, key: str, scope: str = "", custom_type: Optional[Type[T]] = None) -> Optional[T]:
         key_scope = join_key(key, scope)
         with self._cache_lock:

openmodule-14.2.0/openmodule/utils/signal_listener.py

@@ -0,0 +1,174 @@
+import logging
+import threading
+from enum import Enum
+from typing import Optional, Dict, Callable, List, Tuple
+
+import zmq
+from openmodule.dispatcher import MessageDispatcher
+from openmodule.models.signals import SignalMessage, SignalType, GetSignalValueRequest, GetSignalValueResponse, \
+    TriggerSignalsRequest, TriggerSignalsResponse
+from openmodule.rpc import RPCClient
+
+
+class ChangeType(str, Enum):
+    rising_edge = "rising_edge"  # value changed from 0 to 1
+    falling_edge = "falling_edge"  # value change from 1 to 0
+    data_change = "data_change"  # value is 1, additional data is set and no rising_edge
+    none = "none"  # value unchanged and not data_change
+
+
+class FilterType(str, Enum):
+    rising_edge = "rising_edge"  # only rising edges
+    falling_edge = "falling_edge"  # only falling edges
+    any_edge = "any_edge"  # rising and falling edges
+    data_change = "data_change"  # all messages with value true (including rising edges) and additional_data set
+    any_change = "any_change"  # rising and falling edges and additional_data changes
+    any = "any"  # no filtering of changes (also when nothing changes)
+
+    def matches_change(self, change_type: ChangeType) -> bool:
+        if self.value == FilterType.rising_edge:
+            return change_type == ChangeType.rising_edge
+        elif self.value == FilterType.falling_edge:
+            return change_type == ChangeType.falling_edge
+        elif self.value == FilterType.any_edge:
+            return change_type in [ChangeType.rising_edge, ChangeType.falling_edge]
+        elif self.value == FilterType.data_change:
+            return change_type in [ChangeType.rising_edge, ChangeType.data_change]
+        elif self.value == FilterType.any_change:
+            return change_type != ChangeType.none
+        elif self.value == FilterType.any:
+            return True
+        else:
+            raise TypeError("unknown change type")
+
+
+class Signal:
+    def __init__(self, signal_message: SignalMessage, change_type: ChangeType):
+        self.signal: str = signal_message.signal
+        self.type: SignalType = signal_message.type
+        self.value: bool = signal_message.value
+        self.additional_data: Optional[Dict] = signal_message.additional_data
+        self.gate: Optional[str] = signal_message.gate
+        self.parking_area_id: Optional[str] = signal_message.parking_area_id
+        self.change_type: ChangeType = change_type
+
+
+class Listener:
+    def __init__(self, signal_name: str, filter_type: FilterType, callback: Callable[[Signal], None],
+                 tag: Optional[str]):
+        self.signal_name = signal_name
+        self.filter_type = filter_type
+        self.callback = callback
+        self.tag = tag
+
+    def matches(self, signal_name: str, change_type: ChangeType) -> bool:
+        return self.signal_name == signal_name and self.filter_type.matches_change(change_type)
+
+
+class SignalListener:
+    def __init__(self, dispatcher: MessageDispatcher, rpc_client: RPCClient):
+        assert not dispatcher.is_multi_threaded, (
+            "you cannot use a multithreaded message dispatcher for the SignalListener. It is highly reliant "
+            "on receiving messages in the correct order!"
+        )
+        self.current_states: Dict[str, Tuple[bool, Optional[dict]]] = dict()
+        self.listeners: List[Listener] = list()
+        self.listeners_lock = threading.Lock()
+        self.log = logging.getLogger(self.__class__.__name__)
+        self.rpc_client = rpc_client
+        dispatcher.register_handler("signal", SignalMessage, self._on_signal_message, match_type=False)
+
+    def add_listener(self, signal_name: str, filter_type: FilterType, callback: Callable[[Signal], None],
+                     tag: Optional[str]):
+        """
+        Calls the given callback method whenever a signal message is received and the circumstances fulfill the given
+        filter_type
+        :param signal_name: signal name that needs to experience a rising edge to call the callback
+        :param filter_type: One of the available FilterType
+        :param callback: the function that is called when a rising edge occurs on listen_to
+        :param tag: a tag to group listeners for later removal
+        """
+        with self.listeners_lock:
+            self.listeners.append(Listener(signal_name, filter_type, callback, tag))
+
+    def remove_listener(self, tag: Optional[str] = None):
+        """
+        :param tag: all listeners with this tag are removed. If no tag is given, all listeners are removed
+        """
+        with self.listeners_lock:
+            self.listeners = [listener for listener in self.listeners if tag is not None and listener.tag != tag]
+
+    def get_value(self, signal_name: str) -> bool:
+        """
+        returns the current value of a signal.
+        If no value is available yet, it will be requested via rpc.
+        If no answer to RPC, log exception/error and return False
+        :param signal_name: Name of signal to get value from
+        """
+        return self.get_value_and_additional_data(signal_name)[0]
+
+    def get_value_and_additional_data(self, signal_name: str) -> Tuple[bool, Optional[dict]]:
+        """
+        returns the current value of a signal including additional_data.
+        If no value is available yet, it will be requested via rpc.
+        If no answer to RPC, log exception/error and return (False, None)
+        :param signal_name: Name of signal to get value from
+        """
+        if signal_name not in self.current_states:
+            try:
+                res = self.rpc_client.rpc("signal", "get_value", GetSignalValueRequest(signal=signal_name),
+                                          GetSignalValueResponse, timeout=1.0)
+                self.current_states[signal_name] = (res.value, res.additional_data)
+            except RPCClient.Exception:
+                self.log.exception("Error while getting signal value. Assuming False.")
+                self.current_states[signal_name] = (False, None)
+
+        return self.current_states[signal_name]
+
+    def trigger_signals(self, tag: Optional[str] = None, timeout: float = 3.0) -> bool:
+        """
+        :param tag: if given, only signals of listeners with given tag are triggered
+        """
+        try:
+            with self.listeners_lock:
+                if tag is None:
+                    signals_to_trigger = list({l.signal_name for l in self.listeners})
+                else:
+                    signals_to_trigger = list({l.signal_name for l in self.listeners if l.tag == tag})
+            res = self.rpc_client.rpc("signal", "trigger_signals", TriggerSignalsRequest(signals=signals_to_trigger),
+                                      TriggerSignalsResponse, timeout)
+            if not res.success:
+                self.log.error("Failed to trigger all registered signals.")
+            return res.success
+        except RPCClient.Exception:
+            self.log.exception("Error while triggering signals.")
+            return False
+
+    def _on_signal_message(self, message: SignalMessage):
+        """
+        This handler receives all IO Messages, saves any changes and calls any listeners registered in the IoListener
+        """
+        old_state = self.current_states.get(message.signal)
+        old_value = old_state and old_state[0]  # only value without additional_data
+        self.current_states[message.signal] = (message.value, message.additional_data)
+        if old_value != message.value and message.value:
+            change_type = ChangeType.rising_edge
+        elif old_value != message.value:
+            change_type = ChangeType.falling_edge
+        elif message.value and message.additional_data:
+            change_type = ChangeType.data_change
+        else:
+            change_type = ChangeType.none
+        with self.listeners_lock:
+            for listener in self.listeners:
+                """
+                Handles the registered listeners the same as the dispatcher.
+                Is copied here because all messages are needed to keep current_states up to date.            
+                """
+                if listener.matches(message.signal, change_type):
+                    try:
+                        listener.callback(Signal(message, change_type))
+                    except zmq.ContextTerminated:
+                        raise
+                    except Exception as e:
+                        self.log.exception("Error in signal callback")

{openmodule-14.1.1 → openmodule-14.2.0}/openmodule.egg-info/PKG-INFO

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

{openmodule-14.1.1 → openmodule-14.2.0}/openmodule.egg-info/SOURCES.txt

@@ -74,6 +74,7 @@ openmodule/models/presence.py
 openmodule/models/privacy.py
 openmodule/models/rpc.py
 openmodule/models/settings.py
+openmodule/models/signals.py
 openmodule/models/validation.py
 openmodule/models/vehicle.py
 openmodule/rpc/__init__.py
@@ -96,6 +97,7 @@ openmodule/utils/package_reader.py
 openmodule/utils/presence.py
 openmodule/utils/schema.py
 openmodule/utils/settings.py
+openmodule/utils/signal_listener.py
 openmodule/utils/translation.py
 openmodule/utils/validation.py
 openmodule_commands/__init__.py
@@ -121,6 +123,7 @@ openmodule_test/sentry.py
 openmodule_test/settings.py
 openmodule_test/setup.cfg
 openmodule_test/setup.py
+openmodule_test/signal_simulator.py
 openmodule_test/utils.py
 openmodule_test/zeromq.py
 tests/__init__.py
@@ -162,6 +165,7 @@ tests/test_utils_misc_functions.py
 tests/test_utils_package_reader.py
 tests/test_utils_presence.py
 tests/test_utils_settings.py
+tests/test_utils_signal.py
 tests/test_utils_validation.py
 tests/test_utils_vehicle.py
 tests/invalid_database/alembic.ini

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

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

{openmodule-14.1.1 → openmodule-14.2.0}/openmodule.egg-info/requires.txt

@@ -9,7 +9,7 @@ alembic<2,>=1.5.4
 requests~=2.32
 python-dateutil>=2.7.2
 python-dotenv==0.15.0
-arivo-settings_models<2,>=1.2.0
+arivo-settings_models<2,>=1.3.0
 arivo-schedule~=1.2.2
 
 [commands]

openmodule-14.2.0/openmodule_test/signal_simulator.py

@@ -0,0 +1,58 @@
+from typing import Callable, Optional
+
+from openmodule.models.signals import SignalMessage, TriggerSignalsRequest, TriggerSignalsResponse, \
+    GetSignalValueRequest, GetSignalValueResponse, SignalType
+from openmodule.rpc import RPCClient
+
+
+class SignalSimulator:
+    def __init__(self, emit: Callable[[SignalMessage], None]):
+        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):
+        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_msg = SignalMessage(signal=signal_name, type=signal_type,
+                                       value=value, additional_data=additional_data)
+        elif signal_type == SignalType.area_full:
+            assert parking_area_id is not None
+            signal_name = f"{parking_area_id}-area_full"
+            signal_msg = SignalMessage(signal=signal_name, type=signal_type,  parking_area_id=parking_area_id,
+                                       value=value, additional_data=additional_data)
+        else:
+            assert gate is not None
+            signal_name = f"{gate}-{signal_type}"
+            signal_msg = SignalMessage(signal=signal_name, type=signal_type,  gate=gate,
+                                       value=value, additional_data=additional_data)
+        self._signals[signal_msg.signal] = signal_msg
+
+    def remove_signal(self, signal: str):
+        self._signals.pop(signal, None)
+
+    def set_signal(self, signal: str, value: bool, additional_data: Optional[dict] = None):
+        self._signals[signal].value = value
+        self._signals[signal].additional_data = additional_data
+        self.emit(self._signals[signal])
+
+    def trigger_signal_callback(self, request: TriggerSignalsRequest, _):
+        res = TriggerSignalsResponse(success=True)
+        for signal in request.signals:
+            if signal in self._signals:
+                self.emit(self._signals[signal])
+            else:
+                res.success = False
+        return res
+
+    def get_value_callback(self, request: GetSignalValueRequest, _):
+        if request.signal in self._signals:
+            return GetSignalValueResponse(value=self._signals[request.signal].value,
+                                          additional_data=self._signals[request.signal].additional_data)
+        else:
+            raise RPCClient.TimeoutError()

{openmodule-14.1.1 → openmodule-14.2.0}/requirements.txt

@@ -9,5 +9,5 @@ alembic>=1.5.4,<2
 requests~=2.32
 python-dateutil>=2.7.2
 python-dotenv==0.15.0
-arivo-settings_models>=1.2.0,<2
+arivo-settings_models>=1.3.0,<2
 arivo-schedule~=1.2.2

{openmodule-14.1.1 → openmodule-14.2.0}/tests/test_model.py

@@ -1,5 +1,4 @@
 import json
-
 from datetime import datetime, timedelta
 from typing import Optional
 from unittest import TestCase
@@ -8,8 +7,7 @@ import freezegun
 import orjson
 from pydantic import ValidationError
 
-from openmodule import sentry
-from openmodule.models.base import OpenModuleModel, ZMQMessage, Gateway, timezone_validator, CostEntryData
+from openmodule.models.base import OpenModuleModel, ZMQMessage, Gateway, timezone_validator
 
 
 class TestModel(OpenModuleModel):
@@ -138,11 +136,3 @@ class ZMQMessageTestCase(TestCase):
 
         res1.pop("timestamp")
         self.assertDictEqual(res1, {"name": "tä\nst", "type": "tö\tst"})
-
-
-class CostEntryDataTextCase(TestCase):
-    def test_type_parsing(self):
-        res = CostEntryData.parse_raw(b'{"entry_type": "static_cost", "value": 10, "account_id": "0"}')
-        self.assertTrue(isinstance(res.value, int))
-        res = CostEntryData.parse_raw(b'{"entry_type": "rate_change", "value": "10", "account_id": "0"}')
-        self.assertTrue(isinstance(res.value, str))