gogo_keyboard 0.0.0__py3-none-any.whl

gogo_keyboard/__init__.py

@@ -0,0 +1 @@
+ 

gogo_keyboard/_zenoh_simple_listener.py

@@ -0,0 +1,50 @@
+from contextlib import suppress
+import os
+import time
+from typing import Optional
+
+import zenoh
+
+
+def main(topic: str = "key_press", config_path: Optional[str] = None):
+    if config_path is None:
+        conf = zenoh.Config()
+    else:
+        filepath = os.path.expanduser(config_path)
+        conf = zenoh.Config.from_file(filepath)
+
+    with zenoh.open(conf) as session:
+        print(f"Subscribing to '{topic}'")
+        def listener(sample: zenoh.Sample):
+            print(
+                f"Received {sample.kind} ('{sample.key_expr}': '{sample.payload.to_string()}')"
+            )
+        session.declare_subscriber(topic, listener)
+        while True:
+            time.sleep(1)
+
+
+# --- Command line argument parsing --- --- --- --- --- ---
+if __name__ == "__main__":
+    import argparse
+
+    parser = argparse.ArgumentParser(prog="z_sub", description="zenoh sub example")
+    parser.add_argument(
+        "-c",
+        "--config",
+        dest="config",
+        default=None,
+        help="Zenoh config path",
+    )
+    parser.add_argument(
+        "-t",
+        "--topic",
+        dest="topic",
+        default="key_press",
+        help="ROS2 topic to publish key events to",
+    )
+
+    args = parser.parse_args()
+
+    with suppress(KeyboardInterrupt):
+        main(args.topic, args.config)

gogo_keyboard/codes.py

