py-global-shortcuts 0.1.0__tar.gz

py_global_shortcuts-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: py-global-shortcuts
+Version: 0.1.0
+Summary: Python library for creating global keyboard shortcuts.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pynput>=1.8.1
+
+# py-global-shortcuts
+Global shortcuts for python apps using GNOME and Wayland

py_global_shortcuts-0.1.0/README.md

@@ -0,0 +1,2 @@
+# py-global-shortcuts
+Global shortcuts for python apps using GNOME and Wayland

py_global_shortcuts-0.1.0/py_global_shortcuts/__init__.py

@@ -0,0 +1,76 @@
+import platform
+import sys
+from . import globals as g
+from . import shortcut_binder as sb
+from . import utilities as u
+from . shortcut_binder import Command, KeyBinding, KeyBinder
+
+_binder: sb.KeyBinder = None
+_comms = None
+
+def init(appname: str, cache_dir="./temp"):
+    import os
+    
+    if not os.path.exists(cache_dir):
+        os.makedirs(cache_dir)
+
+    g.cache_file = os.path.join(cache_dir, g.CACHE_FILE_NAME)
+
+    if not os.path.exists(g.cache_file):
+        with open(g.cache_file, "w") as f:
+            print("Creating cache file at", g.cache_file)
+            f.write("{}")
+
+    g.appname = appname.replace(" ", "")
+
+    global _binder
+    if u.is_gnome_wayland():
+        global _comms
+        from . import linux_comms
+        _comms = linux_comms.ProcessCommunicator.get_global_communicator()
+        from .gnome_binder import GnomeBinder
+        _binder = GnomeBinder()
+        _comms.start_server(_binder.handle_shortcut)
+    else:
+        from .pynput_binder import PynputBinder
+        _binder = PynputBinder()
+
+def deinit():
+    global _comms
+    if _comms is not None:
+        _comms.cleanup()
+    if _binder is not None:
+        _binder.cleanup()
+
+def binding_handle(appname: str):
+    g.appname = appname.replace(" ", "")
+    if len(sys.argv) < 4:
+        return
+    if g.BINDING_ID_STR == sys.argv[1]:
+        pygsstr, input_appname, unique_id = sys.argv[2].split(g.BASH_COMMAND_SEPERATOR)
+        shortcut = sys.argv[3]
+        assert pygsstr == "pygs"
+        print("Handling binding for app:", sys.argv)
+        if input_appname != appname:
+            # This is not our binding, ignore
+            print("App name does not match, exiting.", appname, g.appname)
+            exit(0)
+        print("Setting unique ID to", unique_id)
+        u.set_unique_id(unique_id)
+        print("Setting unique ID to", unique_id, u.unique_id())
+        if u.is_gnome_wayland():
+            from . import linux_comms
+            comms = linux_comms.ProcessCommunicator.get_global_communicator()
+            if not comms.socket_exists():
+                # No socket to communicate with, exit
+                print("No socket to communicate with, exiting.")
+                exit(0)
+            print("Sending shortcut activation for", shortcut)
+            comms.send_json({"shortcut": f"{shortcut}"})
+        exit(0)
+
+def get_binder() -> sb.KeyBinder:
+    global _binder
+    if _binder is None:
+        raise RuntimeError("Binder not initialized. Call init() first.")
+    return _binder

py_global_shortcuts-0.1.0/py_global_shortcuts/filed_dict.py

