pymobiledevice3 4.14.6__py3-none-any.whl → 7.0.6__py3-none-any.whl

pymobiledevice3/services/web_protocol/cdp_screencast.py

@@ -1,7 +1,9 @@
 import asyncio
+import contextlib
 from base64 import b64decode, b64encode
 from datetime import datetime
 from io import BytesIO
+from typing import Optional
 
 from PIL import Image
 
@@ -27,23 +29,23 @@ class ScreenCast:
         self.device_height = 0
         self.page_scale_factor = 0
         self._run = True
-        self.recording_task = None  # type: asyncio.Task | None
+        self.recording_task: Optional[asyncio.Task] = None
 
     @property
     def scale(self) -> float:
-        """ The amount screen pixels in one devtools pixel. """
+        """The amount screen pixels in one devtools pixel."""
         real_height = self.device_height * self.page_scale_factor
         real_width = self.device_width * self.page_scale_factor
         return min(self.max_height / real_height, self.max_width / real_width, 1) * self.page_scale_factor
 
     @property
     def scaled_width(self) -> int:
-        """ Width of screenshot after scaling. """
+        """Width of screenshot after scaling."""
         return int(self.scale * self.device_width)
 
     @property
     def scaled_height(self) -> int:
-        """ Height of screenshot after scaling. """
+        """Height of screenshot after scaling."""
         return int(self.scale * self.device_height)
 
     async def start(self, message_id: int):
@@ -53,26 +55,26 @@ class ScreenCast:
         """
         device_size = await self.target.evaluate_and_result(
             message_id,
-            ('(window.innerWidth > 0 ? window.innerWidth : screen.width) + "," + '
-             '(window.innerHeight > 0 ? window.innerHeight : screen.height) + "," + '
-             'window.devicePixelRatio')
+            (
+                '(window.innerWidth > 0 ? window.innerWidth : screen.width) + "," + '
+                '(window.innerHeight > 0 ? window.innerHeight : screen.height) + "," + '
+                "window.devicePixelRatio"
+            ),
         )
-        self.device_width, self.device_height, self.page_scale_factor = list(map(int, device_size.split(',')))
+        self.device_width, self.device_height, self.page_scale_factor = list(map(int, device_size.split(",")))
         self._run = True
         self.recording_task = asyncio.create_task(self.recording_loop(message_id))
 
     async def stop(self):
-        """ Stop sending screenshots to the devtools. """
+        """Stop sending screenshots to the devtools."""
         self._run = False
         self.recording_task.cancel()
-        try:
+        with contextlib.suppress(asyncio.CancelledError):
             await self.recording_task
-        except asyncio.CancelledError:
-            pass
         self.recording_task = None
 
     def ack(self, frame_id: int):
-        """ Handle acknowledgement for screencast frames. """
+        """Handle acknowledgement for screencast frames."""
         self.frames_acked.append(frame_id)
 
     def resize_jpeg(self, data: str) -> str:
@@ -83,9 +85,9 @@ class ScreenCast:
         """
         resized_img = Image.open(BytesIO(b64decode(data)))
         resized_img = resized_img.resize((self.scaled_width, self.scaled_height), Image.ANTIALIAS)
-        resized_img = resized_img.convert('RGB')
+        resized_img = resized_img.convert("RGB")
         resized = BytesIO()
-        resized_img.save(resized, format='jpeg', quality='maximum')
+        resized_img.save(resized, format="jpeg", quality="maximum")
         return b64encode(resized.getvalue()).decode()
 
     async def get_offsets(self, message_id: int):
@@ -96,12 +98,11 @@ class ScreenCast:
         :rtype: tuple
         """
         frame_size = await self.target.evaluate_and_result(
-            message_id,
-            'window.document.body.offsetTop + "," + window.pageXOffset + "," + window.pageYOffset'
+            message_id, 'window.document.body.offsetTop + "," + window.pageXOffset + "," + window.pageYOffset'
         )
         if frame_size is None or not isinstance(frame_size, str):
             return 0, 0, 0
-        return tuple(map(int, frame_size.split(',')))
+        return tuple(map(int, frame_size.split(",")))
 
     async def recording_loop(self, message_id):
         """
@@ -114,24 +115,32 @@ class ScreenCast:
                 continue
             self.frame_id += 1
             offset_top, scroll_offset_x, scroll_offset_y = await self.get_offsets(message_id)
