libusb1 3.2.0__tar.gz → 3.3.0__tar.gz

{libusb1-3.2.0/libusb1.egg-info → libusb1-3.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libusb1
-Version: 3.2.0
+Version: 3.3.0
 Summary: Pure-python wrapper for libusb-1.0
 Home-page: https://github.com/vpelletier/python-libusb1
 Author: Vincent Pelletier
@@ -596,9 +596,21 @@ Expose more modern libusb1 API:
 - libusb_set_log_cb
 - libusb_setlocale + libusb_strerror
 - libusb_wrap_sys_device
+- transfer flags LIBUSB_TRANSFER_SHORT_NOT_OK and LIBUSB_TRANSFER_ADD_ZERO_PACKET
 
 As a result, python-libusb1 should now be usable on Android.
 
+Fix tests on python 3.13 .
+
+3.3.0
+-----
+
+Improve deprecation warning, by showing the correct caller location.
+
+Fix finalizer registration errors on pypi by using a thread-safe sequential number generator instead of relying on object id unicity and timely finalizer triggering.
+
+Check in-dll version when creating Windows wheels. Should hopefully version mixups like what happened in 3.1.0 .
+
 .. _CPython: http://www.python.org/
 
 .. _pypy: http://pypy.org/

{libusb1-3.2.0 → libusb1-3.3.0}/README.rst

@@ -574,9 +574,21 @@ Expose more modern libusb1 API:
 - libusb_set_log_cb
 - libusb_setlocale + libusb_strerror
 - libusb_wrap_sys_device
+- transfer flags LIBUSB_TRANSFER_SHORT_NOT_OK and LIBUSB_TRANSFER_ADD_ZERO_PACKET
 
 As a result, python-libusb1 should now be usable on Android.
 
+Fix tests on python 3.13 .
+
+3.3.0
+-----
+
+Improve deprecation warning, by showing the correct caller location.
+
+Fix finalizer registration errors on pypi by using a thread-safe sequential number generator instead of relying on object id unicity and timely finalizer triggering.
+
+Check in-dll version when creating Windows wheels. Should hopefully version mixups like what happened in 3.1.0 .
+
 .. _CPython: http://www.python.org/
 
 .. _pypy: http://pypy.org/

{libusb1-3.2.0 → libusb1-3.3.0/libusb1.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: libusb1
-Version: 3.2.0
+Version: 3.3.0
 Summary: Pure-python wrapper for libusb-1.0
 Home-page: https://github.com/vpelletier/python-libusb1
 Author: Vincent Pelletier
@@ -596,9 +596,21 @@ Expose more modern libusb1 API:
 - libusb_set_log_cb
 - libusb_setlocale + libusb_strerror
 - libusb_wrap_sys_device
+- transfer flags LIBUSB_TRANSFER_SHORT_NOT_OK and LIBUSB_TRANSFER_ADD_ZERO_PACKET
 
 As a result, python-libusb1 should now be usable on Android.
 
+Fix tests on python 3.13 .
+
+3.3.0
+-----
+
+Improve deprecation warning, by showing the correct caller location.
+
+Fix finalizer registration errors on pypi by using a thread-safe sequential number generator instead of relying on object id unicity and timely finalizer triggering.
+
+Check in-dll version when creating Windows wheels. Should hopefully version mixups like what happened in 3.1.0 .
+
 .. _CPython: http://www.python.org/
 
 .. _pypy: http://pypy.org/

{libusb1-3.2.0 → libusb1-3.3.0}/setup.py

@@ -17,6 +17,7 @@
 from setuptools import setup
 from setuptools import Command
 from codecs import open
+import csv
 import hashlib
 from html.parser import HTMLParser
 import os
@@ -35,6 +36,7 @@ if os.getenv('I_KNOW_HOW_TO_RELEASE_PYTHON_LIBUSB1') != '1' and any(
 CURRENT_WINDOWS_7Z_SHA256 = (
     '19835e290f46fab6bd8ce4be6ab7dc5209f1c04bad177065df485e51dc4118c8'
 )
+CURRENT_DLL_VERSION = '1.0.27.11882'
 
 cmdclass = versioneer.get_cmdclass()
 class upload(Command):
@@ -141,6 +143,32 @@ class update_libusb(Command):
                 stdout=subprocess.DEVNULL,
                 close_fds=True,
             )
+            out_dll = os.path.join(out_dir, 'libusb-1.0.dll')
+            assert os.path.exists(out_dll)
+            peres_stdout = subprocess.run(
+                [
+                    'peres',
+                    '--format', 'csv',
+                    '-v',
+                    out_dll,
+                ],
+                check=True,
+                stdout=subprocess.PIPE,
+                encoding='ascii',
+                close_fds=True,
+            ).stdout
+            try:
+                for name, value in csv.reader(peres_stdout.splitlines()):
+                    if name == 'Product Version':
+                        if value != CURRENT_DLL_VERSION:
+                            raise ValueError(
+                                f'{out_dll} unexpected DLL version: {value}',
+                            )
+                        break
+                else:
+                    raise ValueError('No "Product Version" in peres output')
+            except Exception as exc:
+                raise ValueError(f'Peres stdout: {peres_stdout!r}') from exc
 cmdclass['update_libusb'] = update_libusb
 
 setup(

{libusb1-3.2.0 → libusb1-3.3.0}/setup.sh

@@ -29,5 +29,5 @@ twine check --strict "${release_prefix}"*.{whl,tar.gz}
 echo "Done. Next, check their content, sign each:"
 echo "  for release in ${release_prefix}-*.whl ${release_prefix}.tar.gz; do gpg --armor --detach-sign \"\$release\"; done"
 echo "upload them to pypi:"
-echo "  twine upload ${release_prefix}-*.whl{,.asc} ${release_prefix}.tar.gz{,.asc}"
+echo "  twine upload ${release_prefix}-*.whl ${release_prefix}.tar.gz"
 echo "and create a new release on github"

{libusb1-3.2.0 → libusb1-3.3.0}/usb1/__init__.py

@@ -53,6 +53,7 @@ from ctypes import byref, c_int, sizeof, POINTER, \
 from ctypes.util import find_library
 import functools
 import inspect
+import itertools
 import sys
 import threading
 import warnings
@@ -172,6 +173,50 @@ def create_binary_buffer(init_or_size):
         init_or_size = bytearray(init_or_size)
     return create_initialised_buffer(init_or_size)
 
+class _LibUSB1Finalizer: # pylint: disable=too-few-public-methods
+    """
+    Create, and keep track of, finalizer objects.
+    Allows outstanding finalizers to be triggered, typically so C resources
+    owned by the objects associated with those finalizers are freed before
+    another one they depend (and owned by the instance of this class) on may
+    be freed.
+    """
+    def __init__(self):
+        self._finalizer_dict = {}
+        self.__finalizer_id_generator = itertools.count()
+        self.__finalizer_id_generator_lock = threading.Lock()
+
+    @staticmethod
+    def __finalize(handle, pop, func, kw):
+        try:
+            func(**kw)
+        finally:
+            pop(handle)
+
+    def _getFinalizer(self, obj, func, **kw):
+        """
+        Creates and adds to _finalizer_dict a finalizer which will trigger
+        after obj becomes unreachable and before it is garbage-collected.
+        When it triggers, func(**kw) is called and the finalizer is removed
+        from _finalizer_dict.
+
+        Returns the created finalizer object.
+        """
+        with self.__finalizer_id_generator_lock:
+            handle = next(self.__finalizer_id_generator)
+        finalizer_dict = self._finalizer_dict
+        finalizer_dict[handle] = finalizer = weakref.finalize(
+            obj,
+            functools.partial(
+                self.__finalize, # Note: static method
+                handle=handle,
+                pop=finalizer_dict.pop,
+                func=func,
+                kw=kw,
+            ),
+        )
+        return finalizer
+
 def create_initialised_buffer(init):
     # raises if init is an integer - this is intentional
     string_type = c_char * len(init)
@@ -219,8 +264,9 @@ class USBTransfer:
         iso_packets,
         before_submit,
         after_completion,
-        registerFinalizer,
-        unregisterFinalizer,
+        getFinalizer,
+        short_is_error,
+        add_zero_packet,
     ):
         """
         You should not instanciate this class directly.
@@ -241,20 +287,16 @@ class USBTransfer:
             raise USBErrorNoMem
             # pylint: enable=undefined-variable
         self.__transfer = transfer
-        finalizer_handle = id(self)
-        self.__close = weakref.finalize(
+        self.setShortIsError(short_is_error)
+        self.setAddZeroPacket(add_zero_packet)
+        self.__close = getFinalizer(
             self,
             self.__close, # Note: class method
             transfer=transfer,
             context=context,
-            unregisterFinalizer=functools.partial(
-                unregisterFinalizer,
-                handle=finalizer_handle,
-            ),
             libusb_free_transfer=libusb1.libusb_free_transfer,
             libusb_cancel_transfer=libusb1.libusb_cancel_transfer,
         )
-        registerFinalizer(finalizer_handle, self.__close)
 
     def close(self):
         """
@@ -287,7 +329,6 @@ class USBTransfer:
         cls,
         transfer,
         context,
-        unregisterFinalizer,
         libusb_free_transfer,
         libusb_cancel_transfer,
 
@@ -309,7 +350,6 @@ class USBTransfer:
                 except USBErrorInterrupted_:
                     pass
         libusb_free_transfer(transfer)
-        unregisterFinalizer()
 
     def doom(self):
         """
@@ -720,6 +760,44 @@ class USBTransfer:
         transfer.buffer = cast(buff, c_void_p)
         transfer.length = sizeof(buff)
 
+    def isShortAnError(self):
+        """
+        Returns whether the LIBUSB_TRANSFER_SHORT_NOT_OK flag is set on this
+        transfer.
+        """
+        return bool(self.__transfer.contents.flags & libusb1.LIBUSB_TRANSFER_SHORT_NOT_OK)
+
+    def setShortIsError(self, state):
+        """
+        state (bool)
+            When true, LIBUSB_TRANSFER_SHORT_NOT_OK flag is set on this
+            transfer.
+            Otherwise, it is cleared.
+        """
+        if state:
+            self.__transfer.contents.flags |= libusb1.LIBUSB_TRANSFER_SHORT_NOT_OK
+        else:
+            self.__transfer.contents.flags &= ~libusb1.LIBUSB_TRANSFER_SHORT_NOT_OK
+
+    def isZeroPacketAdded(self):
+        """
+        Returns whether the LIBUSB_TRANSFER_ADD_ZERO_PACKET flag is set on this
+        transfer.
+        """
+        return bool(self.__transfer.contents.flags & libusb1.LIBUSB_TRANSFER_ADD_ZERO_PACKET)
+
+    def setAddZeroPacket(self, state):
+        """
+        state (bool)
+            When true, LIBUSB_TRANSFER_ADD_ZERO_PACKET flag is set on this
+            transfer.
+            Otherwise, it is cleared.
+        """
+        if state:
+            self.__transfer.contents.flags |= libusb1.LIBUSB_TRANSFER_ADD_ZERO_PACKET
+        else:
+            self.__transfer.contents.flags &= ~libusb1.LIBUSB_TRANSFER_ADD_ZERO_PACKET
+
     def isSubmitted(self):
         """
         Tells if this transfer is submitted and still pending.
@@ -986,7 +1064,7 @@ class _ReleaseInterface:
     def __exit__(self, exc_type, exc_val, exc_tb):
         self._handle.releaseInterface(self._interface)
 
-class USBDeviceHandle:
+class USBDeviceHandle(_LibUSB1Finalizer):
     """
     Represents an opened USB device.
     """
@@ -997,8 +1075,7 @@ class USBDeviceHandle:
         context,
         handle,
         device,
-        registerFinalizer,
-        unregisterFinalizer,
+        getFinalizer,
         can_close_device,
     ):
         """
@@ -1006,8 +1083,8 @@ class USBDeviceHandle:
         Call "open" method on an USBDevice instance to get an USBDeviceHandle
         instance.
         """
+        super().__init__()
         self.__context = context
-        self.__finalizer_dict = {}
         # Strong references to inflight transfers so they do not get freed
         # even if user drops all strong references to them. If this instance
         # is garbage-collected, we close all transfers, so it's fine.
@@ -1020,8 +1097,7 @@ class USBDeviceHandle:
         self.__inflight_remove = inflight.remove
         self.__handle = handle
         self.__device = device
-        finalizer_handle = id(self)
-        self.close = weakref.finalize(
+        self.close = getFinalizer(
             self,
             self.close, # Note: static method
             context=context,
@@ -1032,23 +1108,9 @@ class USBDeviceHandle:
                 None
             ),
             inflight=inflight,
-            finalizer_dict=self.__finalizer_dict,
-            unregisterFinalizer=functools.partial(
-                unregisterFinalizer,
-                handle=finalizer_handle,
-            ),
+            finalizer_dict=self._finalizer_dict,
             libusb_close=libusb1.libusb_close,
         )
-        registerFinalizer(finalizer_handle, self.close)
-
-    def __registerFinalizer(self, handle, finalizer):
-        if handle in self.__finalizer_dict:
-            finalizer.detach()
-            raise ValueError('Finalizer handle {handle} already exists')
-        self.__finalizer_dict[handle] = finalizer
-
-    def __unregisterFinalizer(self, handle):
-        self.__finalizer_dict.pop(handle)
 
     @staticmethod
     def close( # pylint: disable=method-hidden
@@ -1057,7 +1119,6 @@ class USBDeviceHandle:
         device,
         inflight,
         finalizer_dict,
-        unregisterFinalizer,
         libusb_close,
 
         set_=set,
@@ -1098,7 +1159,6 @@ class USBDeviceHandle:
         if device is not None:
             device.close()
         libusb_close(handle)
-        unregisterFinalizer()
 
     def getDevice(self):
         """
@@ -1508,11 +1568,14 @@ class USBDeviceHandle:
             raise
         return data_buffer[:transferred]
 
-    def getTransfer(self, iso_packets=0):
+    def getTransfer(self, iso_packets=0, short_is_error=False, add_zero_packet=False):
         """
         Get an USBTransfer instance for asynchronous use.
         iso_packets: the number of isochronous transfer descriptors to
           allocate.
+        short_is_error: When true, short frames are reported as errors.
+        add_zero_packet: When true, transfers of a multiple of the endpoint
+          size are followed by a zero-length packet.
         """
         return USBTransfer(
             context=self.__context,
@@ -1520,8 +1583,9 @@ class USBDeviceHandle:
             iso_packets=iso_packets,
             before_submit=self.__inflight_add,
             after_completion=self.__inflight_remove,
-            registerFinalizer=self.__registerFinalizer,
-            unregisterFinalizer=self.__unregisterFinalizer,
+            getFinalizer=self._getFinalizer,
+            short_is_error=short_is_error,
+            add_zero_packet=add_zero_packet,
         )
 
 class USBConfiguration:
@@ -1734,7 +1798,7 @@ class USBEndpoint:
     def getExtra(self):
         return libusb1.get_extra(self.__endpoint)
 
-class USBDevice:
+class USBDevice(_LibUSB1Finalizer):
     """
     Represents a USB device.
 
@@ -1750,8 +1814,7 @@ class USBDevice:
         self,
         context,
         device_p,
-        registerFinalizer,
-        unregisterFinalizer,
+        getFinalizer,
         can_load_configuration,
         can_change_refcount,
         handle_p,
@@ -1760,13 +1823,12 @@ class USBDevice:
         You should not instanciate this class directly.
         Call USBContext methods to receive instances of this class.
         """
+        super().__init__()
         self.__context = context
-        self.__finalizer_dict = finalizer_dict = {}
         self.__configuration_descriptor_list = descriptor_list = []
         if can_change_refcount:
             libusb1.libusb_ref_device(device_p)
-        finalizer_handle = id(self)
-        self.close = weakref.finalize(
+        self.close = getFinalizer(
             self,
             self.close, # Note: static method
             device_p=(
@@ -1774,16 +1836,11 @@ class USBDevice:
                 if can_change_refcount else
                 None
             ),
-            finalizer_dict=finalizer_dict,
-            unregisterFinalizer=functools.partial(
-                unregisterFinalizer,
-                handle=finalizer_handle,
-            ),
+            finalizer_dict=self._finalizer_dict,
             descriptor_list=descriptor_list,
             libusb_unref_device=libusb1.libusb_unref_device,
             libusb_free_config_descriptor=libusb1.libusb_free_config_descriptor,
         )
-        registerFinalizer(finalizer_handle, self.close)
         self.device_p = device_p
         # Fetch device descriptor
         # Note: if this is made lazy, access errors will happen later, breaking
@@ -1817,25 +1874,14 @@ class USBDevice:
                 context=context,
                 handle=handle_p,
                 device=self,
-                registerFinalizer=self.__registerFinalizer,
-                unregisterFinalizer=self.__unregisterFinalizer,
+                getFinalizer=self._getFinalizer,
                 can_close_device=True,
             )
 
-    def __registerFinalizer(self, handle, finalizer):
-        if handle in self.__finalizer_dict:
-            finalizer.detach()
-            raise ValueError('Finalizer handle {handle} already exists')
-        self.__finalizer_dict[handle] = finalizer
-
-    def __unregisterFinalizer(self, handle):
-        self.__finalizer_dict.pop(handle)
-
     @staticmethod
     def close( # pylint: disable=method-hidden
         device_p,
         finalizer_dict,
-        unregisterFinalizer,
         descriptor_list,
         libusb_unref_device,
         libusb_free_config_descriptor,
@@ -1852,7 +1898,6 @@ class USBDevice:
             libusb_free_config_descriptor(
                 byref_(descriptor_list.pop()),
             )
-        unregisterFinalizer()
 
     def __str__(self):
         return (
@@ -2093,8 +2138,7 @@ class USBDevice:
             context=self.__context,
             handle=handle,
             device=self,
-            registerFinalizer=self.__registerFinalizer,
-            unregisterFinalizer=self.__unregisterFinalizer,
+            getFinalizer=self._getFinalizer,
             can_close_device=False,
         )
 
@@ -2103,7 +2147,7 @@ _zero_tv_p = byref(_zero_tv)
 _null_pointer = c_void_p()
 _NULL_LOG_CALLBACK = libusb1.libusb_log_cb_p(0)
 
-class USBContext:
+class USBContext(_LibUSB1Finalizer):
     """
     libusb1 USB context.
 
@@ -2131,6 +2175,7 @@ class USBContext:
                         'Use "with USBContext() as context:" for safer cleanup'
                         ' on interpreter shutdown. See also USBContext.open().',
                         DeprecationWarning,
+                        stacklevel=4
                     )
                     self.open()
                 self.__context_refcount += 1
@@ -2193,6 +2238,7 @@ class USBContext:
         __enter__, open, or the first context-dependent call, whichever happens
         first) to fail if libusb is older than v1.0.27 .
         """
+        super().__init__()
         # Used to prevent an exit to cause a segfault if a concurrent thread
         # is still in libusb.
         self.__context_refcount = 0
@@ -2200,7 +2246,6 @@ class USBContext:
         self.__context_p = libusb1.libusb_context_p()
         assert not self.__context_p
         self.__hotplug_callback_dict = {}
-        self.__finalizer_dict = {}
         self.__log_level = log_level
         self.__use_usbdk = use_usbdk
         self.__with_device_discovery = with_device_discovery
@@ -2213,15 +2258,6 @@ class USBContext:
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
 
-    def __registerFinalizer(self, handle, finalizer):
-        if handle in self.__finalizer_dict:
-            finalizer.detach()
-            raise ValueError('Finalizer handle {handle} already exists')
-        self.__finalizer_dict[handle] = finalizer
-
-    def __unregisterFinalizer(self, handle):
-        self.__finalizer_dict.pop(handle)
-
     def open(self):
         """
         Finish context initialisation, as is normally done in __enter__ .
