GHIElectronics.Endpoint.Devices.UsbHost 0.5.3__py3-none-any.whl

GHIElectronics/Endpoint/Devices/UsbHost/__init__.py

@@ -0,0 +1,143 @@
+"""USB devices of Endpoint, with the same API as .NET's
+GHIElectronics.Endpoint.Devices.UsbHost:
+
+    import serial
+    from GHIElectronics.Endpoint.Core import DeviceConnectionStatus
+    from GHIElectronics.Endpoint.Devices.UsbHost import DeviceType, UsbHostController
+
+    usb = UsbHostController.GetDefault()
+
+    def changed(sender, e):
+        if e.DeviceStatus == DeviceConnectionStatus.Connected and e.Type == DeviceType.Serial:
+            port = serial.Serial(e.DeviceName, 115200)   # "/dev/ttyUSB0"
+
+    usb.ConnectionChanged += changed
+    usb.Enable()   # the devices already plugged in are reported too
+
+One event for each thing a device gives: a keyboard with a touchpad gives
+Keyboard and Mouse, a webcam gives Webcam and Audio (its microphone).
+DeviceName is what to open it with (see DeviceType). The events come on the
+library's USB thread. USB drives come as MassStorage: use StorageController
+(GHIElectronics.Endpoint.Devices.Storage) for them.
+
+Keyboards, mice and joysticks have TinyCLR's classes:
+
+    if e.DeviceStatus == DeviceConnectionStatus.Connected and e.Type == DeviceType.Mouse:
+        mouse = Mouse(e.DeviceName)
+        mouse.SetCursorBounds(Position(0, 0), Position(799, 479))
+        mouse.CursorMoved += lambda sender, a: print("Cursor at", a.NewPosition.X, a.NewPosition.Y)
+        mouse.ButtonChanged += lambda sender, a: print(a.Which.name, a.State.name)
+
+A program's own devices: pyusb for one with no driver (DeviceType.Unknown),
+the hid package (hidapi) for HID devices; the board has their libraries:
+
+    pip install pyusb hid
+    device = usb.core.find(idVendor=e.VendorId, idProduct=e.ProductId)
+    device = hid.Device(vid=e.VendorId, pid=e.ProductId)
+
+A controller or device stays alive until it is disposed, also when the
+program keeps no variable for it.
+"""
+
+from GHIElectronics.Endpoint.Core import DeviceConnectionStatus
+from GHIElectronics.Endpoint.Core._event import Event
+from GHIElectronics.Endpoint.Core._native import UsbHostCallback, native
+
+from ._input import BaseDevice, Joystick, Keyboard, Mouse, Printer, PrinterStatus
+from ._types import ButtonState, Buttons, Cursor, DeviceType, HatSwitchDirection, Key, KeyState, Position
+
+__all__ = ["BaseDevice", "ButtonState", "Buttons", "Cursor", "DeviceConnectionStatus", "DeviceType",
+           "HatSwitchDirection", "Joystick", "Key", "KeyState", "Keyboard", "Mouse", "Position", "Printer",
+           "PrinterStatus",
+           "UsbDeviceConnectionEventArgs", "UsbHostController"]
+
+
+class UsbDeviceConnectionEventArgs:
+    def __init__(self, deviceStatus, id, type, vendorId, productId, deviceName, manufacturer, product, serialNumber):
+        self.DeviceStatus = deviceStatus
+        self.Id = id
+        """The device's number: the same for all its events, a new one when it is plugged in again"""
+        self.Type = type
+        self.VendorId = vendorId
+        self.ProductId = productId
+        self.DeviceName = deviceName
+        """What to open: "/dev/ttyUSB0", "eth1"... (see DeviceType)"""
+        self.Manufacturer = manufacturer
+        """The device's own names ("Logitech", "USB Receiver"), empty if it has none"""
+        self.Product = product
+        self.SerialNumber = serialNumber
+
+    def __repr__(self):
+        return (f"UsbDeviceConnectionEventArgs({self.DeviceStatus.name}, Id={self.Id}, Type={self.Type.name}, "
+                f"DeviceName={self.DeviceName!r}, VendorId=0x{self.VendorId:04X}, ProductId=0x{self.ProductId:04X}, "
+                f"Manufacturer={self.Manufacturer!r}, Product={self.Product!r})")
+
+
+def _text(value):
+    return value.decode(errors="replace") if value else ""
+
+
+def _type(value):
+    try:
+        return DeviceType(value)
+    except ValueError:
+        return value  # a type a newer libendpoint knows
+
+
+class UsbHostController:
+    @staticmethod
+    def GetDefault():
+        return UsbHostController()
+
+    def __init__(self):
+        self._event = Event()
+        self._handle = None
+        self._callback = UsbHostCallback(self._changed)  # kept: the library calls it
+        handle = native.out_handle()
+        native.usbhost_create(self._callback, None, native.ref(handle))
+        self._handle = handle
+        native.keep_alive(self)
+
+    @property
+    def ConnectionChanged(self):
+        """A device connected or disconnected: handler(sender, e). Add with +=, remove with -="""
+        return self._event
+
+    @ConnectionChanged.setter
+    def ConnectionChanged(self, value):
+        if value is not self._event:
+            raise TypeError("Use += and -= to add and remove an event handler")
+
+    def _h(self):
+        if self._handle is None:
+            raise native.disposed("UsbHostController")
+        return self._handle
+
+    def Enable(self):
+        """Starts reporting devices: first the ones already plugged in"""
+        native.usbhost_enable(self._h())
+
+    def Disable(self):
+        native.usbhost_disable(self._h())
+
+    def Dispose(self):
+        """Stops the events (one being delivered finishes first)"""
+        if self._handle is not None:
+            native.usbhost_dispose(self._handle)
+            self._handle = None
+            native.let_go(self)
+
+    def _changed(self, context, status, id, type, vendorId, productId, deviceName, manufacturer, product,
+                 serialNumber):
+        self._event(self, UsbDeviceConnectionEventArgs(DeviceConnectionStatus(status), id, _type(type), vendorId,
+                                                       productId, _text(deviceName), _text(manufacturer),
+                                                       _text(product), _text(serialNumber)))
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exception):
+        self.Dispose()
+
+    def __del__(self):
+        self.Dispose()

