pybiolib 0.2.951__py3-none-any.whl → 1.2.1890__py3-none-any.whl

biolib/pyppeteer/pyppeteer/pipe_transport.py

@@ -1,59 +0,0 @@
-import logging
-from typing import Callable, Optional
-
-from pyppeteer import helpers
-
-logger = logging.getLogger(__name__)
-
-
-class PipeTransport:
-    def __init__(
-        self, pipeWrite, pipeRead,
-    ):
-        self._pipeWrite = pipeWrite
-        self._pendingMessage = ''
-        self.onmessage: Optional[Callable[[Optional[str], str], None]] = None
-        self.onclose: Optional[Callable[[], None]] = None
-
-        def _onclose() -> None:
-            if self.onclose:
-                self.onclose()
-
-        self._eventListeners = [
-            helpers.addEventListener(pipeRead, 'data', lambda buffer: self._dispatch(buffer)),
-            helpers.addEventListener(pipeRead, 'close', _onclose),
-            helpers.addEventListener(
-                pipeRead, 'error', lambda e: logger.error(f'An exception occurred on pipe read: {e}')
-            ),
-            helpers.addEventListener(
-                pipeWrite, 'error', lambda e: logger.error(f'An exception occurred on pipe read: {e}')
-            ),
-        ]
-
-    def send(self, message: str) -> None:
-        self._pipeWrite.write(message)
-        self._pipeWrite.write('\0')
-
-    def _dispatch(self, buffer: str) -> None:
-        end = buffer.find('\0')  # -1 means nothing found
-        if end == -1:
-            self._pendingMessage += buffer
-            return
-
-        message = self._pendingMessage + buffer
-        if message and self.onmessage:
-            self.onmessage(None, message)
-
-        start = end + 1
-        end = buffer.find('\0', start)
-        while end != -1:
-            if self.onmessage:
-                self.onmessage(None, buffer)
-            start = end + 1
-            end = buffer.find('\0', start)
-
-        self._pendingMessage = buffer
-
-    def close(self) -> None:
-        self._pipeWrite = None
-        helpers.removeEventListeners(self._eventListeners)

biolib/pyppeteer/pyppeteer/target.py