@@ -0,0 +1,263 @@
+KEY_UNKNOWN = 0
+KEY_A = 4
+KEY_B = 5
+KEY_C = 6
+KEY_D = 7
+KEY_E = 8
+KEY_F = 9
+KEY_G = 10
+KEY_H = 11
+KEY_I = 12
+KEY_J = 13
+KEY_K = 14
+KEY_L = 15
+KEY_M = 16
+KEY_N = 17
+KEY_O = 18
+KEY_P = 19
+KEY_Q = 20
+KEY_R = 21
+KEY_S = 22
+KEY_T = 23
+KEY_U = 24
+KEY_V = 25
+KEY_W = 26
+KEY_X = 27
+KEY_Y = 28
+KEY_Z = 29
+KEY_1 = 30
+KEY_2 = 31
+KEY_3 = 32
+KEY_4 = 33
+KEY_5 = 34
+KEY_6 = 35
+KEY_7 = 36
+KEY_8 = 37
+KEY_9 = 38
+KEY_0 = 39
+KEY_RETURN = 40
+KEY_ESCAPE = 41
+KEY_BACKSPACE = 42
+KEY_TAB = 43
+KEY_SPACE = 44
+KEY_MINUS = 45
+KEY_EQUALS = 46
+KEY_LEFTBRACKET = 47
+KEY_RIGHTBRACKET = 48
+KEY_BACKSLASH = 49
+KEY_NONUSHASH = 50
+KEY_SEMICOLON = 51
+KEY_APOSTROPHE = 52
+KEY_GRAVE = 53
+KEY_COMMA = 54
+KEY_PERIOD = 55
+KEY_SLASH = 56
+KEY_CAPSLOCK = 57
+KEY_F1 = 58
+KEY_F2 = 59
+KEY_F3 = 60
+KEY_F4 = 61
+KEY_F5 = 62
+KEY_F6 = 63
+KEY_F7 = 64
+KEY_F8 = 65
+KEY_F9 = 66
+KEY_F10 = 67
+KEY_F11 = 68
+KEY_F12 = 69
+KEY_PRINTSCREEN = 70
+KEY_SCROLLLOCK = 71
+KEY_PAUSE = 72
+KEY_INSERT = 73
+KEY_HOME = 74
+KEY_PAGEUP = 75
+KEY_DELETE = 76
+KEY_END = 77
+KEY_PAGEDOWN = 78
+KEY_RIGHT = 79
+KEY_LEFT = 80
+KEY_DOWN = 81
+KEY_UP = 82
+KEY_NUMLOCKCLEAR = 83
+KEY_KP_DIVIDE = 84
+KEY_KP_MULTIPLY = 85
+KEY_KP_MINUS = 86
+KEY_KP_PLUS = 87
+KEY_KP_ENTER = 88
+KEY_KP_1 = 89
+KEY_KP_2 = 90
+KEY_KP_3 = 91
+KEY_KP_4 = 92
+KEY_KP_5 = 93
+KEY_KP_6 = 94
+KEY_KP_7 = 95
+KEY_KP_8 = 96
+KEY_KP_9 = 97
+KEY_KP_0 = 98
+KEY_KP_PERIOD = 99
+KEY_NONUSBACKSLASH = 100
+KEY_APPLICATION = 101
+KEY_POWER = 102
+KEY_KP_EQUALS = 103
+KEY_F13 = 104
+KEY_F14 = 105
+KEY_F15 = 106
+KEY_F16 = 107
+KEY_F17 = 108
+KEY_F18 = 109
+KEY_F19 = 110
+KEY_F20 = 111
+KEY_F21 = 112
+KEY_F22 = 113
+KEY_F23 = 114
+KEY_F24 = 115
+KEY_EXECUTE = 116
+KEY_HELP = 117
+KEY_MENU = 118
+KEY_SELECT = 119
+KEY_STOP = 120
+KEY_AGAIN = 121
+KEY_UNDO = 122
+KEY_CUT = 123
+KEY_COPY = 124
+KEY_PASTE = 125
+KEY_FIND = 126
+KEY_MUTE = 127
+KEY_VOLUMEUP = 128
+KEY_VOLUMEDOWN = 129
+KEY_KP_COMMA = 133
+KEY_KP_EQUALSAS400 = 134
+KEY_INTERNATIONAL1 = 135
+KEY_INTERNATIONAL2 = 136
+KEY_INTERNATIONAL3 = 137
+KEY_INTERNATIONAL4 = 138
+KEY_INTERNATIONAL5 = 139
+KEY_INTERNATIONAL6 = 140
+KEY_INTERNATIONAL7 = 141
+KEY_INTERNATIONAL8 = 142
+KEY_INTERNATIONAL9 = 143
+KEY_LANG1 = 144
+KEY_LANG2 = 145
+KEY_LANG3 = 146
+KEY_LANG4 = 147
+KEY_LANG5 = 148
+KEY_LANG6 = 149
+KEY_LANG7 = 150
+KEY_LANG8 = 151
+KEY_LANG9 = 152
+KEY_ALTERASE = 153
+KEY_SYSREQ = 154
+KEY_CANCEL = 155
+KEY_CLEAR = 156
+KEY_PRIOR = 157
+KEY_RETURN2 = 158
+KEY_SEPARATOR = 159
+KEY_OUT = 160
+KEY_OPER = 161
+KEY_CLEARAGAIN = 162
+KEY_CRSEL = 163
+KEY_EXSEL = 164
+KEY_KP_00 = 176
+KEY_KP_000 = 177
+KEY_THOUSANDSSEPARATOR = 178
+KEY_DECIMALSEPARATOR = 179
+KEY_CURRENCYUNIT = 180
+KEY_CURRENCYSUBUNIT = 181
+KEY_KP_LEFTPAREN = 182
+KEY_KP_RIGHTPAREN = 183
+KEY_KP_LEFTBRACE = 184
+KEY_KP_RIGHTBRACE = 185
+KEY_KP_TAB = 186
+KEY_KP_BACKSPACE = 187
+KEY_KP_A = 188
+KEY_KP_B = 189
+KEY_KP_C = 190
+KEY_KP_D = 191
+KEY_KP_E = 192
+KEY_KP_F = 193
+KEY_KP_XOR = 194
+KEY_KP_POWER = 195
+KEY_KP_PERCENT = 196
+KEY_KP_LESS = 197
+KEY_KP_GREATER = 198
+KEY_KP_AMPERSAND = 199
+KEY_KP_DBLAMPERSAND = 200
+KEY_KP_VERTICALBAR = 201
+KEY_KP_DBLVERTICALBAR = 202
+KEY_KP_COLON = 203
+KEY_KP_HASH = 204
+KEY_KP_SPACE = 205
+KEY_KP_AT = 206
+KEY_KP_EXCLAM = 207
+KEY_KP_MEMSTORE = 208
+KEY_KP_MEMRECALL = 209
+KEY_KP_MEMCLEAR = 210
+KEY_KP_MEMADD = 211
+KEY_KP_MEMSUBTRACT = 212
+KEY_KP_MEMMULTIPLY = 213
+KEY_KP_MEMDIVIDE = 214
+KEY_KP_PLUSMINUS = 215
+KEY_KP_CLEAR = 216
+KEY_KP_CLEARENTRY = 217
+KEY_KP_BINARY = 218
+KEY_KP_OCTAL = 219
+KEY_KP_DECIMAL = 220
+KEY_KP_HEXADECIMAL = 221
+KEY_LCTRL = 224
+KEY_LSHIFT = 225
+KEY_LALT = 226
+KEY_LGUI = 227
+KEY_RCTRL = 228
+KEY_RSHIFT = 229
+KEY_RALT = 230
+KEY_RGUI = 231
+KEY_MODE = 257
+KEY_AUDIONEXT = 258
+KEY_AUDIOPREV = 259
+KEY_AUDIOSTOP = 260
+KEY_AUDIOPLAY = 261
+KEY_AUDIOMUTE = 262
+KEY_MEDIASELECT = 263
+KEY_WWW = 264
+KEY_MAIL = 265
+KEY_CALCULATOR = 266
+KEY_COMPUTER = 267
+KEY_AC_SEARCH = 268
+KEY_AC_HOME = 269
+KEY_AC_BACK = 270
+KEY_AC_FORWARD = 271
+KEY_AC_STOP = 272
+KEY_AC_REFRESH = 273
+KEY_AC_BOOKMARKS = 274
+KEY_BRIGHTNESSDOWN = 275
+KEY_BRIGHTNESSUP = 276
+KEY_DISPLAYSWITCH = 277
+KEY_KBDILLUMTOGGLE = 278
+KEY_KBDILLUMDOWN = 279
+KEY_KBDILLUMUP = 280
+KEY_EJECT = 281
+KEY_SLEEP = 282
+KEY_APP1 = 283
+KEY_APP2 = 284
+KEY_AUDIOREWIND = 285
+KEY_AUDIOFASTFORWARD = 286
+KEY_SOFTLEFT = 287
+KEY_SOFTRIGHT = 288
+KEY_CALL = 289
+KEY_ENDCALL = 290
+
+MODIFIER_NONE=0
+MODIFIER_LSHIFT=1
+MODIFIER_RSHIFT=2
+MODIFIER_LCTRL=64
+MODIFIER_RCTRL=128
+MODIFIER_LALT=256
+MODIFIER_RALT=512
+MODIFIER_LMETA=1024
+MODIFIER_RMETA=2048
+MODIFIER_NUM=4096
+MODIFIER_CAPS=8192
+MODIFIER_MODE=16384
+MODIFIER_RESERVED=32768
+
+SDL_NUM_SCANCODES = 512

