pymobiledevice3 4.27.3__tar.gz → 4.27.5__tar.gz

{pymobiledevice3-4.27.3 → pymobiledevice3-4.27.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymobiledevice3
-Version: 4.27.3
+Version: 4.27.5
 Summary: Pure python3 implementation for working with iDevices (iPhone, etc...)
 Author-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>
 Maintainer-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>

{pymobiledevice3-4.27.3 → pymobiledevice3-4.27.5}/pymobiledevice3/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '4.27.3'
-__version_tuple__ = version_tuple = (4, 27, 3)
+__version__ = version = '4.27.5'
+__version_tuple__ = version_tuple = (4, 27, 5)
 
-__commit_id__ = commit_id = 'ge48177203'
+__commit_id__ = commit_id = 'g6e0511aa8'

{pymobiledevice3-4.27.3 → pymobiledevice3-4.27.5}/pymobiledevice3/services/afc.py

@@ -277,7 +277,7 @@ class AfcService(LockdownService):
                 except Exception as afc_exception:
                     if not ignore_errors:
                         raise
-                    self.logger.warning("(Ignoring) Error:", afc_exception, "occured during the copy of", src_filename)
+                    self.logger.warning(f"(Ignoring) Error: {afc_exception} occurred during the copy of {src_filename}")
 
     @path_to_str()
     def exists(self, filename):
@@ -620,7 +620,7 @@ class AfcService(LockdownService):
                 pass
         return status, data
 
-    def _do_operation(self, opcode: afc_opcode_t, data: bytes = b''):
+    def _do_operation(self, opcode, data: bytes = b''):
         self._dispatch_packet(opcode, data)
         status, data = self._receive_data()
 
@@ -887,6 +887,7 @@ class AfcShell:
         progress_bar : --progress_bar
             Show progress bar
         """
+
         def log(src, dst):
             print(f'{src} --> {dst}')
 

{pymobiledevice3-4.27.3 → pymobiledevice3-4.27.5}/pymobiledevice3/services/crash_reports.py

@@ -99,7 +99,7 @@ class CrashReportsManager:
                     self.afc.rm_single(src, force=True)
 
         match = None if match is None else re.compile(match)
-        self.afc.pull(entry, out, match, callback=log, progress_bar=progress_bar)
+        self.afc.pull(entry, out, match, callback=log, progress_bar=progress_bar, ignore_errors=True)
 
     def flush(self) -> None:
         """ Trigger com.apple.crashreportmover to flush all products into CrashReports directory """

{pymobiledevice3-4.27.3 → pymobiledevice3-4.27.5}/pymobiledevice3/services/webinspector.py

@@ -4,7 +4,7 @@ import logging
 import uuid
 from dataclasses import dataclass, fields
 from enum import Enum
-from typing import Optional, Union
+from typing import Any, Coroutine, Optional, Union
 
 import nest_asyncio
 
@@ -157,7 +157,7 @@ class WebinspectorService:
         self.service = self.await_(self.lockdown.aio_start_lockdown_service(self.service_name))
         self.await_(self._report_identifier())
         try:
-            self._handle_recv(self.await_(asyncio.wait_for(self._recv_message(), timeout)))
+            self._handle_recv(self._await_with_timeout(self._recv_message(), timeout))
         except asyncio.TimeoutError as e:
             raise WebInspectorNotEnabledError from e
         self._recv_task = self.loop.create_task(self._receiving_task())
@@ -225,7 +225,7 @@ class WebinspectorService:
         self.await_(self._request_application_launch(bundle))
         self.get_open_pages()
         try:
-            return self.await_(asyncio.wait_for(self._wait_for_application(bundle), timeout=timeout))
+            return self._await_with_timeout(self._wait_for_application(bundle), timeout)
         except TimeoutError:
             raise LaunchingApplicationError()
 
@@ -244,8 +244,22 @@ class WebinspectorService:
     def flush_input(self, duration: Union[float, int] = 0):
         return self.await_(asyncio.sleep(duration))
 
-    def await_(self, awaitable):
-        return self.loop.run_until_complete(asyncio.ensure_future(awaitable, loop=self.loop))
+    def await_(self, awaitable: Coroutine) -> Any:
+        return self.loop.run_until_complete(awaitable)
+
+    def _await_with_timeout(self, coro: Coroutine, timeout: float = None) -> Any:
+        # Create a task explicitly so we're definitely inside a Task
+        task = self.loop.create_task(coro)
+        done, pending = self.loop.run_until_complete(asyncio.wait({task}, timeout=timeout))
+        if not done:
+            task.cancel()
+            # Give the task a chance to cancel cleanly
+            try:
+                self.loop.run_until_complete(task)
+            except asyncio.CancelledError:
+                pass
+            raise WebInspectorNotEnabledError()
+        return task.result()
 
     def _handle_recv(self, plist):
         self.receive_handlers[plist['__selector']](plist['__argument'])

{pymobiledevice3-4.27.3 → pymobiledevice3-4.27.5}/pymobiledevice3/tcp_forwarder.py

@@ -51,37 +51,38 @@ class TcpForwarderBase:
         if self.listening_event:
             self.listening_event.set()
 
-        while self.inputs:
-            # will only perform the socket select on the inputs. the outputs will handled
-            # as synchronous blocking
-            readable, writable, exceptional = select.select(self.inputs, [], self.inputs, self.TIMEOUT)
-            if self.stopped.is_set():
-                self.logger.debug("Closing since stopped is set")
-                break
-
-            closed_sockets = set()
-            for current_sock in readable:
-                self.logger.debug("Processing %r", current_sock)
-                if current_sock is self.server_socket:
-                    self._handle_server_connection()
-                else:
-                    if current_sock not in closed_sockets:
-                        try:
-                            self._handle_data(current_sock, closed_sockets)
-                        except ConnectionResetError:
-                            self.logger.exception("Error when handling data")
-                            self._handle_close_or_error(current_sock)
+        try:
+            while self.inputs:
+                # will only perform the socket select on the inputs. the outputs will handled
+                # as synchronous blocking
+                readable, writable, exceptional = select.select(self.inputs, [], self.inputs, self.TIMEOUT)
+                if self.stopped.is_set():
+                    self.logger.debug("Closing since stopped is set")
+                    break
+
+                closed_sockets = set()
+                for current_sock in readable:
+                    self.logger.debug("Processing %r", current_sock)
+                    if current_sock is self.server_socket:
+                        self._handle_server_connection()
                     else:
-                        self.logger.debug("Is closed")
-
-            for current_sock in exceptional:
-                self.logger.error("Sock failed: %r", current_sock)
-                self._handle_close_or_error(current_sock)
-
-        self.logger.info("Closing everything")
-        # on stop, close all currently opened sockets
-        for current_sock in self.inputs:
-            current_sock.close()
+                        if current_sock not in closed_sockets:
+                            try:
+                                self._handle_data(current_sock, closed_sockets)
+                            except ConnectionResetError:
+                                self.logger.exception("Error when handling data")
+                                self._handle_close_or_error(current_sock)
+                        else:
+                            self.logger.debug("Is closed")
+
+                for current_sock in exceptional:
+                    self.logger.error("Sock failed: %r", current_sock)
+                    self._handle_close_or_error(current_sock)
+        finally:
+            self.logger.info("Closing everything")
+            # on stop, close all currently opened sockets
+            for current_sock in self.inputs:
+                current_sock.close()
 
     def _handle_close_or_error(self, from_sock):
         """ if an error occurred its time to close the two sockets """

{pymobiledevice3-4.27.3 → pymobiledevice3-4.27.5}/pymobiledevice3/tunneld/server.py

@@ -5,11 +5,17 @@ import logging
 import os
 import signal
 import traceback
+import warnings
 from contextlib import asynccontextmanager, suppress
 from typing import Optional, Union
 
 import construct
-import fastapi
+
+with warnings.catch_warnings():
+    # Ignore: "Core Pydantic V1 functionality isn't compatible with Python 3.14 or greater."
+    warnings.simplefilter('ignore', category=UserWarning)
+    import fastapi
+
 import uvicorn
 from construct import StreamError
 from fastapi import FastAPI
@@ -18,7 +24,7 @@ from packaging.version import Version
 from pymobiledevice3 import usbmux
 from pymobiledevice3.bonjour import REMOTED_SERVICE_NAMES, browse
 from pymobiledevice3.exceptions import ConnectionFailedError, ConnectionFailedToUsbmuxdError, DeviceNotFoundError, \
-    GetProhibitedError, InvalidServiceError, LockdownError, MuxException, PairingError
+    GetProhibitedError, IncorrectModeError, InvalidServiceError, LockdownError, MuxException, PairingError
 from pymobiledevice3.lockdown import create_using_usbmux, get_mobdev2_lockdowns
 from pymobiledevice3.osu.os_utils import get_os_utils
 from pymobiledevice3.remote.common import TunnelProtocol
@@ -143,7 +149,7 @@ class TunneldCore:
                         try:
                             service = CoreDeviceTunnelProxy(create_using_usbmux(mux_device.serial))
                         except (MuxException, InvalidServiceError, GetProhibitedError, construct.core.StreamError,
-                                ConnectionAbortedError, DeviceNotFoundError, LockdownError):
+                                ConnectionAbortedError, DeviceNotFoundError, LockdownError, IncorrectModeError):
                             continue
                         self.tunnel_tasks[task_identifier] = TunnelTask(
                             udid=mux_device.serial,

{pymobiledevice3-4.27.3 → pymobiledevice3-4.27.5}/pymobiledevice3.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymobiledevice3
-Version: 4.27.3
+Version: 4.27.5
 Summary: Pure python3 implementation for working with iDevices (iPhone, etc...)
 Author-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>
 Maintainer-email: doronz88 <doron88@gmail.com>, matan <matan1008@gmail.com>