@@ -1,147 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""Target module."""
-
-import asyncio
-from typing import TYPE_CHECKING, Awaitable, Callable, Dict, Optional
-
-from biolib.pyppeteer.pyppeteer.connection import CDPSession
-from biolib.pyppeteer.pyppeteer.events import Events
-from biolib.pyppeteer.pyppeteer.helpers import safe_future_set_result
-from biolib.pyppeteer.pyppeteer.models import Protocol
-from biolib.pyppeteer.pyppeteer.page import Page
-from biolib.pyppeteer.pyppeteer.task_queue import TaskQueue
-from biolib.pyppeteer.pyppeteer.worker import Worker
-
-if TYPE_CHECKING:
-    from pyppeteer.browser import Browser, BrowserContext
-
-
-class Target:
-    """Browser's target class."""
-
-    def __init__(
-        self,
-        targetInfo: Dict,
-        browserContext: 'BrowserContext',
-        sessionFactory: Callable[[], Awaitable[CDPSession]],
-        ignoreHTTPSErrors: bool,
-        defaultViewport: Protocol.Page.Viewport,
-        screenshotTaskQueue: TaskQueue,
-        loop: asyncio.AbstractEventLoop,
-    ) -> None:
-        self._targetInfo = targetInfo
-        self._browserContext = browserContext
-        self._targetId = targetInfo.get('targetId', '')
-        self._sessionFactory = sessionFactory
-        self._ignoreHTTPSErrors = ignoreHTTPSErrors
-        self._defaultViewport = defaultViewport
-        self._screenshotTaskQueue = screenshotTaskQueue
-        self._page: Optional[Page] = None
-        self._workerFuture: Optional[Awaitable[Worker]] = None
-        self.loop = loop
-
-        self._initializedPromise = self.loop.create_future()
-        self._isClosedPromise = self.loop.create_future()
-        self._isInitialized = self._targetInfo['type'] != 'page' or self._targetInfo['url'] != ''
-        if self._isInitialized:
-            self._initializedCallback(True)
-
-    def _initializedCallback(self, success: bool) -> None:
-        if not success:
-            return safe_future_set_result(self._initializedPromise, False)
-        opener = self.opener
-        if not opener or not opener._page or self.type != 'page':
-            return self._initializedPromise.set_result(True)
-        openerPage = opener._page
-        if not openerPage.listeners(Events.Page.Popup):
-            return self._initializedPromise.set_result(True)
-        openerPage.emit(Events.Page.Popup, openerPage)
-        return self._initializedPromise.set_result(True)
-
-    def _closedCallback(self) -> None:
-        self._isClosedPromise.set_result(None)
-
-    async def createCDPSession(self) -> CDPSession:
-        """Create a Chrome Devtools Protocol session attached to the target."""
-        return await self._sessionFactory()
-
-    async def page(self) -> Optional[Page]:
-        """Get page of this target.
-
-        If the target is not of type "page" or "background_page", return
-        ``None``.
-        """
-        if self._page:
-            return self._page
-        if self._targetInfo['type'] in ['page', 'background_page']:
-            session = await self._sessionFactory()
-            self._page = await Page.create(
-                client=session,
-                target=self,
-                ignoreHTTPSErrors=self._ignoreHTTPSErrors,
-                defaultViewport=self._defaultViewport,
-                screenshotTaskQueue=self._screenshotTaskQueue,
-            )
-        return self._page
-
-    def worker(self) -> Optional[Awaitable[Worker]]:
-        _type = self._targetInfo['type']
-        if _type not in ['service_worker', 'shared_worker']:
-            return None
-        if not self._workerFuture:
-
-            async def worker_fut_task() -> Worker:
-                nonlocal self
-                session = await self._sessionFactory()
-                return Worker(session, self._targetInfo['url'], lambda *_: None, lambda *_: None)
-
-            self._workerFuture = self.loop.create_task(worker_fut_task())
-            return self._workerFuture
-
-    @property
-    def url(self) -> str:
-        """Get url of this target."""
-        return self._targetInfo['url']
-
-    @property
-    def type(self) -> str:
-        """Get type of this target.
-
-        Type can be ``'page'``, ``'background_page'``, ``'service_worker'``,
-        ``'browser'``, or ``'other'``.
-        """
-        _type = self._targetInfo['type']
-        if _type in ['page', 'background_page', 'service_worker', 'shared_worker', 'browser']:
-            return _type
-        return 'other'
-
-    @property
-    def browser(self) -> 'Browser':
-        """Get the browser the target belongs to."""
-        return self._browserContext.browser
-
-    @property
-    def browserContext(self) -> 'BrowserContext':
-        """Return the browser context the target belongs to."""
-        return self._browserContext
-
-    @property
-    def opener(self) -> Optional['Target']:
-        """Get the target that opened this target.
-
-        Top-level targets return ``None``.
-        """
-        openerId = self._targetInfo.get('openerId')
-        if openerId is None:
-            return None
-        return self.browser._targets.get(openerId)
-
-    def _targetInfoChanged(self, targetInfo: Dict) -> None:
-        self._targetInfo = targetInfo
-
-        if not self._isInitialized and (self._targetInfo['type'] != 'page' or self._targetInfo['url'] != ''):
-            self._isInitialized = True
-            self._initializedCallback(True)
-            return

biolib/pyppeteer/pyppeteer/task_queue.py

@@ -1,24 +0,0 @@
-import asyncio
-import logging
-from typing import Any, Awaitable
-
-logger = logging.getLogger(__name__)
-
-
-class TaskQueue:
-    def __init__(self, loop: asyncio.AbstractEventLoop = None):
-        self.loop = loop or asyncio.get_event_loop()
-        fut = self.loop.create_future()
-        fut.set_result(None)
-        self._task_chain = fut
-
-    def post_task(self, task: Awaitable[Any]) -> Awaitable[Any]:
-        async def run_awaitable(prev) -> None:
-            try:
-                await prev
-                return await task
-            except Exception as e:
-                logger.error(f'Exception while evaluating task queue: {e}')
-
-        self._task_chain = self.loop.create_task(run_awaitable(self._task_chain))
-        return self._task_chain