gogo_keyboard/example.py

@@ -0,0 +1,60 @@
+import asyncio
+import json
+from dataclasses import asdict
+
+import sdl2
+import sdl2.ext
+
+from . import codes
+from .keyboard import Key, KeySub
+
+
+async def detect_window_closed(event: asyncio.Event):
+    await event.wait()
+    print("Gorilla window closed by user.")
+
+
+async def detect_CtrlC(key_sub: KeySub):
+    async for k in key_sub.listen_reliable():
+        if k.symbol == "C" and (k.modifiers & codes.MODIFIER_LCTRL) and k.is_pressed:
+            print("Ctrl+C in Gorilla window by user.")
+            return
+
+
+async def print_keys(key_sub: KeySub):
+    async for k in key_sub.listen_reliable():
+        print(json.dumps({k: str(v) for k,v in asdict(k).items()}, indent=4))
+
+
+async def async_main():
+    window_closed_event = asyncio.Event()
+    key_sub = KeySub(
+        termination_callback=window_closed_event.set,
+    )
+
+    try:
+        print_task = asyncio.create_task(print_keys(key_sub))
+        close_task = asyncio.create_task(detect_window_closed(window_closed_event))
+        ctrl_task = asyncio.create_task(detect_CtrlC(key_sub))
+        await asyncio.wait(
+            [print_task, close_task, ctrl_task], return_when=asyncio.FIRST_COMPLETED
+        )
+        print_task.cancel()
+        close_task.cancel()
+        ctrl_task.cancel()
+    finally:
+        key_sub.close()
+
+
+def main():
+    try:
+        asyncio.run(async_main())
+    except KeyboardInterrupt:
+        print("KeyboardInterrupt in python process")
+    finally:
+        sdl2.ext.quit()
+    print("Exited cleanly :)")
+
+
+if __name__ == "__main__":
+    main()

