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

biolib/pyppeteer/pyppeteer/emulation_manager.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""Emulation Manager module."""
-import asyncio
-
-from biolib.pyppeteer.pyppeteer.connection import CDPSession
-from biolib.pyppeteer.pyppeteer.models import Protocol
-
-
-class EmulationManager:
-    """EmulationManager class."""
-
-    def __init__(self, client: CDPSession) -> None:
-        """Make new emulation manager."""
-        self._client = client
-        self._emulatingMobile = False
-        self._hasTouch = False
-        self._emulatingMobile = False
-
-    async def emulateViewport(self, viewport: Protocol.Page.Viewport) -> bool:
-        """
-        Evaluate viewport.
-        :param viewport: dictionary which supports keys: isMobile, width, height,
-            deviceScaleFactor, isLandscape, hasTouch
-        """
-        mobile = viewport.get('isMobile', False)
-        width = viewport.get('width')
-        height = viewport.get('height')
-        deviceScaleFactor = viewport.get('deviceScaleFactor', 1)
-        if viewport.get('isLandscape'):
-            screenOrientation = {'angle': 90, 'type': 'landscapePrimary'}
-        else:
-            screenOrientation = {'angle': 0, 'type': 'portraitPrimary'}
-        hasTouch = viewport.get('hasTouch', False)
-
-        await asyncio.gather(
-            self._client.send(
-                'Emulation.setDeviceMetricsOverride',
-                {
-                    'mobile': mobile,
-                    'width': width,
-                    'height': height,
-                    'deviceScaleFactor': deviceScaleFactor,
-                    'screenOrientation': screenOrientation,
-                },
-            ),
-            self._client.send('Emulation.setTouchEmulationEnabled', {'enabled': hasTouch}),
-        )
-        reloadNeeded = self._emulatingMobile != mobile or self._hasTouch != hasTouch
-        self._emulatingMobile = mobile
-        self._hasTouch = hasTouch
-        return reloadNeeded

biolib/pyppeteer/pyppeteer/errors.py

@@ -1,48 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""Exceptions for pyppeteer package."""
-
-import asyncio
-
-
-class PyppeteerError(Exception):  # noqa: D204
-    """Base exception for pyppeteer."""
-
-    pass
-
-
-class BrowserError(PyppeteerError):  # noqa: D204
-    """Exception raised from browser."""
-
-    pass
-
-
-class ElementHandleError(PyppeteerError):  # noqa: D204
-    """ElementHandle related exception."""
-
-    pass
-
-
-class NetworkError(PyppeteerError):  # noqa: D204
-    """Network/Protocol related exception."""
-
-    pass
-
-
-class PageError(PyppeteerError):  # noqa: D204
-    """Page/Frame related exception."""
-
-    pass
-
-
-class TimeoutError(asyncio.TimeoutError):  # noqa: D204
-    """Timeout Error class."""
-
-    pass
-
-
-class DeprecationError(PyppeteerError):  # noqa: D204
-    """Deprecated Error class"""
-
-    pass

biolib/pyppeteer/pyppeteer/events.py

