Dependency injection

bin/input-remapper-control

@@ -29,8 +29,9 @@ import sys
 from enum import Enum
 from typing import Union, Optional
 
-from inputremapper.configs.global_config import global_config
+from inputremapper.configs.global_config import GlobalConfig
 from inputremapper.configs.migrations import Migrations
+from inputremapper.injection.global_uinputs import GlobalUInputs, UInput, FrontendUInput
 from inputremapper.logging.logger import logger
 
 
@@ -66,6 +67,14 @@ class Options:
 
 
 class InputRemapperControl:
+    def __init__(
+        self,
+        global_config: GlobalConfig,
+        migrations: Migrations,
+    ):
+        self.global_config = global_config
+        self.migrations = migrations
+
     def run(self, cmd) -> None:
         """Run and log a command."""
         logger.info("Running `%s`...", cmd)
@@ -81,9 +90,9 @@ class InputRemapperControl:
             print(group.key)
 
     def list_key_names(self):
-        from inputremapper.configs.system_mapping import system_mapping
+        from inputremapper.configs.keyboard_layout import keyboard_layout
 
-        print("\n".join(system_mapping.list_names()))
+        print("\n".join(keyboard_layout.list_names()))
 
     def communicate(
         self,
@@ -131,7 +140,7 @@ class InputRemapperControl:
             sys.exit(6)
 
         logger.info('Using config from "%s" instead', path)
-        global_config.load_config(path)
+        self.global_config.load_config(path)
 
     def ensure_migrated(self) -> None:
         # import stuff late to make sure the correct log level is applied
@@ -144,9 +153,9 @@ class InputRemapperControl:
             # This will also refresh the config of the daemon if the user changed
             # it in the meantime.
             # config_dir is either the cli arg or the default path in home
-            config_dir = os.path.dirname(global_config.path)
+            config_dir = os.path.dirname(self.global_config.path)
             self.daemon.set_config_dir(config_dir)
-            Migrations.migrate()
+            self.migrations.migrate()
 
     def _stop(self, device: str) -> None:
         group = self._require_group(device)
@@ -267,7 +276,14 @@ class InputRemapperControl:
 
 
 def main(options: Options) -> None:
-    input_remapper_control = InputRemapperControl()
+    global_config = GlobalConfig()
+    global_uinputs = GlobalUInputs(FrontendUInput)
+    migrations = Migrations(global_uinputs)
+    input_remapper_control = InputRemapperControl(
+        global_config,
+        migrations,
+    )
+
     if options.debug:
         logger.update_verbosity(True)
 

bin/input-remapper-gtk

@@ -74,33 +74,38 @@ if __name__ == "__main__":
     #  log-level is set.
     # import input-remapper stuff after setting the log verbosity
     from inputremapper.gui.messages.message_broker import MessageBroker, MessageType
-    from inputremapper.configs.system_mapping import system_mapping
+    from inputremapper.configs.keyboard_layout import keyboard_layout
     from inputremapper.gui.data_manager import DataManager
     from inputremapper.gui.user_interface import UserInterface
     from inputremapper.gui.controller import Controller
-    from inputremapper.injection.global_uinputs import GlobalUInputs
+    from inputremapper.injection.global_uinputs import GlobalUInputs, FrontendUInput
     from inputremapper.groups import _Groups
     from inputremapper.gui.reader_client import ReaderClient
     from inputremapper.daemon import Daemon
     from inputremapper.configs.global_config import GlobalConfig
     from inputremapper.configs.migrations import Migrations
 
-    Migrations.migrate()
+    global_uinputs = GlobalUInputs(FrontendUInput)
+    migrations = Migrations(global_uinputs)
+
+    Migrations(global_uinputs).migrate()
 
     message_broker = MessageBroker()
 
+    global_config = GlobalConfig()
+
     # create the reader before we start the reader-service (start_processes) otherwise
     # it can come to race conditions with the creation of pipes
     reader_client = ReaderClient(message_broker, _Groups())
     daemon = start_processes()
 
     data_manager = DataManager(
         message_broker,
-        GlobalConfig(),
+        global_config,
         reader_client,
         daemon,
-        GlobalUInputs(),
-        system_mapping,
+        global_uinputs,
+        keyboard_layout,
     )
     controller = Controller(message_broker, data_manager)
     user_interface = UserInterface(message_broker, controller)

bin/input-remapper-reader-service

@@ -28,6 +28,7 @@ import sys
 from argparse import ArgumentParser
 
 from inputremapper.groups import _Groups
+from inputremapper.injection.global_uinputs import GlobalUInputs, FrontendUInput
 from inputremapper.logging.logger import logger
 
 if __name__ == "__main__":
@@ -57,5 +58,6 @@ if __name__ == "__main__":
 
     atexit.register(on_exit)
     groups = _Groups()
-    reader_service = ReaderService(groups)
+    global_uinputs = GlobalUInputs(FrontendUInput)
+    reader_service = ReaderService(groups, global_uinputs)
     asyncio.run(reader_service.run())

bin/input-remapper-service

@@ -25,6 +25,9 @@
 import sys
 from argparse import ArgumentParser
 
+from inputremapper.configs.global_config import GlobalConfig
+from inputremapper.injection.global_uinputs import GlobalUInputs, UInput
+from inputremapper.injection.mapping_handlers.mapping_parser import MappingParser
 from inputremapper.logging.logger import logger
 
 if __name__ == "__main__":
@@ -55,6 +58,10 @@ if __name__ == "__main__":
     if not options.hide_info:
         logger.log_info("input-remapper-service")
 
-    daemon = Daemon()
+    global_config = GlobalConfig()
+    global_uinputs = GlobalUInputs(UInput)
+    mapping_parser = MappingParser(global_uinputs)
+
+    daemon = Daemon(global_config, global_uinputs, mapping_parser)
     daemon.publish()
     daemon.run()

inputremapper/configs/global_config.py

@@ -25,8 +25,8 @@
 
 from inputremapper.configs.base_config import ConfigBase, INITIAL_CONFIG
 from inputremapper.configs.paths import PathUtils
-from inputremapper.user import UserUtils
 from inputremapper.logging.logger import logger
+from inputremapper.user import UserUtils
 
 MOUSE = "mouse"
 WHEEL = "wheel"
@@ -35,7 +35,7 @@
 
 
 class GlobalConfig(ConfigBase):
-    """Global default configuration.
+    """Global default configuration, from which all presets inherit.
     It can also contain some extra stuff not relevant for presets, like the
     autoload stuff. If presets have a config key set, it will ignore
     the default global configuration for that one. If none of the configs
@@ -129,7 +129,3 @@ def _save_config(self):
             json.dump(self._config, file, indent=4)
             logger.info("Saved config to %s", self.path)
             file.write("\n")
-
-
-# TODO DI
-global_config = GlobalConfig()

inputremapper/configs/input_config.py

@@ -31,7 +31,7 @@
 except ImportError:
     from pydantic import BaseModel, root_validator, validator
 
-from inputremapper.configs.system_mapping import system_mapping
+from inputremapper.configs.keyboard_layout import keyboard_layout
 from inputremapper.gui.messages.message_types import MessageType
 from inputremapper.logging.logger import logger
 from inputremapper.utils import get_evdev_constant_name
@@ -142,7 +142,7 @@ def _get_name(self) -> Optional[str]:
         # first try to find the name in xmodmap to not display wrong
         # names due to the keyboard layout
         if self.type == ecodes.EV_KEY:
-            key_name = system_mapping.get_name(self.code)
+            key_name = keyboard_layout.get_name(self.code)
 
         if key_name is None:
             # if no result, look in the linux combination constants. On a german

inputremapper/configs/system_mapping.py → inputremapper/configs/keyboard_layout.py

@@ -41,15 +41,15 @@
 LAZY_LOAD = None
 
 
-class SystemMapping:
+class KeyboardLayout:
     """Stores information about all available keycodes."""
 
     _mapping: Optional[dict] = LAZY_LOAD
     _xmodmap: Optional[List[Tuple[str, str]]] = LAZY_LOAD
     _case_insensitive_mapping: Optional[dict] = LAZY_LOAD
 
     def __getattribute__(self, wanted: str):
-        """To lazy load system_mapping info only when needed.
+        """To lazy load keyboard_layout info only when needed.
 
         For example, this helps to keep logs of input-remapper-control clear when it
         doesn't need it the information.
@@ -160,7 +160,7 @@ def _set(self, name: str, code: int):
 
     def get(self, name: str) -> int:
         """Return the code mapped to the key."""
-        # the correct casing should be shown when asking the system_mapping
+        # the correct casing should be shown when asking the keyboard_layout
         # for stuff. indexing case insensitive to support old presets.
         if name not in self._mapping:
             # only if not e.g. both "a" and "A" are in the mapping
@@ -216,4 +216,4 @@ def _find_legit_mappings(self) -> dict:
 
 # TODO DI
 # this mapping represents the xmodmap output, which stays constant
-system_mapping = SystemMapping()
+keyboard_layout = KeyboardLayout()

inputremapper/configs/mapping.py

@@ -62,7 +62,7 @@
     )
 
 from inputremapper.configs.input_config import InputCombination