biolib/pyppeteer/pyppeteer/timeout_settings.py

@@ -1,36 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""
-Timeout setting module
-
-puppeteer equivalent: TimeoutSettings.js
-"""
-
-DEFAULT_TIMEOUT = 30_000  # 30 seconds
-
-
-class TimeoutSettings:
-    def __init__(self):
-        self._defaultTimeout = None
-        self._defaultNavigationTimeout = None
-
-    def setDefaultTimeout(self, timeout: float) -> None:
-        self._defaultTimeout = timeout
-
-    def setDefaultNavigationTimeout(self, timeout: float) -> None:
-        self._defaultNavigationTimeout = timeout
-
-    @property
-    def navigationTimeout(self) -> float:
-        if self._defaultNavigationTimeout:
-            return self._defaultNavigationTimeout
-        if self._defaultTimeout:
-            return self._defaultTimeout
-        return DEFAULT_TIMEOUT
-
-    @property
-    def timeout(self) -> float:
-        if self._defaultTimeout:
-            return self._defaultTimeout
-        return DEFAULT_TIMEOUT

biolib/pyppeteer/pyppeteer/tracing.py

@@ -1,93 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""Tracing module."""
-
-from pathlib import Path
-from typing import Sequence, Union
-
-from biolib.pyppeteer.pyppeteer import helpers
-from biolib.pyppeteer.pyppeteer.connection import CDPSession
-
-
-class Tracing:
-    """Tracing class.
-
-    You can use :meth:`start` and :meth:`stop` to create a trace file which can
-    be opened in Chrome DevTools or
-    `timeline viewer <https://chromedevtools.github.io/timeline-viewer/>`_.
-
-    .. code::
-
-        await page.tracing.start({'path': 'trace.json'})
-        await page.goto('https://www.google.com')
-        await page.tracing.stop()
-    """
-
-    def __init__(self, client: CDPSession) -> None:
-        self._client = client
-        self._recording = False
-        self._path = ''
-
-    async def start(
-        self, path: Union[Path, str] = '', screenshots: bool = False, categories: Sequence[str] = None
-    ) -> None:
-        """Start tracing.
-
-        Only one trace can be active at a time per browser.
-
-        This method accepts the following options:
-
-        * ``path`` (str): A path to write the trace file to.
-        * ``screenshots`` (bool): Capture screenshots in the trace.
-        * ``categories`` (List[str]): Specify custom categories to use instead
-          of default.
-        """
-        defaultCategories = [
-            '-*',
-            'devtools.timeline',
-            'v8.execute',
-            'disabled-by-default-devtools.timeline',
-            'disabled-by-default-devtools.timeline.frame',
-            'toplevel',
-            'blink.console',
-            'blink.user_timing',
-            'latencyInfo',
-            'disabled-by-default-devtools.timeline.stack',
-            'disabled-by-default-v8.cpu_profiler',
-            'disabled-by-default-v8.cpu_profiler.hires',
-        ]
-
-        if not isinstance(categories, list):
-            try:
-                categories = list(categories)
-            except TypeError:
-                categories = defaultCategories
-
-        if screenshots:
-            categories.append('disabled-by-default-devtools.screenshot')
-
-        self._path = path
-        self._recording = True
-        await self._client.send(
-            'Tracing.start', {'transferMode': 'ReturnAsStream', 'categories': ','.join(categories),}
-        )
-
-    async def stop(self) -> str:
-        """Stop tracing.
-
-        :return: trace data as string.
-        """
-        contentFuture = self._client.loop.create_future()
-
-        async def complete_trace(event):
-            nonlocal self, contentFuture
-            result = await helpers.readProtocolStream(self._client, event['stream'], self._path)
-            contentFuture.set_result(result)
-
-        self._client.once(
-            'Tracing.tracingComplete', complete_trace,
-        )
-        await self._client.send('Tracing.end')
-        self._recording = False
-        return await contentFuture