@@ -0,0 +1,114 @@
+import json
+import os
+from typing import TypeVar, Generic
+import typing as t
+
+class CustomJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        try:
+            return super().default(obj)
+        except TypeError:
+            if type(obj) in FiledDict._custom_serializers:
+                return FiledDict._custom_serializers[type(obj)](obj)
+            return str(obj)
+
+class CustomJSONDecoder(json.JSONDecoder):
+    def __init__(self, *args, **kwargs):
+        json.JSONDecoder.__init__(self, object_hook=self._custom_object_hook, *args, **kwargs)
+
+    def _custom_object_hook(self, dct):
+        if FiledDict._custom_dict_deserializer is not None:
+            try:
+                return FiledDict._custom_dict_deserializer(dct)
+            except (KeyError, ValueError, TypeError) as e:
+                pass
+        return dct
+
+K = TypeVar('K')
+V = TypeVar('V')
+class FiledDict(Generic[K, V]):
+    _custom_serializers = {}
+    _custom_dict_deserializer: t.Callable = None
+
+    @staticmethod
+    def register_serializer(type, serializer):
+        FiledDict._custom_serializers[type] = serializer
+
+
+    """ Tries its best to mimick a json file, and reflect changes in file upon saving.
+        Very useful for handling settings that need to be persistent
+    """
+
+    def __init__(self, file: str, autosave: bool = True, default: t.Dict[K, V] = {}):
+        """ The file to mirror
+serializer
+        Args:
+            file (string): path to the file
+        """
+        self.file = file
+        self.autosave = autosave
+        self.default = default
+        if (not self.load()):
+            self._settings = default
+        self.save()
+        self.type = type(self._settings)
+
+    def __iter__(self):
+        return iter(self._settings)
+
+    def __len__(self):
+        return len(self._settings)
+
+    def __getitem__(self, name: K) -> V:
+        return self._settings.__getitem__(name)
+
+    def __setitem__(self, name: K, val: V):
+        self._settings.__setitem__(name, val)
+        if self.autosave:
+            self.save()
+
+    def __delitem__(self, key: K):
+        self._settings.__delitem__(key)
+        if self.autosave:
+            self.save()
+
+    def __getattr__(self, name):
+        return getattr(self._settings, name)
+
+    def save(self):
+        if (self.file is not None):
+            f = open(self.file,'w')
+            f.write(json.dumps(self._settings, indent=4, cls=CustomJSONEncoder))
+
+    def load(self):
+        if (self.file is None):
+            return False
+        if os.path.isfile(self.file):
+            f = open(self.file,'r')
+            try:
+                self._settings = json.load(f, cls=CustomJSONDecoder)
+            except json.JSONDecodeError as e:
+                print("Failed to load settings file, using default.", str(e))
+                self._settings = self.default
+                self.save()
+            finally:
+                f.close()
+            print(self._settings)
+            return True
+        return False
+
+    def keys(self) -> t.Iterable[K]:
+        return self._settings.keys()
+
+    def values(self) -> t.Iterable[V]:
+        return self._settings.values()
+
+    def items(self) -> t.Iterable[t.Tuple[K, V]]:
+        return self._settings.items()
+
+    def pop(self, key: K, if_fail: V = "") -> V:
+        return self._settings.pop(key, if_fail)
+
+    def remove(self, item: V) -> None:
+        return self._settings.remove(item)
+

py_global_shortcuts-0.1.0/py_global_shortcuts/globals.py

@@ -0,0 +1,9 @@
+# Used to store the apps current shortcuts
+BINDING_ID_STR = "??++??"
+CACHE_FILE_NAME = "py_global_shortcuts_cache.json"
+GSETTINGS_SCHEMA = "org.gnome.settings-daemon.plugins.media-keys"
+GSETTINGS_KEY = "custom-keybindings"
+BASH_COMMAND_SEPERATOR = "___"
+
+cache_file = ""
+appname = None

py_global_shortcuts-0.1.0/py_global_shortcuts/gnome_binder.py