@@ -1,63 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Events module
-
-puppeteer equivalent: Events.js
-"""
-
-
-class Events:
-    class Page:
-        Close = 'close'
-        Console = 'console'
-        Dialog = 'dialog'
-        DOMContentLoaded = 'domcontentloaded'
-        Error = 'error'
-        # Can't use just 'error' due to node.js special treatment of error events.
-        # @see https://nodejs.org/api/events.html#events_error_events
-        PageError = 'pageerror'
-        Request = 'request'
-        Response = 'response'
-        RequestFailed = 'requestfailed'
-        RequestFinished = 'requestfinished'
-        FrameAttached = 'frameattached'
-        FrameDetached = 'framedetached'
-        FrameNavigated = 'framenavigated'
-        Load = 'load'
-        Metrics = 'metrics'
-        Popup = 'popup'
-        WorkerCreated = 'workercreated'
-        WorkerDestroyed = 'workerdestroyed'
-
-    class Browser:
-        TargetCreated = 'targetcreated'
-        TargetDestroyed = 'targetdestroyed'
-        TargetChanged = 'targetchanged'
-        Disconnected = 'disconnected'
-
-    class BrowserContext:
-        TargetCreated = 'targetcreated'
-        TargetDestroyed = 'targetdestroyed'
-        TargetChanged = 'targetchanged'
-
-    class NetworkManager:
-        Request = 'Events.NetworkManager.Request'
-        Response = 'Events.NetworkManager.Response'
-        RequestFailed = 'Events.NetworkManager.RequestFailed'
-        RequestFinished = 'Events.NetworkManager.RequestFinished'
-
-    class FrameManager:
-        FrameAttached = 'Events.FrameManager.FrameAttached'
-        FrameNavigated = 'Events.FrameManager.FrameNavigated'
-        FrameDetached = 'Events.FrameManager.FrameDetached'
-        LifecycleEvent = 'Events.FrameManager.LifecycleEvent'
-        FrameNavigatedWithinDocument = 'Events.FrameManager.FrameNavigatedWithinDocument'
-        ExecutionContextCreated = 'Events.FrameManager.ExecutionContextCreated'
-        ExecutionContextDestroyed = 'Events.FrameManager.ExecutionContextDestroyed'
-
-    class Connection:
-        Disconnected = 'Events.Connection.Disconnected'
-
-    class CDPSession:
-        Disconnected = 'Events.CDPSession.Disconnected'

biolib/pyppeteer/pyppeteer/execution_context.py

@@ -1,156 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-
-"""Execution Context Module."""
-
-import logging
-import math
-import re
-from typing import TYPE_CHECKING, Any, Dict, Optional, Union
-
-from biolib.pyppeteer.pyppeteer import helpers
-from biolib.pyppeteer.pyppeteer.connection import CDPSession
-from biolib.pyppeteer.pyppeteer.errors import ElementHandleError
-from biolib.pyppeteer.pyppeteer.jshandle import ElementHandle, JSHandle, createJSHandle
-from biolib.pyppeteer.pyppeteer.models import JSFunctionArg
-
-if TYPE_CHECKING:
-    from pyppeteer.frame import Frame
-    from pyppeteer.domworld import DOMWorld
-
-logger = logging.getLogger(__name__)
-
-EVALUATION_SCRIPT_URL = '__pyppeteer_evaluation_script__'
-SOURCE_URL_REGEX = re.compile(r'^[ \t]*//[@#] sourceURL=\s*(\S*?)\s*$', re.MULTILINE,)
-
-class ExecutionContext:
-    """Execution Context class."""
-
-    def __init__(self, client: CDPSession, contextPayload: Dict, world: Optional['DOMWorld']) -> None:
-        self._client = client
-        self._world = world
-        self._contextId = contextPayload['id']
-
-    @property
-    def frame(self) -> Optional['Frame']:
-        """Return frame associated with this execution context."""
-        if self._world:
-            return self._world.frame
-
-    async def evaluate(self, pageFunction: str, *args: JSFunctionArg) -> JSFunctionArg:
-        """Execute ``pageFunction`` on this context.
-
-        Details see :meth:`pyppeteer.page.Page.evaluate`.
-        """
-        return await self._evaluateInternal(True, pageFunction, *args)
-
-    async def evaluateHandle(self, pageFunction: str, *args: JSFunctionArg) -> Union['JSHandle', 'ElementHandle']:
-        """Execute ``pageFunction`` on this context.
-        Details see :meth:`pyppeteer.page.Page.evaluateHandle`.
-        """
-        return await self._evaluateInternal(False, pageFunction, *args)
-
-    async def _evaluateInternal(
-        self, returnByValue: bool, pageFunction: str, *args: JSFunctionArg
-    ) -> Union['JSHandle', 'ElementHandle', JSFunctionArg]:
-        suffix = f'//# sourceURL={EVALUATION_SCRIPT_URL}'
-
-        if not helpers.is_js_func(pageFunction):
-            try:
-                if SOURCE_URL_REGEX.match(pageFunction):
-                    expressionWithSourceUrl = pageFunction
-                else:
-                    expressionWithSourceUrl = f'{pageFunction}\n{suffix}'
-                remoteObject = await self._client.send(
-                    'Runtime.evaluate',
-                    {
-                        'expression': expressionWithSourceUrl,
-                        'contextId': self._contextId,
-                        'returnByValue': returnByValue,
-                        'awaitPromise': True,
-                        'userGesture': True,
-                    },
-                )
-            except Exception as e:
-                exceptionDetails = rewriteError(e)
-                raise type(e)(f'Evaluation failed: {helpers.getExceptionMessage(exceptionDetails)}')
-        else:
-            try:
-                remoteObject = await self._client.send(
-                    'Runtime.callFunctionOn',
-                    {
-                        'functionDeclaration': f'{pageFunction}\n{suffix}\n',
-                        'executionContextId': self._contextId,
-                        'arguments': [self._convertArgument(arg) for arg in args],
-                        'returnByValue': returnByValue,
-                        'awaitPromise': True,
-                        'userGesture': True,
-                    },
-                )
-            except Exception as e:
-                exceptionDetails = rewriteError(e)
-                raise type(e)(f'Evaluation failed: {helpers.getExceptionMessage(exceptionDetails)}')
-
-        exceptionDetails = remoteObject.get('exceptionDetails')
-        if exceptionDetails:
-            raise ElementHandleError('Evaluation failed: {}'.format(helpers.getExceptionMessage(exceptionDetails)))
-
-        remoteObject = remoteObject['result']
-        if returnByValue:
-            return helpers.valueFromRemoteObject(remoteObject)
-        else:
-            return createJSHandle(self, remoteObject)
-
-    def _convertArgument(self, arg: Any) -> Dict:  # noqa: C901
-        if arg == math.inf:
-            return {'unserializableValue': 'Infinity'}
-        if arg == -math.inf:
-            return {'unserializableValue': '-Infinity'}
-        objectHandle = arg if isinstance(arg, JSHandle) else None
-        if objectHandle:
-            if objectHandle._context != self:
-                raise ElementHandleError('JSHandles can be evaluated only in the context they were created!')
-            if objectHandle._disposed:
-                raise ElementHandleError('JSHandle is disposed!')
-            if objectHandle._remoteObject.get('unserializableValue'):
-                return {'unserializableValue': objectHandle._remoteObject.get('unserializableValue')}
-            if not objectHandle._remoteObject.get('objectId'):
-                return {'value': objectHandle._remoteObject.get('value')}
-            return {'objectId': objectHandle._remoteObject.get('objectId')}
-        return {'value': arg}
-
-    async def queryObjects(self, prototypeHandle: 'JSHandle'):
-        if prototypeHandle._disposed:
-            raise ElementHandleError('Prototype JSHandle is disposed')
-        if not prototypeHandle._remoteObject.get('objectId'):
-            raise ElementHandleError('Prototype JSHandle must not be referencing primitive value')
-        response = await self._client.send(
-            'Runtime.queryObjects', {'prototypeObjectId': prototypeHandle._remoteObject['objectId']}
-        )
-        return createJSHandle(context=self, remoteObject=response.get('objects'))
-
-    async def _adoptBackendNodeId(self, backendNodeId: int):
-        obj = await self._client.send(
-            'DOM.resolveNode', {'backendNodeId': backendNodeId, 'executionContextId': self._contextId}
-        )
-        obj = obj['object']
-        return createJSHandle(context=self, remoteObject=obj)
-
-    async def _adoptElementHandle(self, elementHandle: ElementHandle):
-        if elementHandle.executionContext == self:
-            raise ElementHandleError('Cannot adopt handle that already belongs to this execution context')
-        if not self._world:
-            raise ElementHandleError('Cannot adopt handle without DOMWorld')
-        nodeInfo = await self._client.send('DOM.describeNode', {'objectId': elementHandle._remoteObject['objectId']})
-        return await self._adoptBackendNodeId(nodeInfo['node']['backendNodeId'])
-
-
-def rewriteError(error: Exception) -> Union[None, Dict[str, Dict[str, str]]]:
-    msg = error.args[0]
-    if 'Object reference chain is too long' in msg:
-        return {'result': {'type': 'undefined'}}
-    if "Object couldn't be returned by value" in msg:
-        return {'result': {'type': 'undefined'}}
-    if msg.endswith('Cannot find context with specified id'):
-        raise type(error)('Execution context was destroyed, most likely because of a navigation.')
-    raise error

biolib/pyppeteer/pyppeteer/frame/__init__.py

@@ -1,299 +0,0 @@
-import asyncio
-from pathlib import Path
-from typing import TYPE_CHECKING, Any, Awaitable, List, Optional, Set, Union
-
-from ordered_set import OrderedSet
-from biolib.pyppeteer.pyppeteer import helpers
-from biolib.pyppeteer.pyppeteer.connection import CDPSession
-from biolib.pyppeteer.pyppeteer.domworld import DOMWorld, WaitTask
-from biolib.pyppeteer.pyppeteer.errors import BrowserError, PageError
-from biolib.pyppeteer.pyppeteer.jshandle import ElementHandle, JSHandle
-from biolib.pyppeteer.pyppeteer.models import JSFunctionArg, WaitTargets
-from biolib.pyppeteer.pyppeteer.network_manager import Response
-
-if TYPE_CHECKING:
-    from pyppeteer.execution_context import ExecutionContext
-
-
-class Frame:
-    """Frame class.
-
-    Frame objects can be obtained via :attr:`pyppeteer.page.Page.mainFrame`.
-    """
-
-    def __init__(
-        self, frameManager: 'FrameManager', client: CDPSession, parentFrame: Optional['Frame'], frameId: str
-    ) -> None:
-        self._frameManager = frameManager
-        self._client = client
-        self._parentFrame = parentFrame
-        self._url = ''
-        self._id = frameId
-        self._detached = False
-
-        self._loaderId = ''
-        self._lifecycleEvents: Set[str] = set()
-        self._mainWorld = DOMWorld(frameManager, self, frameManager._timeoutSettings)
-        self._secondaryWorld = DOMWorld(frameManager, self, frameManager._timeoutSettings)
-        self._childFrames: OrderedSet[Frame] = OrderedSet()
-        if self._parentFrame:
-            self._parentFrame._childFrames.add(self)
-
-        self._waitTasks: Set[WaitTask] = set()
-        if self._parentFrame:
-            self._parentFrame._childFrames.add(self)
-
-        self.addScriptTag = self.mainWorld.addScriptTag
-        self.addStyleTag = self.mainWorld.addStyleTag
-        self.evaluate = self.mainWorld.evaluate
-        self.evaluateHandle = self.mainWorld.evaluateHandle
-        self.querySelector = self.J = self.mainWorld.querySelector
-        self.querySelectorAll = self.JJ = self.mainWorld.querySelectorAll
-        self.querySelectorAllEval = self.JJeval = self.mainWorld.querySelectorAllEval
-        self.querySelectorEval = self.Jeval = self.mainWorld.querySelectorEval
-        self.type = self.mainWorld.type
-        self.waitForFunction = self.mainWorld.waitForFunction
-        self.xpath = self.Jx = self.mainWorld.xpath
-
-        self.click = self.secondaryWorld.click
-        self.focus = self.secondaryWorld.focus
-        self.hover = self.secondaryWorld.hover
-        self.select = self.secondaryWorld.select
-        self.setContent = self.secondaryWorld.setContent
-        self.tap = self.secondaryWorld.tap
-
-    @property
-    async def executionContext(self) -> Optional['ExecutionContext']:
-        return await self.mainWorld.executionContext
-
-    @property
-    async def content(self) -> str:
-        return await self.secondaryWorld.content
-
-    @property
-    async def title(self) -> str:
-        return await self.secondaryWorld.title
-
-    async def goto(
-        self, url: str, referer: str = None, timeout: float = None, waitUntil: WaitTargets = None
-    ) -> Optional[Response]:
-        return await self._frameManager.navigateFrame(
-            self, url=url, referer=referer, timeout=timeout, waitUntil=waitUntil
-        )
-
-    async def waitForNavigation(
-        self, timeout: Optional[float] = None, waitUntil: Optional[WaitTargets] = None
-    ) -> Optional[Response]:
-        return await self._frameManager.waitForFrameNavigation(self, waitUntil=waitUntil, timeout=timeout)
-
-    @property
-    def mainWorld(self) -> 'DOMWorld':  # ensure mainWorld not settable
-        return self._mainWorld
-
-    @property
-    def secondaryWorld(self) -> 'DOMWorld':  # ensure secondaryWorld is not settable
-        return self._secondaryWorld
-
-    @property
-    def name(self) -> str:
-        """Get frame name."""
-        return getattr(self, '_name', '')
-
-    @property
-    def url(self) -> str:
-        """Get url of the frame."""
-        return self._url
-
-    @property
-    def parentFrame(self) -> Optional['Frame']:
-        """Get parent frame.
-
-        If this frame is main frame or detached frame, return ``None``.
-        """
-        return self._parentFrame
-
-    @property
-    def childFrames(self) -> List['Frame']:
-        """Get child frames."""
-        return list(self._childFrames)
-
-    @property
-    def isDetached(self) -> bool:
-        """Return ``True`` if this frame is detached.
-
-        Otherwise return ``False``.
-        """
-        return self._detached
-
-    async def addScriptTag(
-        self,
-        url: Optional[str] = None,
-        path: Optional[Union[str, Path]] = None,
-        content: Optional[str] = None,
-        type_: str = '',
-    ) -> ElementHandle:
-        """Add script tag to this frame.
-
-        Details see :meth:`pyppeteer.page.Page.addScriptTag`.
-        """
-        return await self._mainWorld.addScriptTag(url=url, path=path, content=content, type_=type_)
-
-    async def addStyleTag(
-        self, url: Optional[str] = None, path: Optional[Union[str, Path]] = None, content: Optional[str] = None
-    ) -> Optional['ElementHandle']:
-        return await self._mainWorld.addStyleTag(url=url, path=path, content=content)
-
-    async def focus(self, selector: str) -> None:
-        """Focus element which matches ``selector``.
-
-        Details see :meth:`pyppeteer.page.Page.focus`.
-        """
-        handle = await self.J(selector)
-        if not handle:
-            raise PageError('No node found for selector: ' + selector)
-        await self.evaluate('element => element.focus()', handle)
-        await handle.dispose()
-
-    async def hover(self, selector: str) -> None:
-        """Mouse hover the element which matches ``selector``.
-
-        Details see :meth:`pyppeteer.page.Page.hover`.
-        """
-        handle = await self.J(selector)
-        if not handle:
-            raise PageError('No node found for selector: ' + selector)
-        await handle.hover()
-        await handle.dispose()
-
-    async def select(self, selector: str, *values: str) -> List[str]:
-        """Select options and return selected values.
-
-        Details see :meth:`pyppeteer.page.Page.select`.
-        """
-        for index, value in values:
-            if not isinstance(value, str):
-                raise TypeError(f'Values must be string. Found {value} of type {type(value)} at index {index}')
-        return await self.querySelectorEval(  # type: ignore
-            selector,
-            '''
-                (element, values) => {
-                    if (element.nodeName.toLowerCase() !== 'select')
-                        throw new Error('Element is not a <select> element.');
-
-                    const options = Array.from(element.options);
-                    element.value = undefined;
-                    for (const option of options) {
-                        option.selected = values.includes(option.value);
-                        if (option.selected && !element.multiple)
-                            break;
-                    }
-
-                    element.dispatchEvent(new Event('input', { 'bubbles': true }));
-                    element.dispatchEvent(new Event('change', { 'bubbles': true }));
-                    return options.filter(option => option.selected).map(options => options.value)
-                }
-        ''',
-            *values,
-        )
-
-    async def tap(self, selector: str) -> None:
-        """Tap the element which matches the ``selector``.
-
-        Details see :meth:`pyppeteer.page.Page.tap`.
-        """
-        handle = await self.J(selector)
-        if not handle:
-            raise PageError('No node found for selector: ' + selector)
-        await handle.tap()
-        await handle.dispose()
-
-    async def type(self, selector: str, text: str, delay: float = 0) -> None:
-        """Type ``text`` on the element which matches ``selector``.
-
-        Details see :meth:`pyppeteer.page.Page.type`.
-        """
-        handle = await self.querySelector(selector)
-        if handle is None:
-            raise PageError(f'Cannot find {selector} on this page')
-        await handle.type(text, delay)
-        await handle.dispose()
-
-    def waitFor(
-        self, selectorOrFunctionOrTimeout: Union[str, int, float], *args: JSFunctionArg, **kwargs: Any
-    ) -> Awaitable[Optional[JSHandle]]:
-        """Wait until `selectorOrFunctionOrTimeout`.
-
-        Details see :meth:`pyppeteer.page.Page.waitFor`.
-        """
-        xPathPattern = '//'
-        if helpers.is_js_func(selectorOrFunctionOrTimeout):
-            return self.waitForFunction(selectorOrFunctionOrTimeout, *args, **kwargs)
-        if isinstance(selectorOrFunctionOrTimeout, str):
-            string = selectorOrFunctionOrTimeout
-            if string.startswith(xPathPattern):
-                return self.waitForXPath(string, **kwargs)
-            return self.waitForSelector(string, **kwargs)
-        if isinstance(selectorOrFunctionOrTimeout, (int, float)):
-            return self._client.loop.create_task(asyncio.sleep(selectorOrFunctionOrTimeout / 1000))
-        f = self._client.loop.create_future()
-        f.set_exception(BrowserError(f'Unsupported target type: {type(selectorOrFunctionOrTimeout)}'))
-        return f
-
-    async def waitForSelector(
-        self, selector: str, visible: bool = False, hidden: bool = False, timeout: float = None
-    ) -> Optional['ElementHandle']:
-        """Wait until element which matches ``selector`` appears on page.
-
-        Details see :meth:`pyppeteer.page.Page.waitForSelector`.
-        """
-        handle = await self._secondaryWorld.waitForSelector(selector, visible=visible, hidden=hidden, timeout=timeout)
-        if handle:
-            mainExecutionContext = await self._mainWorld.executionContext
-            result = await mainExecutionContext._adoptElementHandle(handle)
-            await handle.dispose()
-            return result
-
-    async def waitForXPath(
-        self, xpath: str, visible: bool = False, hidden: bool = False, timeout: int = None
-    ) -> Optional['ElementHandle']:
-        """Wait until element which matches ``xpath`` appears on page.
-
-        Details see :meth:`pyppeteer.page.Page.waitForXPath`.
-        """
-        handle = await self._secondaryWorld.waitForXpath(xpath, visible=visible, hidden=hidden, timeout=timeout)
-        if not handle:
-            return None
-        mainExecutionContext = await self._mainWorld.executionContext
-        result = await mainExecutionContext._adoptElementHandle(handle)
-        await handle.dispose()
-        return result
-
-    def _navigated(self, framePayload: dict) -> None:
-        self._name = framePayload.get('name', '')
-        self._navigationURL = framePayload.get('url', '')
-        self._url = framePayload.get('url', '')
-
-    def _navigatedWithinDocument(self, url: str) -> None:
-        self._url = url
-
-    def _onLifecycleEvent(self, loaderId: str, name: str) -> None:
-        if name == 'init':
-            self._loaderId = loaderId
-            self._lifecycleEvents.clear()
-        else:
-            self._lifecycleEvents.add(name)
-
-    def _onLoadingStopped(self) -> None:
-        self._lifecycleEvents.add('DOMContentLoaded')
-        self._lifecycleEvents.add('load')
-
-    def _detach(self) -> None:
-        self._detached = True
-        self.mainWorld._detach()
-        self.secondaryWorld._detach()
-        if self._parentFrame:
-            self._parentFrame._childFrames.remove(self)
-        self._parentFrame = None
-
-
-from biolib.pyppeteer.pyppeteer.frame.frame_manager import FrameManager  # isort:skip