gogo_keyboard/keyboard.py

@@ -0,0 +1,184 @@
+import asyncio
+import colorsys
+import copy
+import dataclasses
+import random
+from importlib.resources import files
+from typing import Any, Callable, Dict, Tuple
+
+import asyncio_for_robotics
+import sdl2
+import sdl2.ext
+from asyncio_for_robotics.core.sub import BaseSub
+
+
+def scancode_to_color(scancode: int) -> Tuple[int, int, int]:
+    if scancode == 0:
+        return 255, 0, 0
+    brightness = 255
+    r, g, b = colorsys.hsv_to_rgb((scancode % 30) / 30, 0.5, 1)
+    return int(r * brightness), int(g * brightness), int(b * brightness)
+
+
+@dataclasses.dataclass(frozen=True)
+class Key:
+    symbol: str
+    code: int
+    modifiers: int
+    is_pressed: bool
+    sdl_event: sdl2.SDL_KeyboardEvent
+
+    @classmethod
+    def from_sdl(cls, sdl_event: sdl2.SDL_KeyboardEvent) -> "Key":
+        return cls(
+            symbol=sdl2.SDL_GetKeyName(sdl_event.keysym.sym).decode(),
+            code=sdl_event.keysym.scancode,
+            modifiers=sdl_event.keysym.mod,
+            is_pressed=bool(sdl_event.state),
+            sdl_event=sdl_event,
+        )
+
+
+def raise_keyboard_interupt():
+    raise KeyboardInterrupt
+
+
+class KeySub(BaseSub[Key]):
+    def __init__(
+        self,
+        termination_callback: Callable[[], Any] = raise_keyboard_interupt,
+    ) -> None:
+        """Creates a sdl2 window with an asyncio_for_robotics subcriber getting
+        the key presses inputed in the window.
+
+        Args:
+            termination_callback: Will be called when the Gorilla window is
+                closed by the user.
+        """
+        self.termination_callback: Callable[[], Any] = termination_callback
+        r, g, b = colorsys.hsv_to_rgb(random.random(), (random.random() + 1) / 2, 1)
+        self.idle_color: Tuple[int, int, int] = int(r * 255), int(g * 255), int(b * 255)
+
+        self._pressed_keys: Dict[int, Key] = dict()
+        self._surface_icon = sdl2.ext.load_img(
+            str(files("gogo_keyboard").joinpath("icons/gogo.png"))
+        )
+        super().__init__()
+        self.window: sdl2.ext.Window
+        self.renderer: sdl2.ext.Renderer
+        self._init_sdl()
+        self._sdl_thread: asyncio.Task = asyncio.create_task(self._sdl_loop())
+
+        self.texture_idle = sdl2.SDL_CreateTextureFromSurface(
+            self.renderer.sdlrenderer,
+            sdl2.ext.load_img(
+                str(files("gogo_keyboard").joinpath("icons/gogo.png")),
+            ),
+        )
+        self.texture_loop = [
+            sdl2.SDL_CreateTextureFromSurface(
+                self.renderer.sdlrenderer,
+                sdl2.ext.load_img(
+                    str(files("gogo_keyboard").joinpath("icons/gogo_happy.png"))
+                ),
+            ),
+            sdl2.SDL_CreateTextureFromSurface(
+                self.renderer.sdlrenderer,
+                sdl2.ext.load_img(
+                    str(files("gogo_keyboard").joinpath("icons/gogo_happy2.png"))
+                ),
+            ),
+        ]
+        self.tex_ind: int = 0
+        self._draw()
+        self.renderer.present()
+
+    @property
+    def pressed_keys(self) -> Dict[int, Key]:
+        return copy.deepcopy(self._pressed_keys)
+
+    @property
+    def name(self) -> str:
+        return "Gorillinput"
+
+    def close(self):
+        self.window.close()
+        sdl2.ext.quit()
+        self._sdl_thread.cancel()
+
+    def _scancode_to_color(self, scancode):
+        return scancode_to_color(scancode)
+
+    def _init_sdl(self):
+        sdl2.ext.init()
+        self.window = sdl2.ext.Window(
+            "Input",
+            size=(150, 150),
+            # flags=sdl2.SDL_WINDOW_RESIZABLE, # icon disapears if used
+        )
+        sdl2.SDL_SetWindowIcon(self.window.window, self._surface_icon)
+        self.renderer = sdl2.ext.Renderer(self.window)
+        self.window.show()
+        self.texture_frame = sdl2.SDL_Rect(0, 0, 150, 150)  # x, y, width, height
+
+    def _on_window_close(self):
+        self.close()
+        self.termination_callback()
+
+    def _draw(self):
+        self.renderer.color = (
+            self._scancode_to_color(list(self._pressed_keys.keys())[-1])
+            if len(self._pressed_keys) > 0
+            else self.idle_color
+        )
+        self.renderer.clear()
+        if len(self._pressed_keys) > 0 and self.texture_loop != []:
+            self.tex_ind = (self.tex_ind + 1) % len(self.texture_loop)
+            sdl2.SDL_RenderCopy(
+                self.renderer.sdlrenderer,
+                self.texture_loop[self.tex_ind],
+                None,
+                self.texture_frame,
+            )
+        else:
+            sdl2.SDL_RenderCopy(
+                self.renderer.sdlrenderer, self.texture_idle, None, self.texture_frame
+            )
+
+    async def _sdl_loop(self):
+        async for t in asyncio_for_robotics.Rate(30).listen():
+            events = sdl2.ext.get_events()
+            for e in events:
+                if e.type == sdl2.SDL_QUIT:
+
+                    self._on_window_close()
+                    return
+
+                elif e.type == sdl2.SDL_KEYDOWN:
+                    if e.key.repeat:
+                        continue
+                    k = Key.from_sdl(e.key)
+                    self.input_data(k)
+                    self._pressed_keys[k.code] = k
+
+                elif e.type == sdl2.SDL_KEYUP:
+                    k = Key.from_sdl(e.key)
+                    self.input_data(k)
+                    del self._pressed_keys[k.code]
+
+                elif e.type in [
+                    sdl2.SDL_WINDOWEVENT,
+                ]:
+                    sdl2.SDL_SetWindowIcon(self.window.window, self._surface_icon)
+                    self.window.show()
+                    if e.window.event in [
+                        sdl2.SDL_WINDOWEVENT_SIZE_CHANGED,
+                        sdl2.SDL_WINDOWEVENT_RESIZED,
+                    ]:
+                        pass  # continues to update the window to new size
+                    else:
+                        continue  # does nothing
+                else:
+                    continue  # does nothing
+                self._draw()
+                self.renderer.present()