@@ -0,0 +1,134 @@
+import re
+from . import utilities as u
+from . import shortcut_binder as sb
+from . import globals as g
+from typing import Union
+import subprocess
+
+
+class GnomeBinder(sb.KeyBinder):
+    def _get_binding_path_prefix(self) -> str:
+        return f"/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/{u.unique_id()}"
+
+
+    def _deregister_key_binding(self, shortcut: str):
+        current_bindings = self._get_gsettings_bindings_list()
+        bindingpath = f"{self._get_binding_path_prefix()}/{shortcut}/"
+        if bindingpath not in current_bindings:
+            return
+        current_bindings.remove(bindingpath)
+        self._set_gsettings_bindings_list(current_bindings)
+
+
+    def _set_gsettings_bindings_list(self, bindings: list[str]):
+        subprocess.run(
+            ["gsettings", "set", g.GSETTINGS_SCHEMA, g.GSETTINGS_KEY, str(bindings)],
+            capture_output=True
+        )
+
+    def _remove_current_bindings_from_gsettings(self):
+        schema = "org.gnome.settings-daemon.plugins.media-keys"
+        key = "custom-keybindings"
+
+        current_bindings = self._get_gsettings_bindings_list()
+        updated_bindings = []
+        for b in current_bindings:
+            if not b.startswith(self._get_binding_path_prefix()):
+                updated_bindings.append(b)
+        self._set_gsettings_bindings_list(updated_bindings)
+
+
+    def _get_gsettings_bindings_list(self) -> list[str]:
+        # Get the current list of custom keybindings
+        result = subprocess.run(
+            ["gsettings", "get", g.GSETTINGS_SCHEMA, g.GSETTINGS_KEY],
+            capture_output=True,
+            text=True
+        )
+
+        current_bindings = result.stdout.strip()
+        current_bindings = re.sub(r'^@as\s+', '', current_bindings)
+        current_bindings = eval(current_bindings)
+
+        return current_bindings
+
+    def _get_current_gsettings_bindings(self):
+        current_bindings = self._get_gsettings_bindings_list()
+
+        app_bindings = []
+        for binding_path in current_bindings:
+            if binding_path.startswith(self._get_binding_path_prefix()):
+                # Get the shortcut details for this binding
+                binding_schema = f"{g.GSETTINGS_SCHEMA}.custom-keybinding:{binding_path}"
+                name = subprocess.run(
+                    ["gsettings", "get", binding_schema, "name"],
+                    capture_output=True,
+                    text=True
+                ).stdout.strip().strip("'")
+                command = subprocess.run(
+                    ["gsettings", "get", binding_schema, "command"],
+                    capture_output=True,
+                    text=True
+                ).stdout.strip().strip("'")
+                shortcut = subprocess.run(
+                    ["gsettings", "get", binding_schema, "binding"],
+                    capture_output=True,
+                    text=True
+                ).stdout.strip().strip("'")
+
+                app_bindings.append(shortcut)
+
+        return app_bindings
+
+    def cleanup(self):
+        self._remove_current_bindings_from_gsettings()
+
+    def _register_key_binding(self, shortcut):
+        # binding_command = f"terminator -x bash -c '{u.get_exec_bash(shortcut)}; exec bash'"
+        binding_command = f"{u.get_exec_bash(shortcut)}"
+        self.gnome_register_key_binding(shortcut, binding_command)
+
+    def _sanitize_binding_str_for_gnome(self, binding_str: str) -> str:
+        if "+" in binding_str:
+            binding_str = binding_str.replace("+", "")
+        return binding_str.lower()
+
+    def gnome_register_key_binding(self, shortcut, command):
+        # Pynput has a slightly different style
+        shortcut = self._sanitize_binding_str_for_gnome(shortcut)
+
+        # Get the current list of custom keybindings
+        result = subprocess.run(
+            ["gsettings", "get", g.GSETTINGS_SCHEMA, g.GSETTINGS_KEY],
+            capture_output=True,
+            text=True
+        )
+
+        current_bindings = result.stdout.strip()
+        current_bindings = re.sub(r'^@as\s+', '', current_bindings)
+        current_bindings = eval(current_bindings)
+
+        # Define the new binding path
+        new_binding_path = f"/org/gnome/settings-daemon/plugins/media-keys/custom-keybindings/{u.unique_id()}/{shortcut.replace(' ', '_')}/"
+
+        # Add the new binding if it doesn't exist
+        if new_binding_path not in current_bindings:
+            current_bindings.append(new_binding_path)
+            subprocess.run(
+                ["gsettings", "set", g.GSETTINGS_SCHEMA, g.GSETTINGS_KEY, str(current_bindings)],
+                capture_output=True
+            )
+
+            # Set the name, command, and binding for the new shortcut
+            subprocess.run(
+                ["gsettings", "set", f"{g.GSETTINGS_SCHEMA}.custom-keybinding:{new_binding_path}", "name", f"Custom Shortcut {shortcut}"],
+                capture_output=True
+            )
+            subprocess.run(
+                ["gsettings", "set", f"{g.GSETTINGS_SCHEMA}.custom-keybinding:{new_binding_path}", "command", command],
+                capture_output=True
+            )
+            subprocess.run(
+                ["gsettings", "set", f"{g.GSETTINGS_SCHEMA}.custom-keybinding:{new_binding_path}", "binding", shortcut],
+                capture_output=True
+            )

py_global_shortcuts-0.1.0/py_global_shortcuts/linux_comms.py