GHIElectronics/Endpoint/Devices/UsbHost/_input.py

@@ -0,0 +1,410 @@
+"""USB keyboards, mice and joysticks with TinyCLR's API, and printers. Each is
+opened with the DeviceName its UsbHostController event gives
+("/dev/input/event2", "/dev/usb/lp0"); its events come on the device's own
+thread; it stays alive until it is disposed."""
+
+from enum import IntFlag
+import ctypes
+
+from GHIElectronics.Endpoint.Core._event import Event
+from GHIElectronics.Endpoint.Core._native import InputCallback, UnpluggedCallback, native
+
+from ._types import ButtonState, Buttons, Cursor, DeviceType, HatSwitchDirection, Key, KeyState, Position
+
+# The libendpoint events (see Input::Event in libendpoint)
+_KEY, _MOUSE_BUTTON, _MOUSE_MOVE, _WHEEL, _JOY_BUTTON, _JOY_MOVE, _HAT, _DISCONNECTED = range(1, 9)
+
+
+class _EventProperty:
+    """An event: handlers are added with += and removed with -= (handler(sender, e))"""
+
+    def __set_name__(self, owner, name):
+        self.attribute = "_event_" + name
+
+    def __get__(self, target, owner=None):
+        return self if target is None else target.__dict__[self.attribute]
+
+    def __set__(self, target, value):
+        if value is not target.__dict__.get(self.attribute):
+            raise TypeError("Use += and -= to add and remove an event handler")
+
+
+class _EventArgs:
+    def __init__(self, **values):
+        self.__dict__.update(values)
+
+    def __repr__(self):
+        values = ", ".join(f"{name}={value!r}" for name, value in self.__dict__.items())
+        return f"{type(self).__name__}({values})"
+
+
+def _key(value):
+    try:
+        return Key(value)
+    except ValueError:
+        return value  # a key TinyCLR has no name for: its USB key code
+
+
+class BaseDevice:
+    """A USB device the program uses: Keyboard, Mouse, Joystick or Printer"""
+
+    Disconnected = _EventProperty()
+    """The device was unplugged: handler(sender, e)"""
+
+    def __init__(self, deviceName, deviceType):
+        # The events exist before the device can raise them
+        for klass in type(self).__mro__:
+            for value in vars(klass).values():
+                if isinstance(value, _EventProperty):
+                    self.__dict__[value.attribute] = Event()
+        self._handle = None
+        self._printer = deviceType == DeviceType.Printer
+        handle = native.out_handle()
+        vendor, product, connected, capabilities = (native.out_int() for _ in range(4))
+        # The callbacks are kept: the library calls them
+        if self._printer:
+            self._callback = UnpluggedCallback(lambda context: self.Disconnected(self, None))
+            native.printer_open(str(deviceName).encode(), self._callback, None, native.ref(handle))
+            native.printer_info(handle, native.ref(vendor), native.ref(product), native.ref(connected))
+        else:
+            self._callback = InputCallback(self._changed)
+            native.input_open(str(deviceName).encode(), int(deviceType), self._callback, None, native.ref(handle))
+            native.input_info(handle, native.ref(vendor), native.ref(product), native.ref(connected),
+                              native.ref(capabilities))
+        self._handle = handle
+        native.keep_alive(self)
+        self._deviceName = str(deviceName)
+        self._type = deviceType
+        self._vendorId = vendor.value
+        self._productId = product.value
+        self._capabilities = capabilities.value
+
+    @property
+    def DeviceName(self):
+        """What the device was opened with: "/dev/input/event2", "/dev/usb/lp0" """
+        return self._deviceName
+
+    @property
+    def Type(self):
+        return self._type
+
+    @property
+    def VendorId(self):
+        return self._vendorId
+
+    @property
+    def ProductId(self):
+        return self._productId
+
+    @property
+    def Connected(self):
+        if self._handle is None:
+            return False
+        values = [native.out_int() for _ in range(4)]
+        if self._printer:
+            native.printer_info(self._handle, *[native.ref(v) for v in values[:3]])
+        else:
+            native.input_info(self._handle, *[native.ref(v) for v in values])
+        return values[2].value != 0
+
+    def Dispose(self):
+        """Stops the device's events (one being delivered finishes first)"""
+        if self._handle is not None:
+            (native.printer_close if self._printer else native.input_close)(self._handle)
+            self._handle = None
+            native.let_go(self)
+
+    def _h(self):
+        if self._handle is None:
+            raise native.disposed(type(self).__name__)
+        return self._handle
+
+    def _changed(self, context, event, a, b, c, d, e):
+        if event == _DISCONNECTED:
+            self.Disconnected(self, None)
+        else:
+            self._on_event(event, a, b, c, d, e)
+
+    def _on_event(self, event, a, b, c, d, e):
+        pass
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exception):
+        self.Dispose()
+
+    def __repr__(self):
+        return f"{type(self).__name__}({self._deviceName!r})"
+
+
+class Mouse(BaseDevice):
+    """A USB mouse. The cursor stays between 0 and 512 at first, as on TinyCLR:
+    set it to the screen with SetCursorBounds.
+
+        mouse = Mouse(e.DeviceName)     # from UsbHostController, DeviceType.Mouse
+        mouse.SetCursorBounds(Position(0, 0), Position(799, 479))
+        mouse.CursorMoved += lambda sender, a: print("Cursor at", a.NewPosition.X, a.NewPosition.Y)
+        mouse.ButtonChanged += lambda sender, a: print(a.Which.name, a.State.name)
+    """
+
+    ButtonChanged = _EventProperty()
+    """A button was pressed or released: handler(sender, e) with e.Which (Buttons), e.State (ButtonState)"""
+    WheelMoved = _EventProperty()
+    """The wheel moved: e.NewPosition, e.Delta"""
+    CursorMoved = _EventProperty()
+    """The cursor moved: e.NewPosition, e.Delta (Position)"""
+
+    class ButtonChangedEventArgs(_EventArgs):
+        pass
+
+    class WheelMovedEventArgs(_EventArgs):
+        pass
+
+    class CursorMovedEventArgs(_EventArgs):
+        pass
+
+    def __init__(self, deviceName):
+        super().__init__(deviceName, DeviceType.Mouse)
+
+    def _state(self):
+        values = [native.out_int() for _ in range(4)]
+        native.input_mouse_state(self._h(), *[native.ref(v) for v in values])
+        return [v.value for v in values]
+
+    def _button(self, button):
+        return ButtonState.Pressed if self._state()[3] & button else ButtonState.Released
+
+    @property
+    def LeftButtonState(self):
+        return self._button(Buttons.Left)
+
+    @property
+    def RightButtonState(self):
+        return self._button(Buttons.Right)
+
+    @property
+    def MiddleButtonState(self):
+        return self._button(Buttons.Middle)
+
+    @property
+    def Extended1ButtonState(self):
+        return self._button(Buttons.Extended1)
+
+    @property
+    def Extended2ButtonState(self):
+        return self._button(Buttons.Extended2)
+
+    @property
+    def CursorPosition(self):
+        x, y, _, _ = self._state()
+        return Position(x, y)
+
+    @property
+    def WheelPosition(self):
+        return self._state()[2]
+
+    @property
+    def AbsolutePosition(self):
+        """False: a USB mouse moves relative"""
+        return False
+
+    def SetScale(self, scale):
+        """Scales the x, y, and wheel delta values"""
+        native.input_set_scale(self._h(), float(scale))
+
+    def SetCursorBounds(self, minimum, maximum):
+        """The cursor's smallest and largest Position"""
+        native.input_set_cursor_bounds(self._h(), 0, minimum.X, maximum.X, minimum.Y, maximum.Y)
+
+    def SetCursorPosition(self, newPosition):
+        native.input_set_cursor_position(self._h(), newPosition.X, newPosition.Y)
+
+    def _on_event(self, event, a, b, c, d, e):
+        if event == _MOUSE_BUTTON:
+            self.ButtonChanged(self, Mouse.ButtonChangedEventArgs(Which=Buttons(a), State=ButtonState(b)))
+        elif event == _MOUSE_MOVE:
+            self.CursorMoved(self, Mouse.CursorMovedEventArgs(NewPosition=Position(a, b), Delta=Position(c, d)))
+        elif event == _WHEEL:
+            self.WheelMoved(self, Mouse.WheelMovedEventArgs(NewPosition=a, Delta=b))
+
+
+class Keyboard(BaseDevice):
+    """A USB keyboard. CharDown and CharUp come only for keys with an ASCII
+    character (a US keyboard; Ctrl+A to Ctrl+Z give 1 to 26). A key held down
+    gives one KeyDown.
+
+        keyboard = Keyboard(e.DeviceName)   # from UsbHostController, DeviceType.Keyboard
+        keyboard.CharDown += lambda sender, a: print(a.Ascii, end="", flush=True)
+    """
+
+    KeyUp = _EventProperty()
+    """A key was released: handler(sender, e) with e.Which (Key) and e.Ascii (a str, "\\0" if none)"""
+    KeyDown = _EventProperty()
+    """A key was pressed"""
+    CharUp = _EventProperty()
+    """A key with an ASCII character was released"""
+    CharDown = _EventProperty()
+    """A key with an ASCII character was pressed"""
+
+    class KeyboardEventArgs(_EventArgs):
+        pass
+
+    def __init__(self, deviceName):
+        super().__init__(deviceName, DeviceType.Keyboard)
+
+    def IsKeyPressed(self, key):
+        """The KeyState of a key"""
+        state = native.out_int()
+        native.input_key_state(self._h(), int(key), native.ref(state))
+        return KeyState(state.value)
+
+    def _on_event(self, event, a, b, c, d, e):
+        if event != _KEY:
+            return
+        args = Keyboard.KeyboardEventArgs(Which=_key(a), Ascii=chr(c))
+        if b == KeyState.Pressed:
+            self.KeyDown(self, args)
+            if c:
+                self.CharDown(self, args)
+        else:
+            self.KeyUp(self, args)
+            if c:
+                self.CharUp(self, args)
+
+
+class Joystick(BaseDevice):
+    """A USB joystick or game pad. The sticks go from -512 to 512 at first, as on
+    TinyCLR: Cursor1 is the left stick, Cursor2 the right one. Buttons are
+    numbered from 0.
+
+        joystick = Joystick(e.DeviceName)   # from UsbHostController, DeviceType.Joystick
+        joystick.CursorMoved += lambda sender, a: print(a.Which.name, a.NewPosition)
+        joystick.ButtonChanged += lambda sender, a: print("Button", a.Which, a.State.name)
+    """
+
+    ButtonChanged = _EventProperty()
+    """A button was pressed or released: handler(sender, e) with e.Which (its number), e.State"""
+    CursorMoved = _EventProperty()
+    """A stick moved: e.Which (Cursor), e.NewPosition, e.Delta"""
+    HatSwitchPressed = _EventProperty()
+    """The hat switch moved: e.Direction (HatSwitchDirection)"""
+
+    class DeviceCapabilities(IntFlag):
+        CursorX = 0x01
+        CursorY = 0x02
+        Cursor2X = 0x04
+        Cursor2Y = 0x08
+        HatSwitch = 0x10
+        Buttons = 0x20
+
+    class ButtonChangedEventArgs(_EventArgs):
+        pass
+
+    class CursorMovedEventArgs(_EventArgs):
+        pass
+
+    class HatSwitchPressedEventArgs(_EventArgs):
+        pass
+
+    def __init__(self, deviceName):
+        super().__init__(deviceName, DeviceType.Joystick)
+
+    @property
+    def Capabilities(self):
+        return Joystick.DeviceCapabilities(self._capabilities)
+
+    def _state(self, cursor):
+        x, y, hat = native.out_int(), native.out_int(), native.out_int()
+        buttons = native.out_uint32()
+        native.input_joystick_state(self._h(), int(cursor), native.ref(x), native.ref(y), native.ref(hat),
+                                    native.ref(buttons))
+        return Position(x.value, y.value), HatSwitchDirection(hat.value), buttons.value
+
+    @property
+    def CursorPosition(self):
+        return self._state(Cursor.Cursor1)[0]
+
+    @property
+    def Cursor2Position(self):
+        return self._state(Cursor.Cursor2)[0]
+
+    @property
+    def CurrentHatSwitchDirection(self):
+        return self._state(Cursor.Cursor1)[1]
+
+    def SetCursorBounds(self, cursor, minX, maxX, minY, maxY):
+        native.input_set_cursor_bounds(self._h(), int(cursor), minX, maxX, minY, maxY)
+
+    def GetButtonState(self, buttonNumber):
+        """The ButtonState of a button (0 to 31)"""
+        if not 0 <= buttonNumber <= 31:
+            from GHIElectronics.Endpoint.Core import ArgumentOutOfRangeException
+            raise ArgumentOutOfRangeException("The button number must be 0 to 31")
+        return ButtonState.Pressed if self._state(Cursor.Cursor1)[2] & (1 << buttonNumber) else ButtonState.Released
+
+    def _on_event(self, event, a, b, c, d, e):
+        if event == _JOY_BUTTON:
+            self.ButtonChanged(self, Joystick.ButtonChangedEventArgs(Which=a, State=ButtonState(b)))
+        elif event == _JOY_MOVE:
+            self.CursorMoved(self, Joystick.CursorMovedEventArgs(Which=Cursor(a), NewPosition=Position(b, c),
+                                                                 Delta=Position(d, e)))
+        elif event == _HAT:
+            self.HatSwitchPressed(self, Joystick.HatSwitchPressedEventArgs(Direction=HatSwitchDirection(a)))
+
+
+class PrinterStatus(IntFlag):
+    """What a printer reports about itself (Ready: nothing)"""
+
+    Ready = 0
+    PaperOut = 0x01
+    Offline = 0x02
+    Error = 0x04
+
+
+class Printer(BaseDevice):
+    """A USB printer: the bytes it understands (ESC/POS for receipt printers, ZPL or
+    EPL for label printers, PCL or PostScript for office printers) go to it as
+    they are.
+
+        printer = Printer(e.DeviceName)     # from UsbHostController, DeviceType.Printer
+        printer.Write("Hello\n\n\n")
+        printer.Write(bytes([0x1D, 0x56, 0x00]))   # ESC/POS: cut the paper
+    """
+
+    def __init__(self, deviceName):
+        super().__init__(deviceName, DeviceType.Printer)
+        self.WriteTimeout = -1
+        """How long Write waits for the printer to take the data, in milliseconds (-1: as long as it takes)"""
+
+    @property
+    def DeviceId(self):
+        """The printer's IEEE 1284 Device ID: "MFG:EPSON;CMD:ESC/POS;MDL:TM-T20II;CLS:PRINTER;" """
+        text = ctypes.create_string_buffer(1024)
+        native.printer_device_id(self._h(), text, len(text))
+        return text.value.decode(errors="replace")
+
+    @property
+    def Status(self):
+        """PaperOut, Offline and Error, as the printer reports them (Ready: none)"""
+        status = native.out_int()
+        native.printer_status(self._h(), native.ref(status))
+        return PrinterStatus(status.value)
+
+    def Write(self, data):
+        """Sends bytes (or text, as UTF-8) to the printer; all of them, or a TimeoutException
+        after WriteTimeout"""
+        if isinstance(data, str):
+            data = data.encode()
+        pointer, length, keep = native.readable(data)
+        written = native.out_int()
+        native.printer_write(self._h(), pointer, length, int(self.WriteTimeout), native.ref(written))
+        return written.value
+
+    def Read(self, buffer, timeout=-1):
+        """Reads what the printer answers (to a status request) into a bytearray: its length,
+        0 if nothing came in timeout milliseconds (-1: as long as it takes)"""
+        pointer, size = native.writable(buffer)
+        length = native.out_int()
+        native.printer_read(self._h(), pointer, size, int(timeout), native.ref(length))
+        return length.value