-from inputremapper.configs.system_mapping import system_mapping, DISABLE_NAME
+from inputremapper.configs.keyboard_layout import keyboard_layout, DISABLE_NAME
 from inputremapper.configs.validation_errors import (
     OutputSymbolUnknownError,
     SymbolNotAvailableInTargetError,
@@ -286,13 +286,13 @@ def remove_combination_changed_callback(self):
 
     def get_output_type_code(self) -> Optional[Tuple[int, int]]:
         """Returns the output_type and output_code if set,
-        otherwise looks the output_symbol up in the system_mapping
+        otherwise looks the output_symbol up in the keyboard_layout
         return None for unknown symbols and macros
         """
         if self.output_code and self.output_type:
             return self.output_type, self.output_code
         if self.output_symbol and not is_this_a_macro(self.output_symbol):
-            return EV_KEY, system_mapping.get(self.output_symbol)
+            return EV_KEY, keyboard_layout.get(self.output_symbol)
         return None
 
     def get_output_name_constant(self) -> str:
@@ -385,7 +385,7 @@ def validate_symbol(cls, values):
             parse(symbol, mapping=mapping_mock, verbose=False)
             return values
 
-        code = system_mapping.get(symbol)
+        code = keyboard_layout.get(symbol)
         if code is None:
             raise OutputSymbolUnknownError(symbol)
 
@@ -450,7 +450,7 @@ def validate_output_integrity(cls, values):
             if type_ is not None or code is not None:
                 raise MacroButTypeOrCodeSetError()
 
-        if code is not None and code != system_mapping.get(symbol) or type_ != EV_KEY:
+        if code is not None and code != keyboard_layout.get(symbol) or type_ != EV_KEY:
             raise SymbolAndCodeMismatchError(symbol, code)
         return values