@@ -0,0 +1,88 @@
+import json
+import socket
+import threading
+from . import utilities as u
+import os
+
+class ProcessCommunicator:
+    """Handle JSON communication between Python processes using Unix domain sockets."""
+    global_instance = None
+
+    def __init__(self, socket_path=None):
+        """Initialize communicator with optional socket path.
+
+        Args:
+            socket_path: Path to Unix domain socket. Auto-generated if None.
+        """
+        self.socket_path = socket_path or f"/tmp/pygs_{u.unique_id()}.sock"
+        self.server_socket = None
+        self.client_socket = None
+
+    def socket_exists(self):
+        """Check if the socket file exists."""
+        return os.path.exists(self.socket_path)
+
+    def start_server(self, callback):
+        """Start server to receive JSON messages.
+
+        Args:
+            callback: Function called with deserialized JSON data
+        """
+        # Remove existing socket file
+        if os.path.exists(self.socket_path):
+            os.remove(self.socket_path)
+
+
+        self.server_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.server_socket.bind(self.socket_path)
+        self.server_socket.listen(1)
+
+        def accept_connections():
+            while True:
+                try:
+                    conn, _ = self.server_socket.accept()
+                    data = b""
+                    while True:
+                        chunk = conn.recv(4096)
+                        if not chunk:
+                            break
+                        data += chunk
+                    if data:
+                        callback(json.loads(data.decode())["shortcut"])
+                    conn.close()
+                except:
+                    break
+
+        thread = threading.Thread(target=accept_connections, daemon=True)
+        thread.start()
+
+    def send_json(self, data):
+        """Send JSON data to server socket.
+
+        Args:
+            data: Dictionary or JSON-serializable object to send
+        """
+        self.client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        self.client_socket.connect(self.socket_path)
+        json_str = json.dumps(data)
+        self.client_socket.sendall(json_str.encode())
+        self.client_socket.close()
+
+    def close(self):
+        """Close server and client sockets."""
+        if self.server_socket:
+            self.server_socket.close()
+        if self.client_socket:
+            self.client_socket.close()
+
+    def cleanup(self):
+        """Close sockets and remove socket file."""
+        self.close()
+        if os.path.exists(self.socket_path):
+            os.remove(self.socket_path)
+
+    @staticmethod
+    def get_global_communicator():
+        if ProcessCommunicator.global_instance is None:
+            ProcessCommunicator.global_instance = ProcessCommunicator()
+        return ProcessCommunicator.global_instance

py_global_shortcuts-0.1.0/py_global_shortcuts/pynput_binder.py

@@ -0,0 +1,52 @@
+import re
+from . import utilities as u
+from . import shortcut_binder as sb
+from . import globals as g
+from typing import Union
+import subprocess
+import pynput
+
+class PynputBinder(sb.KeyBinder):
+    def __init__(self):
+        self._hotkeys: dict[str, pynput.keyboard.HotKey] = {}
+        self._key_listener = pynput.keyboard.Listener(on_press=self._on_press, on_release=self._on_release)
+        self._key_listener.start()
+        super().__init__()
+
+
+    def _on_press(self, key):
+        can = self._key_listener.canonical(key)
+        for hotkey in self._hotkeys.values():
+            hotkey.press(can)
+
+
+    def _on_release(self, key):
+        can = self._key_listener.canonical(key)
+        for hotkey in self._hotkeys.values():
+            hotkey.release(can)
+
+
+    def _deregister_key_binding(self, shortcut: str):
+        if shortcut in self._hotkeys:
+            del self._hotkeys[shortcut]        
+
+
+    def cleanup(self):
+        self._key_listener.stop()
+
+
+    def _create_hotkey_fun(self, shortcut: str):
+        def fun():
+            self.handle_shortcut(shortcut)
+        return fun
+
+
+    def _register_key_binding(self, shortcut):
+        if shortcut in self._hotkeys:
+            return
+        keys = pynput.keyboard.HotKey.parse(shortcut)
+        for i in range(len(keys)):
+            keys[i] = self._key_listener.canonical(keys[i])
+        
+        self._hotkeys[shortcut] = pynput.keyboard.HotKey(keys, self._create_hotkey_fun(shortcut))
+

py_global_shortcuts-0.1.0/py_global_shortcuts/shortcut_binder.py

