fix test_ignore_disabled

inputremapper/configs/input_config.py

@@ -23,7 +23,7 @@
 from typing import Tuple, Iterable, Union, List, Dict, Optional, Hashable, TypeAlias
 
 from evdev import ecodes
-from evdev._ecodes import EV_ABS, EV_KEY
+from evdev._ecodes import EV_ABS, EV_KEY, EV_REL
 
 from inputremapper.input_event import InputEvent
 from pydantic import BaseModel, root_validator, validator
@@ -73,6 +73,8 @@ def __repr__(self):
 
     @classmethod
     def abs(cls, code, analog_threshold, origin_hash):
+        """Create a new InputConfig object for an abs input like joysticks."""
+        # TODO analog_threshold default None and move to last param?
         return InputConfig(
             type=EV_ABS,
             code=code,
@@ -82,12 +84,22 @@ def abs(cls, code, analog_threshold, origin_hash):
 
     @classmethod
     def key(cls, code, origin_hash):
+        """Create a new InputConfig object for a key input."""
         return InputConfig(
             type=EV_KEY,
             code=code,
             origin_hash=origin_hash,
         )
 
+    @classmethod
+    def rel(cls, code, origin_hash):
+        """Create a new InputConfig object for a rel input like mouse movements."""
+        return InputConfig(
+            type=EV_REL,
+            code=code,
+            origin_hash=origin_hash,
+        )
+
     @property
     def input_match_hash(self) -> Hashable:
         """a Hashable object which is intended to match the InputConfig with a
@@ -340,6 +352,16 @@ def empty_combination(cls) -> InputCombination:
         """
         return cls([{"type": 99, "code": 99, "analog_threshold": 99}])
 
+    @classmethod
+    def from_tuples(cls, *tuples):
+        """Construct an InputCombination from (type, code, value) tuples."""
+        return cls(
+            [
+                {"type": tuple_[0], "code": tuple_[1], "analog_threshold": tuple_[2]}
+                for tuple_ in tuples
+            ]
+        )
+
     def is_problematic(self) -> bool:
         """Is this combination going to work properly on all systems?"""
         if len(self) <= 1:

inputremapper/injection/context.py

@@ -19,6 +19,7 @@
 
 
 """Stores injection-process wide information."""
+
 from __future__ import annotations
 
 from collections import defaultdict
@@ -111,7 +112,13 @@ def get_entry_points(self, input_event: InputEvent) -> List[NotifyCallback]:
         input_match_hash = input_event.input_match_hash
         callbacks = self._notify_callbacks[input_match_hash]
         if len(callbacks) == 0:
-            logger.warning("No NotifyCallbacks set for %s", input_match_hash)
+            logger.debug("No NotifyCallbacks set for %s", input_match_hash)
+
+        # TODO logs appearing when hitting forwarded keys
+        """
+        22:51:45.774591 68627 service WARNING context.py:114: No NotifyCallbacks set for (1, 16, 'cba0d7f555a960fabbad51fdb8f28b70')
+        22:51:45.774713 68627 service ERROR event_reader.py:127: No NotifyCallbacks set
+        """
 
         return callbacks
 

inputremapper/injection/event_reader.py

@@ -112,7 +112,10 @@ async def read_loop(self) -> AsyncIterator[evdev.InputEvent]:
                 yield event
 
     def send_to_handlers(self, event: InputEvent) -> bool:
-        """Send the event to callback."""
+        """Send the event to the NotifyCallbacks.
+
+        Return if anyone took care of the event.
+        """
         if event.type == evdev.ecodes.EV_MSC:
             return False
 
@@ -122,10 +125,6 @@ def send_to_handlers(self, event: InputEvent) -> bool:
         results = set()
         notify_callbacks = self.context.get_entry_points(event)
 
-        if len(notify_callbacks) == 0:
-            # There definitely has to be a handler if the mapping is not empty
-            logger.error("No NotifyCallbacks set")
-
         if notify_callbacks:
             for notify_callback in notify_callbacks:
                 results.add(notify_callback(event, source=self._source))

inputremapper/injection/mapping_handlers/axis_switch_handler.py

@@ -122,7 +122,7 @@ def _handle_key_input(self, event: InputEvent):
         if self._map_axis.type == evdev.ecodes.EV_ABS:
             # send the last cached value so that the abs axis
             # is at the correct position
-            logger.debug("starting axis for", self.mapping.input_combination)
+            logger.debug("starting axis for %s", self.mapping.input_combination)
             event = InputEvent(
                 0,
                 0,

inputremapper/input_event.py

@@ -21,7 +21,7 @@
 
 import enum
 from dataclasses import dataclass
-from typing import Tuple, Optional, Hashable
+from typing import Tuple, Optional, Hashable, Literal
 
 import evdev
 from evdev import ecodes
@@ -97,10 +97,13 @@ def from_tuple(
         cls, event_tuple: Tuple[int, int, int], origin_hash: Optional[str] = None
     ) -> InputEvent:
         """Create a InputEvent from a (type, code, value) tuple."""
+        # TODO use this as rarely as possible. Construct objects as early as possible
+        #  instead.
         if len(event_tuple) != 3:
             raise TypeError(
                 f"failed to create InputEvent {event_tuple = } must have length 3"
             )
+
         return cls(
             0,
             0,
@@ -110,6 +113,45 @@ def from_tuple(
             origin_hash=origin_hash,
         )
 
+    @classmethod
+    def abs(cls, code: int, value: int, origin_hash: str):
+        """Create an abs event, like joystick movements."""
+        return cls(
+            0,
+            0,
+            ecodes.EV_ABS,
+            code,
+            value,
+            origin_hash=origin_hash,
+        )
+
+    @classmethod
+    def rel(cls, code: int, value: int, origin_hash: str):
+        """Create a rel event, like mouse movements."""
+        return cls(
+            0,
+            0,
+            ecodes.EV_REL,
+            code,
+            value,
+            origin_hash=origin_hash,
+        )
+
+    @classmethod
+    def key(cls, code: int, value: Literal[0, 1], origin_hash: str):
+        """Create a key event, like keyboard keys or gamepad buttons.
+
+        A value of 1 means "press", a value of 0 means "release".
+        """
+        return cls(
+            0,
+            0,
+            ecodes.EV_KEY,
+            code,
+            value,
+            origin_hash=origin_hash,
+        )
+
     @property
     def type_and_code(self) -> Tuple[int, int]:
         """Event type, code."""

tests/integration/test_gui.py

@@ -916,10 +916,10 @@ def test_hat_switch(self):
         gtk_iteration()
 
         # it should be possible to add all of them
-        ev_1 = (EV_ABS, evdev.ecodes.ABS_HAT0X, -1)
-        ev_2 = (EV_ABS, evdev.ecodes.ABS_HAT0X, 1)
-        ev_3 = (EV_ABS, evdev.ecodes.ABS_HAT0Y, -1)
-        ev_4 = (EV_ABS, evdev.ecodes.ABS_HAT0Y, 1)
+        ev_1 = InputEvent.from_tuple((EV_ABS, evdev.ecodes.ABS_HAT0X, -1))
+        ev_2 = InputEvent.from_tuple((EV_ABS, evdev.ecodes.ABS_HAT0X, 1))
+        ev_3 = InputEvent.from_tuple((EV_ABS, evdev.ecodes.ABS_HAT0Y, -1))
+        ev_4 = InputEvent.from_tuple((EV_ABS, evdev.ecodes.ABS_HAT0Y, 1))
 
         def add_mapping(event_tuple, symbol) -> InputCombination:
             """adds mapping and returns the expected input combination"""
@@ -977,10 +977,10 @@ def test_combination(self):
         gtk_iteration()
 
         # it should be possible to write a combination
-        ev_1 = (EV_KEY, evdev.ecodes.KEY_A, 1)
-        ev_2 = (EV_ABS, evdev.ecodes.ABS_HAT0X, 1)
-        ev_3 = (EV_KEY, evdev.ecodes.KEY_C, 1)
-        ev_4 = (EV_ABS, evdev.ecodes.ABS_HAT0X, -1)
+        ev_1 = InputEvent.from_tuple((EV_KEY, evdev.ecodes.KEY_A, 1))
+        ev_2 = InputEvent.from_tuple((EV_ABS, evdev.ecodes.ABS_HAT0X, 1))
+        ev_3 = InputEvent.from_tuple((EV_KEY, evdev.ecodes.KEY_C, 1))
+        ev_4 = InputEvent.from_tuple((EV_ABS, evdev.ecodes.ABS_HAT0X, -1))
         combination_1 = (ev_1, ev_2, ev_3)
         combination_2 = (ev_2, ev_1, ev_3)
 

tests/lib/fixtures.py

@@ -312,6 +312,16 @@ def get_combination_config(
     *event_tuples: Tuple[int, int] | Tuple[int, int, int]
 ) -> Iterable[Dict[str, int]]:
     """Convenient function to get an iterable of dicts, InputEvent.event_tuples."""
+    # TODO replace usages of
+    #  get_key_mapping(
+    #     InputCombination(get_combination_config
+    # with
+    #              get_key_mapping(
+    #                 input_combination=InputCombination.from_tuples(*combi_1),
+    #                 output_symbol="b",
+    #             )
+    # ?
+    # TODO replace all tuples with proper objects
     for event in event_tuples:
         if len(event) == 3:
             yield {"type": event[0], "code": event[1], "analog_threshold": event[2]}
@@ -321,37 +331,40 @@ def get_combination_config(
             raise TypeError
 
 
-def get_ui_mapping(combination=None, target_uinput="keyboard", output_symbol="a"):
+def get_ui_mapping(input_combination=None, target_uinput="keyboard", output_symbol="a"):
     """Convenient function to get a valid mapping."""
     from inputremapper.configs.mapping import UIMapping
 
-    if not combination:
-        combination = get_combination_config((99, 99))
+    if not input_combination:
+        input_combination = get_combination_config((99, 99))
 
     return UIMapping(
-        input_combination=combination,
+        input_combination=input_combination,
         target_uinput=target_uinput,
         output_symbol=output_symbol,
     )
 
 
-def get_key_mapping(combination=None, target_uinput="keyboard", output_symbol="a"):
+def get_key_mapping(
+    input_combination=None, target_uinput="keyboard", output_symbol="a"
+):
     """Convenient function to get a valid mapping."""
     from inputremapper.configs.mapping import Mapping
 
-    if not combination:
-        combination = [{"type": 99, "code": 99, "analog_threshold": 99}]
+    if not input_combination:
+        input_combination = [{"type": 99, "code": 99, "analog_threshold": 99}]
 
     return Mapping(
-        input_combination=combination,
+        input_combination=input_combination,
         target_uinput=target_uinput,
         output_symbol=output_symbol,
     )
 
 
 def new_event(type, code, value, timestamp=None, offset=0):
-    """Create a new input_event."""
-    from tests.lib.patches import InputEvent
+    """Create a new InputEvent."""
+    # TODO probably deprecated with InputEvent.abs and InputEvent.key
+    from inputremapper.input_event import InputEvent
 
     if timestamp is None:
         timestamp = time.time() + offset
@@ -372,27 +385,30 @@ def prepare_presets():
 
     preset1 = Preset(get_preset_path("Foo Device", "preset1"))
     preset1.add(
-        get_key_mapping(combination=get_combination_config((1, 1)), output_symbol="b")
+        get_key_mapping(
+            input_combination=get_combination_config((1, 1)),
+            output_symbol="b",
+        )
     )
-    preset1.add(get_key_mapping(combination=get_combination_config((1, 2))))
+    preset1.add(get_key_mapping(input_combination=get_combination_config((1, 2))))
     preset1.save()
 
     time.sleep(0.1)
     preset2 = Preset(get_preset_path("Foo Device", "preset2"))
-    preset2.add(get_key_mapping(combination=get_combination_config((1, 3))))
-    preset2.add(get_key_mapping(combination=get_combination_config((1, 4))))
+    preset2.add(get_key_mapping(input_combination=get_combination_config((1, 3))))
+    preset2.add(get_key_mapping(input_combination=get_combination_config((1, 4))))
     preset2.save()
 
     # make sure the timestamp of preset 3 is the newest,
     # so that it will be automatically loaded by the GUI
     time.sleep(0.1)
     preset3 = Preset(get_preset_path("Foo Device", "preset3"))
-    preset3.add(get_key_mapping(combination=get_combination_config((1, 5))))
+    preset3.add(get_key_mapping(input_combination=get_combination_config((1, 5))))
     preset3.save()
 
     with open(get_config_path("config.json"), "w") as file:
         json.dump({"autoload": {"Foo Device 2": "preset2"}}, file, indent=4)
 
     global_config.load_config()
 
-    return preset1, preset2, preset3
+    return preset1, preset2, preset3b

tests/lib/stuff.py

@@ -25,6 +25,7 @@
 
 def convert_to_internal_events(events):
     """Convert an iterable of InputEvent to a list of inputremapper.InputEvent."""
+    # TODO deprecated
     from inputremapper.input_event import InputEvent as InternalInputEvent
 
     return [InternalInputEvent.from_event(event) for event in events]

tests/unit/test_daemon.py

@@ -141,7 +141,7 @@ def test_daemon(self):
         """Injection 1"""
 
         # should forward the event unchanged
-        push_events(fixtures.gamepad, [new_event(EV_KEY, BTN_B, 1)])
+        push_events(fixtures.gamepad, [InputEvent.key(BTN_B, 1)])
 
         self.daemon = Daemon()