gogo_keyboard/mini_example.py

@@ -0,0 +1,9 @@
+import asyncio
+from gogo_keyboard.keyboard import KeySub
+
+async def async_main():
+    key_sub = KeySub()
+    async for key in key_sub.listen_reliable():
+        print(key)
+
+asyncio.run(async_main())

gogo_keyboard/ros_node.py

@@ -0,0 +1,75 @@
+"""ROS2 node that publishes keyboard events as JSON-encoded std_msgs/String messages.
+
+Run using:
+    - python3 -m gogo_keyboard.ros_node
+    - python3 -m gogo_keyboard.ros_node -t my_topic
+    - python3 -m gogo_keyboard.ros_node --topic my_topic
+"""
+import argparse
+import asyncio
+import json
+from contextlib import suppress
+from dataclasses import asdict
+
+import rclpy
+from rclpy.qos import DurabilityPolicy, HistoryPolicy, QoSProfile, ReliabilityPolicy
+from std_msgs.msg import String
+
+from gogo_keyboard.keyboard import Key, KeySub
+
+
+def make_ros_msg(key: Key) -> String:
+    """Convert a Key object into a JSON-encoded ROS String message."""
+    dict_key = asdict(key)
+    del dict_key["sdl_event"]
+    return String(data=json.dumps(dict_key))
+
+
+async def async_main(topic: str = "key_press"):
+    """Run the async keyboard listener and publish key events to a ROS2 topic.
+
+    Args:
+        topic: ROS2 topic to publish key events to
+    """
+    rclpy.init()
+    node = rclpy.create_node("gogo_keyboard")
+    pub = node.create_publisher(
+        String,
+        topic,
+        QoSProfile(  # no message lost (hopefuly)
+            reliability=ReliabilityPolicy.RELIABLE,
+            history=HistoryPolicy.KEEP_ALL,
+            durability=DurabilityPolicy.VOLATILE,
+        ),
+    )
+    key_sub = KeySub()
+    print(
+        f"🦍🦍_keyboard publishing onto `{node.resolve_topic_name(pub.topic)}`. \nListen using `ros2 topic echo {node.resolve_topic_name(pub.topic)}`"
+    )
+    try:
+        async for key in key_sub.listen_reliable():
+            msg = make_ros_msg(key)
+            pub.publish(msg)
+    finally:
+        print(f"gogo_keyboard exiting.")
+        key_sub.close()
+        rclpy.shutdown()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-t",
+        "--topic",
+        default="key_press",
+        help="ROS2 topic to publish key events to",
+    )
+    args = parser.parse_args()
+    with suppress(
+        asyncio.CancelledError, KeyboardInterrupt, rclpy._rclpy_pybind11.RCLError
+    ):
+        asyncio.run(async_main(args.topic))
+
+
+if __name__ == "__main__":
+    main()