@@ -0,0 +1,179 @@
+from typing import Callable, Union
+from . import globals as g
+from . filed_dict import FiledDict, CustomJSONEncoder
+import os
+
+
+class Command:
+    def __init__(self, cmd_id: str, function: Callable, name: str = ""):
+        self.name = name
+        self.function: Callable = function
+        self.cmd_id = cmd_id
+        if name == "":
+            self.name = self.cmd_id
+
+
+    def __repr__(self):
+        return f"Command({self.name}, {self.function})"
+
+
+    def __str__(self):
+        return self.__repr__()
+
+
+    def execute(self):
+        self.function()
+
+
+class KeyBinding:
+    def __init__(self, shortcut: str):
+        self.shortcut = shortcut
+        self.commands: list[str] = []
+
+
+    def __repr__(self):
+        return f"KeyBinding({self.shortcut}, {self.commands})"
+
+
+    def __str__(self):
+        return self.__repr__()
+
+
+    def get_commands(self) -> list[str]:
+        return self.commands
+
+
+    def add_command(self, command: Union[Command, str]):
+        if isinstance(command, Command):
+            command = command.cmd_id
+        if self.has_command(command):
+            return
+        self.commands.append(command)
+
+
+    def remove_command(self, command: Union[Command, str]):
+        if isinstance(command, Command):
+            command = command.cmd_id
+        if command in self.commands:
+            self.commands.remove(command)
+
+
+    def has_command(self, command: Union[Command, str]) -> bool:
+        if isinstance(command, Command):
+            command = command.cmd_id
+        return command in self.commands
+
+
+class KeyBinder:
+    def __init__(self):
+        self.shortcuts: FiledDict[str, KeyBinding] = FiledDict(g.cache_file, autosave=True, default={})
+        self.commands: dict[str, Command] = {}
+        for shortcut in self.shortcuts.keys():
+            self._register_key_binding(shortcut)
+
+
+    def register_command(self, command: Command):
+        self.commands[command.cmd_id] = command
+
+
+    def get_key_bindings(self) -> list[KeyBinding]:
+        return list(self.shortcuts.values())
+
+
+    def get_key_binding(self, shortcut: str) -> KeyBinding:
+        shortcut = self._sanitize_binding_str(shortcut)
+        if shortcut in self.shortcuts:
+            return self.shortcuts[shortcut]
+        return None
+
+
+    def get_commands(self) -> list[Command]:
+        return list(self.commands.values())
+
+
+    def cleanup(self):
+        pass
+
+
+    def execute_command(self, command_id: Union[Command, str]):
+        if isinstance(command_id, Command):
+            command_id = command_id.id
+        if command_id in self.commands:
+            command = self.commands[command_id]
+            command.execute()
+
+
+    def delete_key_binding(self, shortcut: str):
+        shortcut = self._sanitize_binding_str(shortcut)
+        if shortcut in self.shortcuts:
+            del self.shortcuts[shortcut]
+            self._deregister_key_binding(shortcut)
+        self.shortcuts.save()
+
+
+    def create_key_binding(self, shortcut: str):
+        shortcut = self._sanitize_binding_str(shortcut)
+        if shortcut not in self.shortcuts:
+            self.shortcuts[shortcut] = KeyBinding(shortcut)
+            self._register_key_binding(shortcut)
+            self.shortcuts.save()
+
+
+    def unlink_command(self, shortcut: str, command: Union[Command, str]):
+        shortcut = self._sanitize_binding_str(shortcut)
+        if isinstance(command, Command):
+            command = command.cmd_id
+        if shortcut in self.shortcuts:
+            self.shortcuts[shortcut].remove_command(command)
+        self.shortcuts.save()
+
+
+    def link_command(self, shortcut: str, command: Union[Command, str]):
+        shortcut = self._sanitize_binding_str(shortcut)
+        if shortcut not in self.shortcuts:
+            self.shortcuts[shortcut] = KeyBinding(shortcut)
+        self.shortcuts[shortcut].add_command(command)
+        self._register_key_binding(shortcut)
+        self.shortcuts.save()
+
+
+    def handle_shortcut(self, shortcut: str):
+        shortcut = self._sanitize_binding_str(shortcut)
+        if shortcut in self.shortcuts:
+            for command_id in self.shortcuts[shortcut].get_commands():
+                if command_id in self.commands:
+                    command = self.commands[command_id]
+                    command.execute()
+
+
+    def _register_key_binding(self, shortcut: str):
+        raise NotImplementedError("This method should be implemented by subclasses.")
+
+
+    def _deregister_key_binding(self, shortcut: str):
+        raise NotImplementedError("This method should be implemented by subclasses.")
+
+
+    def _sanitize_binding_str(self, binding_str: str) -> str:
+        return binding_str.lower()
+
+
+def _binding_serializer(bnd: 'KeyBinding'):
+    return {
+        "shortcut": bnd.shortcut,
+        "commands": bnd.get_commands(),
+        "_cls_": "KeyBinding"
+    }
+
+
+def _binding_deserializer(dct):
+    if "_cls_" in dct and dct["_cls_"] == "KeyBinding":
+        ret = KeyBinding(dct["shortcut"])
+        for cmd_id in dct["commands"]:
+            ret.add_command(cmd_id)
+        return ret
+    return dct
+
+
+FiledDict.register_serializer(KeyBinding, _binding_serializer)
+FiledDict._custom_dict_deserializer = _binding_deserializer

