hid 1.0.5__tar.gz → 1.0.6__tar.gz

hid-1.0.6/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Austin Morton
+
+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.

{hid-1.0.5 → hid-1.0.6}/MANIFEST.in

@@ -1 +1,2 @@
-include README.md
+include README.md
+include LICENSE

hid-1.0.6/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.1
+Name: hid
+Version: 1.0.6
+Summary: ctypes bindings for hidapi
+Home-page: https://github.com/apmorton/pyhidapi
+Author: Austin Morton
+Author-email: amorton@juvsoft.com
+License: MIT
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Installing pyhidapi
+pyhidapi is available on [PyPI](https://pypi.org/project/hid/) and can be installed using pip.
+```
+pip install hid
+```
+
+pyhidapi is dependant upon the [hidapi library](https://github.com/libusb/hidapi), which must be installed separately.
+
+# Installing hidapi
+
+## Linux
+Installation procedures vary depending on your distribution.
+
+### Arch Linux
+Binary distributions are available in the community repository.
+
+1. Enable the community repository in `/etc/pacman.conf`
+```
+[community]
+Include = /etc/pacman.d/mirrorlist
+```
+2. Install hidapi
+```
+pacman -Sy hidapi
+```
+
+### CentOS/RHEL
+Binary distributions are available through [EPEL](https://fedoraproject.org/wiki/EPEL).
+```
+yum install hidapi
+```
+
+### Fedora
+Binary distributions are available.
+```
+dnf install hidapi
+```
+
+### Ubuntu/Debian
+Binary distributions are available.
+
+```
+apt install libhidapi-hidraw0
+```
+or
+```
+apt install libhidapi-libusb0
+```
+
+### Others
+Binary distributions may be available in your package repositories. If not, you can build from source as described [in the libusb/hidapi README](https://github.com/libusb/hidapi#build-instructions).
+
+## Windows
+Installation procedure for Windows is described [in the libusb/hidapi README](https://github.com/libusb/hidapi#building-on-windows)
+
+Binary distributions are provided by [libusb/hidapi](https://github.com/libusb/hidapi/releases)
+
+## OSX
+There are currently no official binary distributions for Mac, so you must build hidapi yourself.
+
+Installation instructions are described [in the libusb/hidapi README](https://github.com/libusb/hidapi#mac)
+
+You can also use brew:
+```
+brew install hidapi
+```
+
+## FreeBSD
+Binary distributions are available.
+
+```
+pkg install -g 'py3*-hid'
+```
+
+# Sample usage code
+
+The details about a HID device can be printed with following code:
+
+```python
+import hid
+
+vid = 0x046d	# Change it for your device
+pid = 0xc534	# Change it for your device
+
+with hid.Device(vid, pid) as h:
+	print(f'Device manufacturer: {h.manufacturer}')
+	print(f'Product: {h.product}')
+	print(f'Serial Number: {h.serial}')
+```
+

{hid-1.0.5 → hid-1.0.6}/README.md

@@ -1,90 +1,90 @@
-# Installing pyhidapi
-pyhidapi is available on [PyPI](https://pypi.org/project/hid/) and can be installed using pip.
-```
-pip install hid
-```
-
-pyhidapi is dependant upon the [hidapi library](https://github.com/libusb/hidapi), which must be installed separately.
-
-# Installing hidapi
-
-## Linux
-Installation procedures vary depending on your distribution.
-
-### Arch Linux
-Binary distributions are available in the community repository.
-
-1. Enable the community repository in `/etc/pacman.conf`
-```
-[community]
-Include = /etc/pacman.d/mirrorlist
-```
-2. Install hidapi
-```
-pacman -Sy hidapi
-```
-
-### CentOS/RHEL
-Binary distributions are available through [EPEL](https://fedoraproject.org/wiki/EPEL).
-```
-yum install hidapi
-```
-
-### Fedora
-Binary distributions are available.
-```
-dnf install hidapi
-```
-
-### Ubuntu/Debian
-Binary distributions are available.
-
-```
-apt install libhidapi-hidraw0
-```
-or
-```
-apt install libhidapi-libusb0
-```
-
-### Others
-Binary distributions may be available in your package repositories. If not, you can build from source as described [in the libusb/hidapi README](https://github.com/libusb/hidapi#build-instructions).
-
-## Windows
-Installation procedure for Windows is described [in the libusb/hidapi README](https://github.com/libusb/hidapi#building-on-windows)
-
-Binary distributions are provided by [libusb/hidapi](https://github.com/libusb/hidapi/releases)
-
-## OSX
-There are currently no official binary distributions for Mac, so you must build hidapi yourself.
-
-Installation instructions are described [in the libusb/hidapi README](https://github.com/libusb/hidapi#mac)
-
-You can also use brew:
-```
-brew install hidapi
-```
-
-## FreeBSD
-Binary distributions are available.
-
-```
-pkg install -g 'py3*-hid'
-```
-
-# Sample usage code
-
-The details about a HID device can be printed with following code:
-
-```python
-import hid
-
-vid = 0x046d	# Change it for your device
-pid = 0xc534	# Change it for your device
-
-with hid.Device(vid, pid) as h:
-	print(f'Device manufacturer: {h.manufacturer}')
-	print(f'Product: {h.product}')
-	print(f'Serial Number: {h.serial}')
-```
-
+# Installing pyhidapi
+pyhidapi is available on [PyPI](https://pypi.org/project/hid/) and can be installed using pip.
+```
+pip install hid
+```
+
+pyhidapi is dependant upon the [hidapi library](https://github.com/libusb/hidapi), which must be installed separately.
+
+# Installing hidapi
+
+## Linux
+Installation procedures vary depending on your distribution.
+
+### Arch Linux
+Binary distributions are available in the community repository.
+
+1. Enable the community repository in `/etc/pacman.conf`
+```
+[community]
+Include = /etc/pacman.d/mirrorlist
+```
+2. Install hidapi
+```
+pacman -Sy hidapi
+```
+
+### CentOS/RHEL
+Binary distributions are available through [EPEL](https://fedoraproject.org/wiki/EPEL).
+```
+yum install hidapi
+```
+
+### Fedora
+Binary distributions are available.
+```
+dnf install hidapi
+```
+
+### Ubuntu/Debian
+Binary distributions are available.
+
+```
+apt install libhidapi-hidraw0
+```
+or
+```
+apt install libhidapi-libusb0
+```
+
+### Others
+Binary distributions may be available in your package repositories. If not, you can build from source as described [in the libusb/hidapi README](https://github.com/libusb/hidapi#build-instructions).
+
+## Windows
+Installation procedure for Windows is described [in the libusb/hidapi README](https://github.com/libusb/hidapi#building-on-windows)
+
+Binary distributions are provided by [libusb/hidapi](https://github.com/libusb/hidapi/releases)
+
+## OSX
+There are currently no official binary distributions for Mac, so you must build hidapi yourself.
+
+Installation instructions are described [in the libusb/hidapi README](https://github.com/libusb/hidapi#mac)
+
+You can also use brew:
+```
+brew install hidapi
+```
+
+## FreeBSD
+Binary distributions are available.
+
+```
+pkg install -g 'py3*-hid'
+```
+
+# Sample usage code
+
+The details about a HID device can be printed with following code:
+
+```python
+import hid
+
+vid = 0x046d	# Change it for your device
+pid = 0xc534	# Change it for your device
+
+with hid.Device(vid, pid) as h:
+	print(f'Device manufacturer: {h.manufacturer}')
+	print(f'Product: {h.product}')
+	print(f'Serial Number: {h.serial}')
+```
+

{hid-1.0.5 → hid-1.0.6}/hid/__init__.py

@@ -1,224 +1,266 @@
-import os
-import ctypes
-import atexit
-
-__all__ = ['HIDException', 'DeviceInfo', 'Device', 'enumerate']
-
-
-hidapi = None
-library_paths = (
-    'libhidapi-hidraw.so',
-    'libhidapi-hidraw.so.0',
-    'libhidapi-libusb.so',
-    'libhidapi-libusb.so.0',
-    'libhidapi-iohidmanager.so',
-    'libhidapi-iohidmanager.so.0',
-    'libhidapi.dylib',
-    'hidapi.dll',
-    'libhidapi-0.dll'
-)
-
-for lib in library_paths:
-    try:
-        hidapi = ctypes.cdll.LoadLibrary(lib)
-        break
-    except OSError:
-        pass
-else:
-    error = "Unable to load any of the following libraries:{}"\
-        .format(' '.join(library_paths))
-    raise ImportError(error)
-
-
-hidapi.hid_init()
-atexit.register(hidapi.hid_exit)
-
-
-class HIDException(Exception):
-    pass
-
-
-class DeviceInfo(ctypes.Structure):
-    def as_dict(self):
-        ret = {}
-        for name, type in self._fields_:
-            if name == 'next':
-                continue
-            ret[name] = getattr(self, name, None)
-
-        return ret
-
-DeviceInfo._fields_ = [
-    ('path', ctypes.c_char_p),
-    ('vendor_id', ctypes.c_ushort),
-    ('product_id', ctypes.c_ushort),
-    ('serial_number', ctypes.c_wchar_p),
-    ('release_number', ctypes.c_ushort),
-    ('manufacturer_string', ctypes.c_wchar_p),
-    ('product_string', ctypes.c_wchar_p),
-    ('usage_page', ctypes.c_ushort),
-    ('usage', ctypes.c_ushort),
-    ('interface_number', ctypes.c_int),
-    ('next', ctypes.POINTER(DeviceInfo)),
-]
-
-hidapi.hid_init.argtypes = []
-hidapi.hid_init.restype = ctypes.c_int
-hidapi.hid_exit.argtypes = []
-hidapi.hid_exit.restype = ctypes.c_int
-hidapi.hid_enumerate.argtypes = [ctypes.c_ushort, ctypes.c_ushort]
-hidapi.hid_enumerate.restype = ctypes.POINTER(DeviceInfo)
-hidapi.hid_free_enumeration.argtypes = [ctypes.POINTER(DeviceInfo)]
-hidapi.hid_free_enumeration.restype = None
-hidapi.hid_open.argtypes = [ctypes.c_ushort, ctypes.c_ushort, ctypes.c_wchar_p]
-hidapi.hid_open.restype = ctypes.c_void_p
-hidapi.hid_open_path.argtypes = [ctypes.c_char_p]
-hidapi.hid_open_path.restype = ctypes.c_void_p
-hidapi.hid_write.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t]
-hidapi.hid_write.restype = ctypes.c_int
-hidapi.hid_read_timeout.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t, ctypes.c_int]
-hidapi.hid_read_timeout.restype = ctypes.c_int
-hidapi.hid_read.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t]
-hidapi.hid_read.restype = ctypes.c_int
-hidapi.hid_get_input_report.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t]
-hidapi.hid_get_input_report.restype = ctypes.c_int
-hidapi.hid_set_nonblocking.argtypes = [ctypes.c_void_p, ctypes.c_int]
-hidapi.hid_set_nonblocking.restype = ctypes.c_int
-hidapi.hid_send_feature_report.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
-hidapi.hid_send_feature_report.restype = ctypes.c_int
-hidapi.hid_get_feature_report.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t]
-hidapi.hid_get_feature_report.restype = ctypes.c_int
-hidapi.hid_close.argtypes = [ctypes.c_void_p]
-hidapi.hid_close.restype = None
-hidapi.hid_get_manufacturer_string.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_size_t]
-hidapi.hid_get_manufacturer_string.restype = ctypes.c_int
-hidapi.hid_get_product_string.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_size_t]
-hidapi.hid_get_product_string.restype = ctypes.c_int
-hidapi.hid_get_serial_number_string.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_size_t]
-hidapi.hid_get_serial_number_string.restype = ctypes.c_int
-hidapi.hid_get_indexed_string.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_wchar_p, ctypes.c_size_t]
-hidapi.hid_get_indexed_string.restype = ctypes.c_int
-hidapi.hid_error.argtypes = [ctypes.c_void_p]
-hidapi.hid_error.restype = ctypes.c_wchar_p
-
-
-def enumerate(vid=0, pid=0):
-    ret = []
-    info = hidapi.hid_enumerate(vid, pid)
-    c = info
-
-    while c:
-        ret.append(c.contents.as_dict())
-        c = c.contents.next
-
-    hidapi.hid_free_enumeration(info)
-
-    return ret
-
-
-class Device(object):
-    def __init__(self, vid=None, pid=None, serial=None, path=None):
-        if path:
-            self.__dev = hidapi.hid_open_path(path)
-        elif serial:
-            serial = ctypes.create_unicode_buffer(serial)
-            self.__dev = hidapi.hid_open(vid, pid, serial)
-        elif vid and pid:
-            self.__dev = hidapi.hid_open(vid, pid, None)
-        else:
-            raise ValueError('specify vid/pid or path')
-
-        if not self.__dev:
-            raise HIDException('unable to open device')
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, exc_type, exc_value, exc_traceback):
-        self.close()
-
-    def __hidcall(self, function, *args, **kwargs):
-        if not self.__dev:
-            raise HIDException('device closed')
-
-        ret = function(*args, **kwargs)
-
-        if ret == -1:
-            err = hidapi.hid_error(self.__dev)
-            raise HIDException(err)
-        return ret
-
-    def __readstring(self, function, max_length=255):
-        buf = ctypes.create_unicode_buffer(max_length)
-        self.__hidcall(function, self.__dev, buf, max_length)
-        return buf.value
-
-    def write(self, data):
-        return self.__hidcall(hidapi.hid_write, self.__dev, data, len(data))
-
-    def read(self, size, timeout=None):
-        data = ctypes.create_string_buffer(size)
-
-        if timeout is None:
-            size = self.__hidcall(hidapi.hid_read, self.__dev, data, size)
-        else:
-            size = self.__hidcall(
-                hidapi.hid_read_timeout, self.__dev, data, size, timeout)
-
-        return data.raw[:size]
-
-    def get_input_report(self, report_id, size):
-        data = ctypes.create_string_buffer(size)
-
-        # Pass the id of the report to be read.
-        data[0] = bytearray((report_id,))
-
-        size = self.__hidcall(
-            hidapi.hid_get_input_report, self.__dev, data, size)
-        return data.raw[:size]
-
-    def send_feature_report(self, data):
-        return self.__hidcall(hidapi.hid_send_feature_report,
-                              self.__dev, data, len(data))
-
-    def get_feature_report(self, report_id, size):
-        data = ctypes.create_string_buffer(size)
-
-        # Pass the id of the report to be read.
-        data[0] = bytearray((report_id,))
-
-        size = self.__hidcall(
-            hidapi.hid_get_feature_report, self.__dev, data, size)
-        return data.raw[:size]
-
-    def close(self):
-        if self.__dev:
-            hidapi.hid_close(self.__dev)
-            self.__dev = None
-
-    @property
-    def nonblocking(self):
-        return getattr(self, '_nonblocking', 0)
-
-    @nonblocking.setter
-    def nonblocking(self, value):
-        self.__hidcall(hidapi.hid_set_nonblocking, self.__dev, value)
-        setattr(self, '_nonblocking', value)
-
-    @property
-    def manufacturer(self):
-        return self.__readstring(hidapi.hid_get_manufacturer_string)
-
-    @property
-    def product(self):
-        return self.__readstring(hidapi.hid_get_product_string)
-
-    @property
-    def serial(self):
-        return self.__readstring(hidapi.hid_get_serial_number_string)
-
-    def get_indexed_string(self, index, max_length=255):
-        buf = ctypes.create_unicode_buffer(max_length)
-        self.__hidcall(hidapi.hid_get_indexed_string,
-                       self.__dev, index, buf, max_length)
-        return buf.value
+import os
+import ctypes
+import atexit
+import enum
+
+__all__ = ['HIDException', 'DeviceInfo', 'Device', 'enumerate', 'BusType']
+
+
+hidapi = None
+library_paths = (
+    'libhidapi-hidraw.so',
+    'libhidapi-hidraw.so.0',
+    'libhidapi-libusb.so',
+    'libhidapi-libusb.so.0',
+    'libhidapi-iohidmanager.so',
+    'libhidapi-iohidmanager.so.0',
+    'libhidapi.dylib',
+    'hidapi.dll',
+    'libhidapi-0.dll'
+)
+
+for lib in library_paths:
+    try:
+        hidapi = ctypes.cdll.LoadLibrary(lib)
+        break
+    except OSError:
+        pass
+else:
+    error = "Unable to load any of the following libraries:{}"\
+        .format(' '.join(library_paths))
+    raise ImportError(error)
+
+
+hidapi.hid_init()
+atexit.register(hidapi.hid_exit)
+
+
+class HIDException(Exception):
+    pass
+
+class APIVersion(ctypes.Structure):
+    _fields_ = [
+        ('major', ctypes.c_int),
+        ('minor', ctypes.c_int),
+        ('patch', ctypes.c_int),
+    ]
+
+try:
+    hidapi.hid_version.argtypes = []
+    hidapi.hid_version.restype = ctypes.POINTER(APIVersion)
+
+    version = hidapi.hid_version()
+    version = (
+        version.contents.major,
+        version.contents.minor,
+        version.contents.patch,
+    )
+except AttributeError:
+    #
+    # hid_version API was added in
+    # https://github.com/libusb/hidapi/commit/8f72236099290345928e646d2f2c48f0187ac4af
+    # so if it is missing we are dealing with hidapi 0.8.0 or older
+    #
+    version = (0, 8, 0)
+
+if version >= (0, 13, 0):
+    bus_type = [
+        ('bus_type', ctypes.c_int),
+    ]
+else:
+    bus_type = []
+
+class BusType(enum.Enum):
+    UNKNOWN = 0x00
+    USB = 0x01
+    BLUETOOTH = 0x02
+    I2C = 0x03
+    SPI = 0x04
+
+class DeviceInfo(ctypes.Structure):
+    def as_dict(self):
+        ret = {}
+        for name, type in self._fields_:
+            if name == 'next':
+                continue
+            ret[name] = getattr(self, name, None)
+
+            if name == 'bus_type':
+                ret[name] = BusType(ret[name])
+
+        return ret
+
+DeviceInfo._fields_ = [
+    ('path', ctypes.c_char_p),
+    ('vendor_id', ctypes.c_ushort),
+    ('product_id', ctypes.c_ushort),
+    ('serial_number', ctypes.c_wchar_p),
+    ('release_number', ctypes.c_ushort),
+    ('manufacturer_string', ctypes.c_wchar_p),
+    ('product_string', ctypes.c_wchar_p),
+    ('usage_page', ctypes.c_ushort),
+    ('usage', ctypes.c_ushort),
+    ('interface_number', ctypes.c_int),
+    ('next', ctypes.POINTER(DeviceInfo)),
+] + bus_type
+
+hidapi.hid_init.argtypes = []
+hidapi.hid_init.restype = ctypes.c_int
+hidapi.hid_exit.argtypes = []
+hidapi.hid_exit.restype = ctypes.c_int
+hidapi.hid_enumerate.argtypes = [ctypes.c_ushort, ctypes.c_ushort]
+hidapi.hid_enumerate.restype = ctypes.POINTER(DeviceInfo)
+hidapi.hid_free_enumeration.argtypes = [ctypes.POINTER(DeviceInfo)]
+hidapi.hid_free_enumeration.restype = None
+hidapi.hid_open.argtypes = [ctypes.c_ushort, ctypes.c_ushort, ctypes.c_wchar_p]
+hidapi.hid_open.restype = ctypes.c_void_p
+hidapi.hid_open_path.argtypes = [ctypes.c_char_p]
+hidapi.hid_open_path.restype = ctypes.c_void_p
+hidapi.hid_write.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t]
+hidapi.hid_write.restype = ctypes.c_int
+hidapi.hid_read_timeout.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t, ctypes.c_int]
+hidapi.hid_read_timeout.restype = ctypes.c_int
+hidapi.hid_read.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t]
+hidapi.hid_read.restype = ctypes.c_int
+hidapi.hid_get_input_report.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t]
+hidapi.hid_get_input_report.restype = ctypes.c_int
+hidapi.hid_set_nonblocking.argtypes = [ctypes.c_void_p, ctypes.c_int]
+hidapi.hid_set_nonblocking.restype = ctypes.c_int
+hidapi.hid_send_feature_report.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_int]
+hidapi.hid_send_feature_report.restype = ctypes.c_int
+hidapi.hid_get_feature_report.argtypes = [ctypes.c_void_p, ctypes.c_char_p, ctypes.c_size_t]
+hidapi.hid_get_feature_report.restype = ctypes.c_int
+hidapi.hid_close.argtypes = [ctypes.c_void_p]
+hidapi.hid_close.restype = None
+hidapi.hid_get_manufacturer_string.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_size_t]
+hidapi.hid_get_manufacturer_string.restype = ctypes.c_int
+hidapi.hid_get_product_string.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_size_t]
+hidapi.hid_get_product_string.restype = ctypes.c_int
+hidapi.hid_get_serial_number_string.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_size_t]
+hidapi.hid_get_serial_number_string.restype = ctypes.c_int
+hidapi.hid_get_indexed_string.argtypes = [ctypes.c_void_p, ctypes.c_int, ctypes.c_wchar_p, ctypes.c_size_t]
+hidapi.hid_get_indexed_string.restype = ctypes.c_int
+hidapi.hid_error.argtypes = [ctypes.c_void_p]
+hidapi.hid_error.restype = ctypes.c_wchar_p
+
+
+def enumerate(vid=0, pid=0):
+    ret = []
+    info = hidapi.hid_enumerate(vid, pid)
+    c = info
+
+    while c:
+        ret.append(c.contents.as_dict())
+        c = c.contents.next
+
+    hidapi.hid_free_enumeration(info)
+
+    return ret
+
+
+class Device(object):
+    def __init__(self, vid=None, pid=None, serial=None, path=None):
+        if path:
+            self.__dev = hidapi.hid_open_path(path)
+        elif serial:
+            serial = ctypes.create_unicode_buffer(serial)
+            self.__dev = hidapi.hid_open(vid, pid, serial)
+        elif vid and pid:
+            self.__dev = hidapi.hid_open(vid, pid, None)
+        else:
+            raise ValueError('specify vid/pid or path')
+
+        if not self.__dev:
+            raise HIDException('unable to open device')
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, exc_traceback):
+        self.close()
+
+    def __hidcall(self, function, *args, **kwargs):
+        if not self.__dev:
+            raise HIDException('device closed')
+
+        ret = function(*args, **kwargs)
+
+        if ret == -1:
+            err = hidapi.hid_error(self.__dev)
+            raise HIDException(err)
+        return ret
+
+    def __readstring(self, function, max_length=255):
+        buf = ctypes.create_unicode_buffer(max_length)
+        self.__hidcall(function, self.__dev, buf, max_length)
+        return buf.value
+
+    def write(self, data):
+        return self.__hidcall(hidapi.hid_write, self.__dev, data, len(data))
+
+    def read(self, size, timeout=None):
+        data = ctypes.create_string_buffer(size)
+
+        if timeout is None:
+            size = self.__hidcall(hidapi.hid_read, self.__dev, data, size)
+        else:
+            size = self.__hidcall(
+                hidapi.hid_read_timeout, self.__dev, data, size, timeout)
+
+        return data.raw[:size]
+
+    def get_input_report(self, report_id, size):
+        data = ctypes.create_string_buffer(size)
+
+        # Pass the id of the report to be read.
+        data[0] = bytearray((report_id,))
+
+        size = self.__hidcall(
+            hidapi.hid_get_input_report, self.__dev, data, size)
+        return data.raw[:size]
+
+    def send_feature_report(self, data):
+        return self.__hidcall(hidapi.hid_send_feature_report,
+                              self.__dev, data, len(data))
+
+    def get_feature_report(self, report_id, size):
+        data = ctypes.create_string_buffer(size)
+
+        # Pass the id of the report to be read.
+        data[0] = bytearray((report_id,))
+
+        size = self.__hidcall(
+            hidapi.hid_get_feature_report, self.__dev, data, size)
+        return data.raw[:size]
+
+    def close(self):
+        if self.__dev:
+            hidapi.hid_close(self.__dev)
+            self.__dev = None
+
+    @property
+    def nonblocking(self):
+        return getattr(self, '_nonblocking', 0)
+
+    @nonblocking.setter
+    def nonblocking(self, value):
+        self.__hidcall(hidapi.hid_set_nonblocking, self.__dev, value)
+        setattr(self, '_nonblocking', value)
+
+    @property
+    def manufacturer(self):
+        return self.__readstring(hidapi.hid_get_manufacturer_string)
+
+    @property
+    def product(self):
+        return self.__readstring(hidapi.hid_get_product_string)
+
+    @property
+    def serial(self):
+        return self.__readstring(hidapi.hid_get_serial_number_string)
+
+    def get_indexed_string(self, index, max_length=255):
+        buf = ctypes.create_unicode_buffer(max_length)
+        self.__hidcall(hidapi.hid_get_indexed_string,
+                       self.__dev, index, buf, max_length)
+        return buf.value

hid-1.0.6/hid.egg-info/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.1
+Name: hid
+Version: 1.0.6
+Summary: ctypes bindings for hidapi
+Home-page: https://github.com/apmorton/pyhidapi
+Author: Austin Morton
+Author-email: amorton@juvsoft.com
+License: MIT
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# Installing pyhidapi
+pyhidapi is available on [PyPI](https://pypi.org/project/hid/) and can be installed using pip.
+```
+pip install hid
+```
+
+pyhidapi is dependant upon the [hidapi library](https://github.com/libusb/hidapi), which must be installed separately.
+
+# Installing hidapi
+
+## Linux
+Installation procedures vary depending on your distribution.
+
+### Arch Linux
+Binary distributions are available in the community repository.
+
+1. Enable the community repository in `/etc/pacman.conf`
+```
+[community]
+Include = /etc/pacman.d/mirrorlist
+```
+2. Install hidapi
+```
+pacman -Sy hidapi
+```
+
+### CentOS/RHEL
+Binary distributions are available through [EPEL](https://fedoraproject.org/wiki/EPEL).
+```
+yum install hidapi
+```
+
+### Fedora
+Binary distributions are available.
+```
+dnf install hidapi
+```
+
+### Ubuntu/Debian
+Binary distributions are available.
+
+```
+apt install libhidapi-hidraw0
+```
+or
+```
+apt install libhidapi-libusb0
+```
+
+### Others
+Binary distributions may be available in your package repositories. If not, you can build from source as described [in the libusb/hidapi README](https://github.com/libusb/hidapi#build-instructions).
+
+## Windows
+Installation procedure for Windows is described [in the libusb/hidapi README](https://github.com/libusb/hidapi#building-on-windows)
+
+Binary distributions are provided by [libusb/hidapi](https://github.com/libusb/hidapi/releases)
+
+## OSX
+There are currently no official binary distributions for Mac, so you must build hidapi yourself.
+
+Installation instructions are described [in the libusb/hidapi README](https://github.com/libusb/hidapi#mac)
+
+You can also use brew:
+```
+brew install hidapi
+```
+
+## FreeBSD
+Binary distributions are available.
+
+```
+pkg install -g 'py3*-hid'
+```
+
+# Sample usage code
+
+The details about a HID device can be printed with following code:
+
+```python
+import hid
+
+vid = 0x046d	# Change it for your device
+pid = 0xc534	# Change it for your device
+
+with hid.Device(vid, pid) as h:
+	print(f'Device manufacturer: {h.manufacturer}')
+	print(f'Product: {h.product}')
+	print(f'Serial Number: {h.serial}')
+```
+

{hid-1.0.5 → hid-1.0.6}/hid.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 MANIFEST.in
 README.md
 setup.cfg

{hid-1.0.5 → hid-1.0.6}/setup.py

@@ -1,33 +1,31 @@
-from setuptools import setup, find_packages
-import os
-
-here = os.path.abspath(os.path.dirname(__file__))
-README = open(os.path.join(here, 'README.md')).read()
-
-
-version = '1.0.5'
-
-setup(
-    name='hid',
-    version=version,
-    description='ctypes bindings for hidapi',
-    long_description=README,
-    long_description_content_type='text/markdown',
-    classifiers=[
-        'Intended Audience :: Developers',
-        'License :: OSI Approved :: MIT License',
-        'Operating System :: OS Independent',
-        'Programming Language :: Python',
-        'Programming Language :: Python :: 2.6',
-        'Programming Language :: Python :: 2.7',
-        'Programming Language :: Python :: 3',
-    ],
-    keywords='',
-    author='Austin Morton',
-    author_email='amorton@juvsoft.com',
-    url='https://github.com/apmorton/pyhidapi',
-    license='MIT',
-    packages=find_packages(),
-    zip_safe=False,
-    test_suite='nose.collector'
-)
+from setuptools import setup, find_packages
+import os
+
+here = os.path.abspath(os.path.dirname(__file__))
+README = open(os.path.join(here, 'README.md')).read()
+
+
+version = '1.0.6'
+
+setup(
+    name='hid',
+    version=version,
+    description='ctypes bindings for hidapi',
+    long_description=README,
+    long_description_content_type='text/markdown',
+    classifiers=[
+        'Intended Audience :: Developers',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+    ],
+    keywords='',
+    author='Austin Morton',
+    author_email='amorton@juvsoft.com',
+    url='https://github.com/apmorton/pyhidapi',
+    license='MIT',
+    packages=find_packages(),
+    zip_safe=False,
+    test_suite='nose.collector'
+)

hid-1.0.5/PKG-INFO

@@ -1,108 +0,0 @@
-Metadata-Version: 2.1
-Name: hid
-Version: 1.0.5
-Summary: ctypes bindings for hidapi
-Home-page: https://github.com/apmorton/pyhidapi
-Author: Austin Morton
-Author-email: amorton@juvsoft.com
-License: MIT
-Description: # Installing pyhidapi
-        pyhidapi is available on [PyPI](https://pypi.org/project/hid/) and can be installed using pip.
-        ```
-        pip install hid
-        ```
-        
-        pyhidapi is dependant upon the [hidapi library](https://github.com/libusb/hidapi), which must be installed separately.
-        
-        # Installing hidapi
-        
-        ## Linux
-        Installation procedures vary depending on your distribution.
-        
-        ### Arch Linux
-        Binary distributions are available in the community repository.
-        
-        1. Enable the community repository in `/etc/pacman.conf`
-        ```
-        [community]
-        Include = /etc/pacman.d/mirrorlist
-        ```
-        2. Install hidapi
-        ```
-        pacman -Sy hidapi
-        ```
-        
-        ### CentOS/RHEL
-        Binary distributions are available through [EPEL](https://fedoraproject.org/wiki/EPEL).
-        ```
-        yum install hidapi
-        ```
-        
-        ### Fedora
-        Binary distributions are available.
-        ```
-        dnf install hidapi
-        ```
-        
-        ### Ubuntu/Debian
-        Binary distributions are available.
-        
-        ```
-        apt install libhidapi-hidraw0
-        ```
-        or
-        ```
-        apt install libhidapi-libusb0
-        ```
-        
-        ### Others
-        Binary distributions may be available in your package repositories. If not, you can build from source as described [in the libusb/hidapi README](https://github.com/libusb/hidapi#build-instructions).
-        
-        ## Windows
-        Installation procedure for Windows is described [in the libusb/hidapi README](https://github.com/libusb/hidapi#building-on-windows)
-        
-        Binary distributions are provided by [libusb/hidapi](https://github.com/libusb/hidapi/releases)
-        
-        ## OSX
-        There are currently no official binary distributions for Mac, so you must build hidapi yourself.
-        
-        Installation instructions are described [in the libusb/hidapi README](https://github.com/libusb/hidapi#mac)
-        
-        You can also use brew:
-        ```
-        brew install hidapi
-        ```
-        
-        ## FreeBSD
-        Binary distributions are available.
-        
-        ```
-        pkg install -g 'py3*-hid'
-        ```
-        
-        # Sample usage code
-        
-        The details about a HID device can be printed with following code:
-        
-        ```python
-        import hid
-        
-        vid = 0x046d	# Change it for your device
-        pid = 0xc534	# Change it for your device
-        
-        with hid.Device(vid, pid) as h:
-        	print(f'Device manufacturer: {h.manufacturer}')
-        	print(f'Product: {h.product}')
-        	print(f'Serial Number: {h.serial}')
-        ```
-        
-        
-Platform: UNKNOWN
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Description-Content-Type: text/markdown

hid-1.0.5/hid.egg-info/PKG-INFO

@@ -1,108 +0,0 @@
-Metadata-Version: 2.1
-Name: hid
-Version: 1.0.5
-Summary: ctypes bindings for hidapi
-Home-page: https://github.com/apmorton/pyhidapi
-Author: Austin Morton
-Author-email: amorton@juvsoft.com
-License: MIT
-Description: # Installing pyhidapi
-        pyhidapi is available on [PyPI](https://pypi.org/project/hid/) and can be installed using pip.
-        ```
-        pip install hid
-        ```
-        
-        pyhidapi is dependant upon the [hidapi library](https://github.com/libusb/hidapi), which must be installed separately.
-        
-        # Installing hidapi
-        
-        ## Linux
-        Installation procedures vary depending on your distribution.
-        
-        ### Arch Linux
-        Binary distributions are available in the community repository.
-        
-        1. Enable the community repository in `/etc/pacman.conf`
-        ```
-        [community]
-        Include = /etc/pacman.d/mirrorlist
-        ```
-        2. Install hidapi
-        ```
-        pacman -Sy hidapi
-        ```
-        
-        ### CentOS/RHEL
-        Binary distributions are available through [EPEL](https://fedoraproject.org/wiki/EPEL).
-        ```
-        yum install hidapi
-        ```
-        
-        ### Fedora
-        Binary distributions are available.
-        ```
-        dnf install hidapi
-        ```
-        
-        ### Ubuntu/Debian
-        Binary distributions are available.
-        
-        ```
-        apt install libhidapi-hidraw0
-        ```
-        or
-        ```
-        apt install libhidapi-libusb0
-        ```
-        
-        ### Others
-        Binary distributions may be available in your package repositories. If not, you can build from source as described [in the libusb/hidapi README](https://github.com/libusb/hidapi#build-instructions).
-        
-        ## Windows
-        Installation procedure for Windows is described [in the libusb/hidapi README](https://github.com/libusb/hidapi#building-on-windows)
-        
-        Binary distributions are provided by [libusb/hidapi](https://github.com/libusb/hidapi/releases)
-        
-        ## OSX
-        There are currently no official binary distributions for Mac, so you must build hidapi yourself.
-        
-        Installation instructions are described [in the libusb/hidapi README](https://github.com/libusb/hidapi#mac)
-        
-        You can also use brew:
-        ```
-        brew install hidapi
-        ```
-        
-        ## FreeBSD
-        Binary distributions are available.
-        
-        ```
-        pkg install -g 'py3*-hid'
-        ```
-        
-        # Sample usage code
-        
-        The details about a HID device can be printed with following code:
-        
-        ```python
-        import hid
-        
-        vid = 0x046d	# Change it for your device
-        pid = 0xc534	# Change it for your device
-        
-        with hid.Device(vid, pid) as h:
-        	print(f'Device manufacturer: {h.manufacturer}')
-        	print(f'Product: {h.product}')
-        	print(f'Serial Number: {h.serial}')
-        ```
-        
-        
-Platform: UNKNOWN
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 2.6
-Classifier: Programming Language :: Python :: 2.7
-Classifier: Programming Language :: Python :: 3
-Description-Content-Type: text/markdown