@@ -2274,7 +2310,7 @@ class USBContext:
             self.___close, # Note: static method
             context_p=self.__context_p,
             hotplug_callback_dict=self.__hotplug_callback_dict,
-            finalizer_dict=self.__finalizer_dict,
+            finalizer_dict=self._finalizer_dict,
             libusb_exit=libusb1.libusb_exit,
             libusb_hotplug_deregister_callback=libusb1.libusb_hotplug_deregister_callback,
         )
@@ -2353,8 +2389,7 @@ class USBContext:
                     device = USBDevice(
                         context=self,
                         device_p=device_p,
-                        registerFinalizer=self.__registerFinalizer,
-                        unregisterFinalizer=self.__unregisterFinalizer,
+                        getFinalizer=self._getFinalizer,
                         can_load_configuration=True,
                         can_change_refcount=True,
                         handle_p=None,
@@ -2454,8 +2489,7 @@ class USBContext:
         return USBDevice(
             context=self,
             device_p=libusb1.libusb_get_device(handle_p),
-            registerFinalizer=self.__registerFinalizer,
-            unregisterFinalizer=self.__unregisterFinalizer,
+            getFinalizer=self._getFinalizer,
             can_load_configuration=True, # XXX: give the caller control ?
             can_change_refcount=False,
             handle_p=handle_p,
@@ -2564,28 +2598,21 @@ class USBContext:
             user_data,
         )
         if not self.__has_pollfd_finalizer:
+            # Note: the above condition is just to avoid creating finalizers on
+            # every call. If more than one is created (because of a
+            # race-condition) it is not a big deal, as __finalizePollFDNotifiers
+            # will do the right thing even if called multiple times in a row.
             self.__has_pollfd_finalizer = True
-            try:
-                finalizer_handle = id(self)
-                finalizer_dict = self.__finalizer_dict
-                finalizer = weakref.finalize(
-                    self,
-                    self.__finalizePollFDNotifiers, # Note: staticmethod
-                    context_p=self.__context_p,
-                    unregisterFinalizer=functools.partial(
-                        finalizer_dict.pop,
-                        finalizer_handle,
-                    ),
-                    libusb_set_pollfd_notifiers=libusb1.libusb_set_pollfd_notifiers,
-                )
-                self.__registerFinalizer(finalizer_handle, finalizer)
-            except ValueError: # Already registered
-                pass
+            self.getFinalizer(
+                self,
+                self.__finalizePollFDNotifiers, # Note: staticmethod
+                context_p=self.__context_p,
+                libusb_set_pollfd_notifiers=libusb1.libusb_set_pollfd_notifiers,
+            )
 
     @staticmethod
     def __finalizePollFDNotifiers(
         context_p,
-        unregisterFinalizer,
         libusb_set_pollfd_notifiers,
 
         null_pointer=_null_pointer,
@@ -2598,7 +2625,6 @@ class USBContext:
             removed_cb_p,
             null_pointer,
         )
-        unregisterFinalizer()
 
     @_validContext
     def getNextTimeout(self):
@@ -2756,8 +2782,7 @@ class USBContext:
             device = USBDevice(
                 context=self,
                 device_p=device_p,
-                registerFinalizer=self.__registerFinalizer,
-                unregisterFinalizer=self.__unregisterFinalizer,
+                getFinalizer=self._getFinalizer,
                 # pylint: disable=undefined-variable
                 can_load_configuration=event != HOTPLUG_EVENT_DEVICE_LEFT,
                 # pylint: enable=undefined-variable

{libusb1-3.2.0 → libusb1-3.3.0}/usb1/__pyinstaller/__init__.py

@@ -1,3 +1,6 @@
+# pylint: disable=missing-module-docstring
+# pylint: disable=missing-function-docstring
+# pylint: disable=invalid-name
 import os
 
 def get_hook_dirs():

{libusb1-3.2.0 → libusb1-3.3.0}/usb1/__pyinstaller/hook-usb1.py

@@ -1,5 +1,9 @@
+# pylint: disable=missing-module-docstring
+# pylint: disable=invalid-name
 import logging
+# pylint: disable=import-error
 from PyInstaller.utils.hooks import collect_dynamic_libs
+# pylint: enable=import-error
 
 logger = logging.getLogger(__name__)
 logger.info("--- libusb1 pyinstaller hook ---")

{libusb1-3.2.0 → libusb1-3.3.0}/usb1/__pyinstaller/test_libusb1_packaging.py

@@ -10,8 +10,11 @@ Instructions to run these tests:
   > python -m PyInstaller.utils.run_tests --include_only usb1
 
 """
+# pylint: disable=missing-function-docstring
 import subprocess
+# pylint: disable=import-error
 from PyInstaller import __main__ as pyi_main
+# pylint: enable=import-error
 
 
 def test_pyi_hooksample(tmp_path):
@@ -31,4 +34,4 @@ def test_pyi_hooksample(tmp_path):
         str(app),
     ]
     pyi_main.run(args)
-    subprocess.run([str(distpath / app_name / app_name)], check=True)
+    subprocess.run([str(distpath / app_name / app_name)], check=True)

{libusb1-3.2.0 → libusb1-3.3.0}/usb1/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2024-12-28T12:45:41+0000",
+ "date": "2025-03-04T04:49:54+0000",
  "dirty": false,
  "error": null,
- "full-revisionid": "5a21cb367cc07258a4a4feda996dbfb20da7012c",
- "version": "3.2.0"
+ "full-revisionid": "2dd834dad913a89c68309ac1afa0efc0e55b606f",
+ "version": "3.3.0"
 }
 '''  # END VERSION_JSON
 

{libusb1-3.2.0 → libusb1-3.3.0}/usb1/testUSB1.py

@@ -21,6 +21,7 @@ import functools
 import gc
 import itertools
 import unittest
+import warnings
 import weakref
 import usb1
 from . import libusb1
@@ -35,10 +36,10 @@ class USBContext(usb1.USBContext):
     def open(self):
         try:
             return super().open()
-        except usb1.USBError:
+        except usb1.USBError as exc:
             raise unittest.SkipTest(
                 'usb1.USBContext() fails - no USB bus on system ?'
-            )
+            ) from exc
 
 def checkTransferAllocCount(func):
     @functools.wraps(func)
@@ -85,7 +86,7 @@ class USBTransferTests(unittest.TestCase):
         return pointer(transfer)
 
     @staticmethod
-    def getTransfer(iso_packets=0):
+    def getTransfer(iso_packets=0, short_is_error=False, add_zero_packet=False):
         # Dummy handle
         return usb1.USBTransfer(
             context=None,
@@ -93,8 +94,11 @@ class USBTransferTests(unittest.TestCase):
             iso_packets=iso_packets,
             before_submit=lambda x: None,
             after_completion=lambda x: None,
-            registerFinalizer=lambda handle, finalizer: None,
-            unregisterFinalizer=lambda handle: None,
+            getFinalizer=(
+                lambda obj, func, **kw: weakref.finalize(obj, func, **kw)
+            ),
+            short_is_error=short_is_error,
+            add_zero_packet=add_zero_packet,
         )
 
     @staticmethod
@@ -109,7 +113,7 @@ class USBTransferTests(unittest.TestCase):
         """
         Just testing hasCapability doesn't raise...
         """
-        usb1.hasCapability(usb1.CAP_HAS_CAPABILITY)
+        usb1.hasCapability(usb1.CAP_HAS_CAPABILITY) # pylint: disable=no-member
 
     @checkTransferAllocCount
     def testSetControl(self):
@@ -117,11 +121,11 @@ class USBTransferTests(unittest.TestCase):
         Simplest test: feed some data, must not raise.
         """
         transfer = self.getTransfer()
-        request_type = usb1.TYPE_STANDARD
-        request = usb1.REQUEST_GET_STATUS
+        request_type = usb1.TYPE_STANDARD # pylint: disable=no-member
+        request = usb1.REQUEST_GET_STATUS # pylint: disable=no-member
         value = 0
         index = 0
-        def callback(transfer):
+        def callback(_):
             pass
         user_data = []
         timeout = 1000
@@ -145,10 +149,24 @@ class USBTransferTests(unittest.TestCase):
             request_type, request, value, index, buff, callback=callback)
         # No callback
         transfer.setControl(request_type, request, value, index, buff)
+        self.assertFalse(transfer.isShortAnError())
+        self.assertFalse(transfer.isZeroPacketAdded())
+        transfer.setShortIsError(True)
+        self.assertTrue(transfer.isShortAnError())
+        self.assertFalse(transfer.isZeroPacketAdded())
+        transfer.setAddZeroPacket(True)
+        self.assertTrue(transfer.isShortAnError())
+        self.assertTrue(transfer.isZeroPacketAdded())
+        transfer.setShortIsError(False)
+        self.assertFalse(transfer.isShortAnError())
+        self.assertTrue(transfer.isZeroPacketAdded())
+        transfer.setAddZeroPacket(False)
+        self.assertFalse(transfer.isShortAnError())
+        self.assertFalse(transfer.isZeroPacketAdded())
 
     def _testTransferSetter(self, transfer, setter_id):
         endpoint = 0x81
-        def callback(transfer):
+        def callback(_):
             pass
         user_data = []
         timeout = 1000
@@ -226,7 +244,7 @@ class USBTransferTests(unittest.TestCase):
     @checkTransferAllocCount
     def testSetGetCallback(self):
         transfer = self.getTransfer()
-        def callback(transfer):
+        def callback(_):
             pass
         transfer.setCallback(callback)
         got_callback = transfer.getCallback()
@@ -237,7 +255,7 @@ class USBTransferTests(unittest.TestCase):
         Test descriptor walk.
         Needs any usb device, which won't be opened.
         """
-        with USBContext() as context:
+        with USBContext() as context: # pylint: disable=too-many-nested-blocks
             device_list = context.getDeviceList(skip_on_error=True)
             found = False
             seen_extra = False
@@ -281,9 +299,7 @@ class USBTransferTests(unittest.TestCase):
         self.assertEqual(locals().get(ENUM_NAME), None)
         self.assertEqual(global_dict.get(ENUM_NAME), None)
         self.assertEqual(getattr(libusb1, ENUM_NAME, None), None)
-        # pylint: disable=unused-variable
-        TEST_ENUM = libusb1.Enum({ENUM_NAME: ENUM_VALUE})
-        # pylint: enable=unused-variable
+        _ = libusb1.Enum({ENUM_NAME: ENUM_VALUE})
         self.assertEqual(locals().get(ENUM_NAME), ENUM_VALUE)
         self.assertEqual(global_dict.get(ENUM_NAME), None)
         self.assertEqual(getattr(libusb1, ENUM_NAME, None), None)
@@ -298,9 +314,7 @@ class USBTransferTests(unittest.TestCase):
         self.assertEqual(locals().get(ENUM_NAME), None)
         self.assertEqual(global_dict.get(ENUM_NAME), None)
         self.assertEqual(getattr(libusb1, ENUM_NAME, None), None)
-        # pylint: disable=unused-variable
-        TEST_ENUM = libusb1.Enum({ENUM_NAME: ENUM_VALUE}, global_dict)
-        # pylint: enable=unused-variable
+        _ = libusb1.Enum({ENUM_NAME: ENUM_VALUE}, global_dict)
         try:
             self.assertEqual(locals().get(ENUM_NAME), None)
             self.assertEqual(global_dict.get(ENUM_NAME), ENUM_VALUE)
@@ -316,9 +330,14 @@ class USBTransferTests(unittest.TestCase):
         """
         context = USBContext() # Deprecated
         try:
+            warnings.filterwarnings('ignore', category=DeprecationWarning)
             fd_list = context.getPollFDList()
         except NotImplementedError:
-            raise unittest.SkipTest('libusb without file descriptor events')
+            raise unittest.SkipTest(
+                'libusb without file descriptor events',
+            ) from None
+        finally:
+            warnings.resetwarnings()
         self.assertNotEqual(fd_list, None)
         context.exit() # Deprecated
         self.assertEqual(context.getPollFDList(), None)
@@ -336,7 +355,7 @@ class USBTransferTests(unittest.TestCase):
         try:
             usb1.setLogCallback(callback)
             with USBContext(
-                log_level=usb1.LOG_LEVEL_DEBUG,
+                log_level=usb1.LOG_LEVEL_DEBUG, # pylint: disable=no-member
             ):
                 pass
         finally:
@@ -349,7 +368,7 @@ class USBTransferTests(unittest.TestCase):
         message_list = []
         def callback(context, level, message):
             message_list.append((context, level, message))
-        def log_silencer(context, level, message):
+        def log_silencer(_, __, ___):
             pass
         try:
             # Note: silencing global logs is needed here because we lower the
@@ -358,7 +377,7 @@ class USBTransferTests(unittest.TestCase):
             # to stderr.
             usb1.setLogCallback(log_silencer)
             with USBContext(
-                log_level=usb1.LOG_LEVEL_DEBUG,
+                log_level=usb1.LOG_LEVEL_DEBUG, # pylint: disable=no-member
                 log_callback=callback,
             ) as ctx:
                 ctx.setLogCallback(None)
@@ -369,7 +388,7 @@ class USBTransferTests(unittest.TestCase):
     def testSetLocale(self):
         if not hasattr(libusb1, 'libusb_setlocale'):
             raise unittest.SkipTest('libusb without libusb_setlocale')
-        err = usb1.USBErrorIO()
+        err = usb1.USBErrorIO() # pylint: disable=no-member
         usb1.setLocale('en')
         caption_en = err.getMessage()
         self.assertTrue(caption_en)