gogo_keyboard/zenoh_node.py

@@ -0,0 +1,75 @@
+"""Zenoh publisher that publishes keyboard events as JSON-encoded messages.
+
+Run using:
+    - python3 -m gogo_keyboard.zenoh_node
+"""
+
+import argparse
+import asyncio
+import json
+import os
+from contextlib import suppress
+from dataclasses import asdict
+from typing import Optional
+
+import zenoh
+
+from gogo_keyboard.keyboard import Key, KeySub
+
+
+def make_msg(key: Key) -> str:
+    """Convert a Key object into a JSON-encoded message."""
+    dict_key = asdict(key)
+    del dict_key["sdl_event"]
+    return json.dumps(dict_key)
+
+
+async def async_main(topic: str = "key_press", config_path: Optional[str] = None):
+    """Run the async keyboard listener and publish key events to a zenoh key_expr.
+
+    Args:
+        topic: key_expr to publish key events to
+    """
+    if config_path is None:
+        config = zenoh.Config()
+    else:
+        filepath = os.path.expanduser(config_path)
+        config = zenoh.Config.from_file(filepath)
+    with zenoh.open(config) as ses:
+        pub = ses.declare_publisher(topic, reliability=zenoh.Reliability.RELIABLE)
+        key_sub = KeySub()
+        print(
+            f"🦍🦍_keyboard publishing onto `{pub.key_expr}`. \nListen using `python3 -m gogo_keyboard._zenoh_simple_listener`"
+        )
+        try:
+            async for key in key_sub.listen_reliable():
+                msg = make_msg(key)
+                pub.put(msg)
+        finally:
+            print(f"gogo_keyboard exiting.")
+            key_sub.close()
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "-c",
+        "--config",
+        dest="config",
+        default=None,
+        help="Zenoh config path",
+    )
+    parser.add_argument(
+        "-t",
+        "--topic",
+        dest="topic",
+        default="key_press",
+        help="ROS2 topic to publish key events to",
+    )
+    args = parser.parse_args()
+    with suppress(asyncio.CancelledError, KeyboardInterrupt):
+        asyncio.run(async_main(args.topic, args.config))
+
+
+if __name__ == "__main__":
+    main()