GHIElectronics/Endpoint/Devices/UsbHost/_types.py

@@ -0,0 +1,217 @@
+"""The types of TinyCLR's USB host (GHIElectronics.TinyCLR.Devices.Usb): the
+same names and values (Key is the USB key code). Python's None is a keyword:
+Buttons.None_, Key.None_, HatSwitchDirection.None_."""
+
+from enum import IntEnum, IntFlag
+
+
+class DeviceType(IntEnum):
+    """What a device gives, and its DeviceName"""
+
+    Unknown = 0
+    """No driver on the board: the program talks to it with pyusb ("/dev/bus/usb/001/005"):
+    usb.core.find(idVendor=e.VendorId, idProduct=e.ProductId)"""
+    Hub = 1
+    """"/dev/bus/usb/001/002" """
+    HID = 2
+    """A HID device that is no keyboard, mouse or joystick ("/dev/hidraw0"): use the hid
+    package (hidapi), hid.Device(vid=e.VendorId, pid=e.ProductId)"""
+    Mouse = 3
+    """"/dev/input/event2": open it with Mouse(e.DeviceName)"""
+    Keyboard = 4
+    """"/dev/input/event1": open it with Keyboard(e.DeviceName)"""
+    Joystick = 5
+    """Joysticks and gamepads ("/dev/input/event3"): open it with Joystick(e.DeviceName)"""
+    MassStorage = 6
+    """A drive: use StorageController (no name)"""
+    Printer = 7
+    """"/dev/usb/lp0": open it with Printer(e.DeviceName)"""
+    Serial = 8
+    """A serial port, for pyserial ("/dev/ttyUSB0", "/dev/ttyACM0")"""
+    Webcam = 9
+    """"/dev/video0": open it with UsbCamera (GHIElectronics.Endpoint.Devices.Camera)"""
+    Audio = 10
+    """A sound card: speaker, microphone ("hw:1")"""
+    Network = 11
+    """An Ethernet, WiFi or cellular adapter: the network interface ("eth1", "wlan1")"""
+    Bluetooth = 12
+    """"hci0" """
+    Touch = 13
+    """"/dev/input/eventN": open it with Touch (built-in or USB touchscreen)"""
+
+
+class Buttons(IntFlag):
+    """The mouse buttons"""
+
+    None_ = 0x00
+    Left = 0x01
+    Right = 0x02
+    Middle = 0x04
+    Extended1 = 0x08
+    Extended2 = 0x10
+
+
+class ButtonState(IntEnum):
+    Released = 0
+    Pressed = 1
+
+
+class Cursor(IntEnum):
+    """A joystick's sticks: Cursor1 (left), Cursor2 (right)"""
+
+    Cursor1 = 0
+    Cursor2 = 1
+
+
+class KeyState(IntEnum):
+    Released = 2
+    Pressed = 1
+
+
+class HatSwitchDirection(IntEnum):
+    Up = 0
+    UpRight = 1
+    Right = 2
+    DownRight = 3
+    Down = 4
+    DownLeft = 5
+    Left = 6
+    UpLeft = 7
+    None_ = 8
+
+
+class Key(IntEnum):
+    """The keys on the keyboard: USB key codes. D0 to D9 are the number keys. A key
+    TinyCLR has no name for (F13, media keys) comes as its USB key code (an int)."""
+
+    None_ = 0
+    A = 4
+    B = 5
+    C = 6
+    D = 7
+    E = 8
+    F = 9
+    G = 10
+    H = 11
+    I = 12
+    J = 13
+    K = 14
+    L = 15
+    M = 16
+    N = 17
+    O = 18
+    P = 19
+    Q = 20
+    R = 21
+    S = 22
+    T = 23
+    U = 24
+    V = 25
+    W = 26
+    X = 27
+    Y = 28
+    Z = 29
+    D1 = 30
+    D2 = 31
+    D3 = 32
+    D4 = 33
+    D5 = 34
+    D6 = 35
+    D7 = 36
+    D8 = 37
+    D9 = 38
+    D0 = 39
+    Enter = 40
+    Escape = 41
+    BackSpace = 42
+    Tab = 43
+    Space = 44
+    Substract = 45
+    Equal = 46
+    OpenBrackets = 47
+    CloseBrackets = 48
+    Backslash = 49
+    NonUS = 50
+    Semicolon = 51
+    Quotes = 52
+    GraveAccent = 53
+    Comma = 54
+    Period = 55
+    Divide = 56
+    CapsLock = 57
+    F1 = 58
+    F2 = 59
+    F3 = 60
+    F4 = 61
+    F5 = 62
+    F6 = 63
+    F7 = 64
+    F8 = 65
+    F9 = 66
+    F10 = 67
+    F11 = 68
+    F12 = 69
+    PrintScreen = 70
+    ScrollLock = 71
+    Pause = 72
+    Insert = 73
+    Home = 74
+    PageUp = 75
+    Delete = 76
+    End = 77
+    PageDown = 78
+    RightArrow = 79
+    LeftArrow = 80
+    DownArrow = 81
+    UpArrow = 82
+    NumLock = 83
+    KeypadDivide = 84
+    KeypadMultiply = 85
+    KeypadSubstract = 86
+    KeypadAdd = 87
+    KeypadEnter = 88
+    Keypad1 = 89
+    Keypad2 = 90
+    Keypad3 = 91
+    Keypad4 = 92
+    Keypad5 = 93
+    Keypad6 = 94
+    Keypad7 = 95
+    Keypad8 = 96
+    Keypad9 = 97
+    Keypad0 = 98
+    KeypadDelete = 99
+    NonUS2 = 100
+    Application = 101
+    LeftCtrl = 0xE0
+    LeftShift = 0xE1
+    LeftAlt = 0xE2
+    LeftGUI = 0xE3
+    RightCtrl = 0xE4
+    RightShift = 0xE5
+    RightAlt = 0xE6
+    RightGUI = 0xE7
+
+
+class Position:
+    """A position: X, Y (and Z)"""
+
+    def __init__(self, X=0, Y=0, Z=0):
+        self.X = X
+        self.Y = Y
+        self.Z = Z
+
+    def __sub__(self, other):
+        return Position(self.X - other.X, self.Y - other.Y, self.Z - other.Z)
+
+    def __eq__(self, other):
+        return isinstance(other, Position) and (self.X, self.Y, self.Z) == (other.X, other.Y, other.Z)
+
+    def __hash__(self):
+        return hash((self.X, self.Y, self.Z))
+
+    def __str__(self):
+        return f"({self.X}, {self.Y}, {self.Z})"
+
+    def __repr__(self):
+        return f"Position({self.X}, {self.Y}, {self.Z})"