-            event = await self.target.send_message_with_result(message_id, 'Page.snapshotRect', {
-                'x': 0, 'y': 0, 'width': self.device_width, 'height': self.device_height, 'coordinateSystem': 'Viewport'
-            })
-            data = event['result']['dataURL']
-            data = data[data.find('base64,') + 7:]
+            event = await self.target.send_message_with_result(
+                message_id,
+                "Page.snapshotRect",
+                {
+                    "x": 0,
+                    "y": 0,
+                    "width": self.device_width,
+                    "height": self.device_height,
+                    "coordinateSystem": "Viewport",
+                },
+            )
+            data = event["result"]["dataURL"]
+            data = data[data.find("base64,") + 7 :]
             await self.target.output_queue.put({
-                'method': 'Page.screencastFrame',
-                'params': {
-                    'data': self.resize_jpeg(data),
-                    'sessionId': self.frame_id - 1,
-                    'metadata': {
-                        'pageScaleFactor': self.page_scale_factor,
-                        'offsetTop': offset_top,
-                        'deviceWidth': self.scaled_width,
-                        'deviceHeight': self.scaled_height,
-                        'scrollOffsetX': scroll_offset_x,
-                        'scrollOffsetY': scroll_offset_y,
-                        'timestamp': datetime.now().strftime('%Y-%m-%dT%H:%M:%S.%f'),
-                    }
-                }
+                "method": "Page.screencastFrame",
+                "params": {
+                    "data": self.resize_jpeg(data),
+                    "sessionId": self.frame_id - 1,
+                    "metadata": {
+                        "pageScaleFactor": self.page_scale_factor,
+                        "offsetTop": offset_top,
+                        "deviceWidth": self.scaled_width,
+                        "deviceHeight": self.scaled_height,
+                        "scrollOffsetX": scroll_offset_x,
+                        "scrollOffsetY": scroll_offset_y,
+                        "timestamp": datetime.now().strftime("%Y-%m-%dT%H:%M:%S.%f"),
+                    },
+                },
             })

pymobiledevice3/services/web_protocol/cdp_server.py

@@ -19,7 +19,7 @@ async def lifespan(app: FastAPI):
 app = FastAPI(lifespan=lifespan)
 
 
-@app.get('/json{_:path}')
+@app.get("/json{_:path}")
 async def available_targets(_: str):
     app.state.inspector.get_open_pages()
     targets = []
@@ -28,47 +28,47 @@ async def available_targets(_: str):
             if page.type_ not in (WirTypes.WEB, WirTypes.WEB_PAGE):
                 continue
             targets.append({
-                'description': '',
-                'id': page_id,
-                'title': page.web_title,
-                'type': 'page',
-                'url': page.web_url,
-                'webSocketDebuggerUrl': f'ws://localhost:9222/devtools/page/{page_id}',
-                'devtoolsFrontendUrl': f'/devtools/inspector.html?ws://localhost:9222/devtools/page/{page_id}',
+                "description": "",
+                "id": page_id,
+                "title": page.web_title,
+                "type": "page",
+                "url": page.web_url,
+                "webSocketDebuggerUrl": f"ws://localhost:9222/devtools/page/{page_id}",
+                "devtoolsFrontendUrl": f"/devtools/inspector.html?ws://localhost:9222/devtools/page/{page_id}",
             })
     return targets
 
 
-@app.get('/json/version')
+@app.get("/json/version")
 def version():
     return {
-        'Browser': 'Safari',
-        'Protocol-Version': '1.1',
-        'User-Agent': 'pymobiledevice3',
-        'V8-Version': '7.2.233',
-        'WebKit-Version': '537.36 (@cfede9db1d154de0468cb0538479f34c0755a0f4)',
-        'webSocketDebuggerUrl': f'ws://localhost:9222/devtools/browser/{app.state.inspector.connection_id}'
+        "Browser": "Safari",
+        "Protocol-Version": "1.1",
+        "User-Agent": "pymobiledevice3",
+        "V8-Version": "7.2.233",
+        "WebKit-Version": "537.36 (@cfede9db1d154de0468cb0538479f34c0755a0f4)",
+        "webSocketDebuggerUrl": f"ws://localhost:9222/devtools/browser/{app.state.inspector.connection_id}",
     }
 
 
 async def from_cdp(target: CdpTarget, websocket):
     async for message in websocket.iter_json():
-        logger.debug(f'CDP INPUT:  {message}')
+        logger.debug(f"CDP INPUT:  {message}")
         await target.send(message)
 
 
 async def to_cdp(target: CdpTarget, websocket):
     while True:
         message = await target.receive()
-        logger.debug(f'CDP OUTPUT:  {message}')
+        logger.debug(f"CDP OUTPUT:  {message}")
         await websocket.send_json(message)
 
 
-@app.websocket('/devtools/page/{page_id}')
+@app.websocket("/devtools/page/{page_id}")
 async def page_debugger(websocket: WebSocket, page_id: str):
     application, page = app.state.inspector.find_page_id(page_id)
     session_id = str(uuid.uuid4()).upper()
-    protocol = SessionProtocol(app.state.inspector, session_id, application, page, method_prefix='')
+    protocol = SessionProtocol(app.state.inspector, session_id, application, page, method_prefix="")
     target = await CdpTarget.create(protocol)
     await websocket.accept()
     await asyncio.gather(