gogo_keyboard-0.0.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: gogo_keyboard
+Version: 0.0.0
+Summary: Press keyboard 🦍 Get key 🦍 Python Asyncio for Robotics
+Author-email: Elian NEPPEL <elian.dev@posteo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/2lian/gogo_keyboard
+Project-URL: Repository, https://github.com/2lian/gogo_keyboard
+Project-URL: Issues, https://github.com/2lian/gogo_keyboard/issues
+Keywords: asyncio,robotics,ros2,zenoh,publisher,subscriber
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Natural Language :: English
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Topic :: Scientific/Engineering
+Classifier: Framework :: AsyncIO
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: asyncio_for_robotics>=1.0.0
+Requires-Dist: pysdl2>=0.9.0
+Provides-Extra: dll
+Requires-Dist: pysdl2-dll; extra == "dll"
+Provides-Extra: dev
+Requires-Dist: colorama; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Provides-Extra: build
+Requires-Dist: build; extra == "build"
+Requires-Dist: twine; extra == "build"
+Dynamic: license-file
+
+# Gogo Keyboard
+## Press keyboard 🦍 Get key 🦍  Unga Bunga
+
+| Requirements | Compatibility |
+|---|---|
+| [![python](https://img.shields.io/pypi/pyversions/asyncio_for_robotics?logo=python&logoColor=white&label=Python&color=%20blue)](https://pypi.org/project/asyncio_for_robotics/)<br>![sdl2](https://img.shields.io/badge/sdl-sdl2__images-%20blue?link=https%3A%2F%2Fwww.libsdl.org%2F)<br>[![mit](https://img.shields.io/badge/License-MIT-gold)](https://opensource.org/license/mit)| ![asyncio](https://img.shields.io/badge/Framework-Asyncio-blue?logo=python&logoColor=white) <br>[![ROS 2](https://img.shields.io/badge/ROS_2-Humble%20%7C%20Jazzy%20%7C%20Kilted-blue?logo=ros)](https://github.com/ros2) <br>[![zenoh](https://img.shields.io/badge/Zenoh-%3E%3D1.0-blue)](https://zenoh.io/) |
+
+Python Asyncio library to simply get keyboard presses and releases. Gogo Keyboard creates a new independent SDL2 window that captures the key events.
+
+```python3
+pip install https://github.com/2lian/gogo_keyboard.git[dll]
+python3 -m gogo_keyboard.example
+```
+
+Motivation:
+- Keyboard presses and releases in Asyncio.
+- Only when clicking on the Gorilla window.
+- Python terminal is free for other tasks.
+- Based on [`asyncio_for_robotics`](https://github.com/2lian/asyncio-for-robotics) for seamless compatibility with:
+  - ROS 2
+  - Zenoh
+  - More
+
+| ![python](./media/Screenshot1.png) | ![python](./media/Screenshot2.png) | ![python](./media/Screenshot3.png) |
+|---|---|---|
+
+## Installation
+
+This library requires `sdl2` and `sdl2_image`. By specifying the `[dll]` optional dependency, those will be installed by pip.
+
+```python3
+pip install gogo_keyboard[dll]
+```
+
+Conda pacakge: soon!
+
+## Python Example
+
+Example is [provided here](./src/gogo_keyboard/example.py) and can be run with `python3 -m gogo_keyboard.example`.
+
+Here is a minimal piece of working code:
+
+```python
+import asyncio
+from gogo_keyboard.keyboard import KeySub
+
+async def async_main():
+    key_sub = KeySub()
+    async for key in key_sub.listen_reliable():
+        print(key)
+
+asyncio.run(async_main())
+```
+
+## ROS 2 Example (Humble, Jazzy, Kilted)
+
+A very simple ROS 2 node is [provided here](./src/gogo_keyboard/ros_node.py), run it with `python3 -m gogo_keyboard.ros_node`. The messages format is a `json` formatted `String`, 🦍 simple 🦍  Unga Bunga.
+
+## Zenoh Example
+
+A very simple Zenoh publisher is [provided here](./src/gogo_keyboard/zenoh_node.py), run it with `python3 -m gogo_keyboard.zenoh_node`. The messages format is a `json` formatted `String`, 🦍 simple 🦍  Unga Bunga.

gogo_keyboard-0.0.0.dist-info/RECORD

@@ -0,0 +1,17 @@
+gogo_keyboard/__init__.py,sha256=4W8VliAYUP1KY2gLJ_YDy2TmcXYVm-PY7XikQD_bFwA,2
+gogo_keyboard/_zenoh_simple_listener.py,sha256=ALLACoGxLugo7ICrEkZwaH_xsynmZ_XIyQyxoS1TcHY,1303
+gogo_keyboard/codes.py,sha256=GDGXKh6D0wPVsrFM8UglDkCrjH7ayBki484X_MhDQJs,4465
+gogo_keyboard/example.py,sha256=m8KyUvp1Bz6avF3nQwI23bwvyfvSWZPNzH19V9UUwqk,1539
+gogo_keyboard/keyboard.py,sha256=Fj0FjPNW2rD3-hde5-q-6srCvO3suGd_PP9ml0Ezm4A,6048
+gogo_keyboard/mini_example.py,sha256=1zWGsAVTrHgPwUQYGV4anN9O7x4nriOvUbagO2SC7LM,199
+gogo_keyboard/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gogo_keyboard/ros_node.py,sha256=6_x3QAmEvsxYwBTxgXZzc6etdRjl2jxkpCpQXiXR_5U,2133
+gogo_keyboard/zenoh_node.py,sha256=DTk014KQGkwFlNcnzRPYdESjqBEMybPHvUVYPs4-pCo,2011
+gogo_keyboard/icons/gogo.png,sha256=Csa0zE_0SNgSGvBqBKAyzJ8LT-abBTCldKFrUgL7Z08,918
+gogo_keyboard/icons/gogo_happy.png,sha256=LywojJg3pYiTtdLJhFPHehhqgQl3V5GBX64Mvnkgkxo,940
+gogo_keyboard/icons/gogo_happy2.png,sha256=uNG6elJSZAkSDSW4RRTjgCZWajJnZZ3IpI53jmmFkLQ,1113
+gogo_keyboard-0.0.0.dist-info/licenses/LICENSE,sha256=mLZSGzYp72Ys0WWGIGWxPamHm1loDM6dDtG-4nQOI-0,1069
+gogo_keyboard-0.0.0.dist-info/METADATA,sha256=Jb3awk5-ZvKXcXKJjV8y3TgG3fseD75C_FH_5exByZ4,4238
+gogo_keyboard-0.0.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+gogo_keyboard-0.0.0.dist-info/top_level.txt,sha256=RC5VsKo6kb70BmF7AIkFPB7mguExOHb5QAMMZNlxEk0,14
+gogo_keyboard-0.0.0.dist-info/RECORD,,

gogo_keyboard-0.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

gogo_keyboard-0.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Elian NEPPEL
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gogo_keyboard-0.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+gogo_keyboard