ghielectronics_endpoint_devices_usbhost-0.5.3.dist-info/METADATA

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: GHIElectronics.Endpoint.Devices.UsbHost
+Version: 0.5.3
+Summary: USB devices of GHI Electronics Endpoint: connected and disconnected events, what each device is and its port or network interface.
+Author-email: "GHI Electronics, LLC" <support@ghielectronics.com>
+License-Expression: MIT
+Project-URL: Homepage, https://www.ghielectronics.com/
+Project-URL: Repository, https://github.com/ghi-electronics/Endpoint-Libraries
+Project-URL: Issues, https://github.com/ghi-electronics/Endpoint-Libraries/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: GHIElectronics.Endpoint.Core<0.6,>=0.5.3
+
+# GHIElectronics.Endpoint.Devices.UsbHost
+
+USB devices of GHI Electronics Endpoint: connected and disconnected events, what each device is and its port or network interface.
+
+Part of the [GHI Electronics Endpoint](https://github.com/ghi-electronics/Endpoint-Libraries) libraries. See the repository README for the full package list and getting-started guide.

ghielectronics_endpoint_devices_usbhost-0.5.3.dist-info/RECORD

@@ -0,0 +1,7 @@
+GHIElectronics/Endpoint/Devices/UsbHost/__init__.py,sha256=gzNOm5rEgbFOVaEOA_6g9Mefp7feWWkRcM75X7mLXho,5764
+GHIElectronics/Endpoint/Devices/UsbHost/_input.py,sha256=nPfnZp1lenmXX_sUVq1XEVV0qdi6UVRA5HHXO9eNup4,14972
+GHIElectronics/Endpoint/Devices/UsbHost/_types.py,sha256=MVbgBPxptDKc6msY9Z5DWCtnA3BFzFwHWZ5GyL3aDm0,4633
+ghielectronics_endpoint_devices_usbhost-0.5.3.dist-info/METADATA,sha256=dxi9liDMyT5LjzZvG3czKtGmq3DwfXu9xJm_VNjEcwA,1123
+ghielectronics_endpoint_devices_usbhost-0.5.3.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+ghielectronics_endpoint_devices_usbhost-0.5.3.dist-info/top_level.txt,sha256=NpOZNgd0iquwrRPrTOhUDxc2V9TtNFLv5Z_Dx3YZtIU,15
+ghielectronics_endpoint_devices_usbhost-0.5.3.dist-info/RECORD,,

ghielectronics_endpoint_devices_usbhost-0.5.3.dist-info/WHEEL

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

ghielectronics_endpoint_devices_usbhost-0.5.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+GHIElectronics