py_global_shortcuts-0.1.0/py_global_shortcuts/utilities.py

@@ -0,0 +1,37 @@
+import uuid
+import platform
+import os
+import sys
+
+from . import globals as g
+
+# We need a unique ID per application instance to avoid conflicts
+_unique_id_str = str(uuid.uuid4())
+
+
+def set_unique_id(id_str: str):
+    global _unique_id_str
+    _unique_id_str = id_str
+
+
+def app_id():
+    return f"pygs{g.BASH_COMMAND_SEPERATOR}{g.appname}"
+
+
+def unique_id():
+    return f"{app_id()}{g.BASH_COMMAND_SEPERATOR}{_unique_id_str}"
+
+
+def is_gnome_wayland():
+    if platform.system() != "Linux":
+        return False
+    return os.environ.get("XDG_SESSION_TYPE") == "wayland" and "ubuntu" in os.environ.get("DESKTOP_SESSION", "")
+
+
+def get_exec_bash(shortcut: str = ""):
+    main_python_file = os.path.abspath(sys.argv[0])
+
+    shortcut = shortcut.replace("\\", "\\\\").replace('"', '\\"').replace("$", "\\$").replace("`", "\\`").replace("<", "\\<").replace(">", "\\>")
+
+    return f"{sys.executable} {main_python_file} {g.BINDING_ID_STR} {unique_id()} {shortcut}"
+

py_global_shortcuts-0.1.0/py_global_shortcuts.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: py-global-shortcuts
+Version: 0.1.0
+Summary: Python library for creating global keyboard shortcuts.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pynput>=1.8.1
+
+# py-global-shortcuts
+Global shortcuts for python apps using GNOME and Wayland

py_global_shortcuts-0.1.0/py_global_shortcuts.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+py_global_shortcuts/__init__.py
+py_global_shortcuts/filed_dict.py
+py_global_shortcuts/globals.py
+py_global_shortcuts/gnome_binder.py
+py_global_shortcuts/linux_comms.py
+py_global_shortcuts/pynput_binder.py
+py_global_shortcuts/shortcut_binder.py
+py_global_shortcuts/utilities.py
+py_global_shortcuts.egg-info/PKG-INFO
+py_global_shortcuts.egg-info/SOURCES.txt
+py_global_shortcuts.egg-info/dependency_links.txt
+py_global_shortcuts.egg-info/requires.txt
+py_global_shortcuts.egg-info/top_level.txt

py_global_shortcuts-0.1.0/py_global_shortcuts.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

py_global_shortcuts-0.1.0/py_global_shortcuts.egg-info/requires.txt

@@ -0,0 +1 @@
+pynput>=1.8.1

py_global_shortcuts-0.1.0/py_global_shortcuts.egg-info/top_level.txt

@@ -0,0 +1 @@
+py_global_shortcuts

py_global_shortcuts-0.1.0/pyproject.toml

@@ -0,0 +1,9 @@
+[project]
+name = "py-global-shortcuts"
+version = "0.1.0"
+description = "Python library for creating global keyboard shortcuts."
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pynput>=1.8.1",
+]

py_global_shortcuts-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+