pydoll-python 2.0.1__tar.gz → 2.1.0__tar.gz

{pydoll_python-2.0.1 → pydoll_python-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pydoll-python
-Version: 2.0.1
+Version: 2.1.0
 Summary: 
 Author: Thalison Fernandes
 Author-email: thalissfernandes99@gmail.com
@@ -29,6 +29,7 @@ Description-Content-Type: text/markdown
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/ruff-ci.yml/badge.svg" alt="Ruff CI">
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/release.yml/badge.svg" alt="Release">
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/mypy.yml/badge.svg" alt="MyPy CI">
+    <a href="https://deepwiki.com/autoscrape-labs/pydoll"><img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki"></a>
 </p>
 
 <p align="center">
@@ -171,8 +172,8 @@ async def advanced_captcha_bypass():
             print("Cloudflare Turnstile automatically solved!")
             
             # Continue with your automation - captcha is handled
-            await tab.find(id='username').type('user@example.com')
-            await tab.find(id='password').type('password123')
+            await tab.find(id='username').type_text('user@example.com')
+            await tab.find(id='password').type_text('password123')
             await tab.find(tag_name='button', text='Login').click()
         
         # Method 2: Background processing (non-blocking)
@@ -192,14 +193,6 @@ async def advanced_captcha_bypass():
 asyncio.run(advanced_captcha_bypass())
 ```
 
-**Why This Matters:**
-- **No External Dependencies**: No need for captcha solving services or API keys
-- **Cost Effective**: Eliminate monthly captcha solving service fees
-- **Reliable**: Works consistently without depending on third-party availability
-- **Fast**: Instant solving without network delays to external services
-- **Seamless Integration**: Captcha bypass happens transparently in your automation flow
-
-
 ### Advanced Element Finding
 
 Pydoll offers multiple intuitive ways to find elements. No matter how you prefer to work, we have an approach that makes sense for you:
@@ -307,7 +300,7 @@ async def event_driven_automation():
             print("Page loaded! Starting automation...")
             # Perform actions after page loads
             search_box = await tab.find(id='search-box')
-            await search_box.type('automation')
+            await search_box.type_text('automation')
         
         # React to navigation
         async def on_navigation(event):
@@ -348,7 +341,7 @@ async def iframe_interaction():
         
         # You can use all Tab methods on the frame
         form_input = await frame.find(id='captcha-input')
-        await form_input.type('verification-code')
+        await form_input.type_text('verification-code')
         
         # Find elements by various methods
         links = await frame.find(tag_name='a', find_all=True)

{pydoll_python-2.0.1 → pydoll_python-2.1.0}/README.md

@@ -10,6 +10,7 @@
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/ruff-ci.yml/badge.svg" alt="Ruff CI">
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/release.yml/badge.svg" alt="Release">
     <img src="https://github.com/thalissonvs/pydoll/actions/workflows/mypy.yml/badge.svg" alt="MyPy CI">
+    <a href="https://deepwiki.com/autoscrape-labs/pydoll"><img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki"></a>
 </p>
 
 <p align="center">
@@ -152,8 +153,8 @@ async def advanced_captcha_bypass():
             print("Cloudflare Turnstile automatically solved!")
             
             # Continue with your automation - captcha is handled
-            await tab.find(id='username').type('user@example.com')
-            await tab.find(id='password').type('password123')
+            await tab.find(id='username').type_text('user@example.com')
+            await tab.find(id='password').type_text('password123')
             await tab.find(tag_name='button', text='Login').click()
         
         # Method 2: Background processing (non-blocking)
@@ -173,14 +174,6 @@ async def advanced_captcha_bypass():
 asyncio.run(advanced_captcha_bypass())
 ```
 
-**Why This Matters:**
-- **No External Dependencies**: No need for captcha solving services or API keys
-- **Cost Effective**: Eliminate monthly captcha solving service fees
-- **Reliable**: Works consistently without depending on third-party availability
-- **Fast**: Instant solving without network delays to external services
-- **Seamless Integration**: Captcha bypass happens transparently in your automation flow
-
-
 ### Advanced Element Finding
 
 Pydoll offers multiple intuitive ways to find elements. No matter how you prefer to work, we have an approach that makes sense for you:
@@ -288,7 +281,7 @@ async def event_driven_automation():
             print("Page loaded! Starting automation...")
             # Perform actions after page loads
             search_box = await tab.find(id='search-box')
-            await search_box.type('automation')
+            await search_box.type_text('automation')
         
         # React to navigation
         async def on_navigation(event):
@@ -329,7 +322,7 @@ async def iframe_interaction():
         
         # You can use all Tab methods on the frame
         form_input = await frame.find(id='captcha-input')
-        await form_input.type('verification-code')
+        await form_input.type_text('verification-code')
         
         # Find elements by various methods
         links = await frame.find(tag_name='a', find_all=True)

{pydoll_python-2.0.1 → pydoll_python-2.1.0}/pydoll/browser/tab.py

@@ -12,6 +12,7 @@ from typing import (
     TypeAlias,
     Union,
     cast,
+    overload,
 )
 
 import aiofiles
@@ -32,18 +33,25 @@ from pydoll.exceptions import (
     IFrameNotFound,
     InvalidFileExtension,
     InvalidIFrame,
+    InvalidScriptWithElement,
+    NetworkEventsNotEnabled,
     NoDialogPresent,
     NotAnIFrame,
     PageLoadTimeout,
     WaitElementTimeout,
 )
 from pydoll.protocol.base import Response
-from pydoll.protocol.network.types import Cookie, CookieParam
+from pydoll.protocol.network.responses import GetResponseBodyResponse
+from pydoll.protocol.network.types import Cookie, CookieParam, NetworkLog
 from pydoll.protocol.page.events import PageEvent
 from pydoll.protocol.page.responses import CaptureScreenshotResponse, PrintToPDFResponse
-from pydoll.protocol.runtime.responses import EvaluateResponse
+from pydoll.protocol.runtime.responses import CallFunctionOnResponse, EvaluateResponse
 from pydoll.protocol.storage.responses import GetCookiesResponse
-from pydoll.utils import decode_base64_to_bytes
+from pydoll.utils import (
+    decode_base64_to_bytes,
+    has_return_outside_function,
+    is_script_already_function,
+)
 
 if TYPE_CHECKING:
     from pydoll.browser.chromium.base import Browser
@@ -212,9 +220,6 @@ class Tab(FindElementsMixin):  # noqa: PLR0904
             custom_selector: Custom captcha selector (default: cf-turnstile class).
             time_before_click: Delay before clicking captcha (default 2s).
             time_to_wait_captcha: Timeout for captcha detection (default 5s).
-
-        Returns:
-            Callback ID for disabling auto-solver.
         """
         if not self.page_events_enabled:
             await self.enable_page_events()
@@ -285,7 +290,7 @@ class Tab(FindElementsMixin):  # noqa: PLR0904
         Get Tab object for interacting with iframe content.
 
         Args:
-            frame: Tab representing the iframe (<iframe> tag).
+            frame: Tab representing the iframe tag.
 
         Returns:
             Tab instance configured for iframe interaction.
@@ -295,7 +300,6 @@ class Tab(FindElementsMixin):  # noqa: PLR0904
             InvalidIFrame: If iframe lacks valid src attribute.
             IFrameNotFound: If iframe target not found in browser.
         """
-        print('frame.tag_name: ', frame.tag_name)
         if not frame.tag_name == 'iframe':
             raise NotAnIFrame
 
@@ -317,6 +321,50 @@ class Tab(FindElementsMixin):  # noqa: PLR0904
         )
         return response['result']['cookies']
 
+    async def get_network_response_body(self, request_id: str) -> str:
+        """
+        Get the response body for a given request ID.
+
+        Args:
+            request_id: Request ID to get the response body for.
+
+        Returns:
+            The response body for the given request ID.
+
+        Raises:
+            NetworkEventsNotEnabled: If network events are not enabled.
+        """
+        if not self.network_events_enabled:
+            raise NetworkEventsNotEnabled('Network events must be enabled to get response body')
+
+        response: GetResponseBodyResponse = await self._execute_command(
+            NetworkCommands.get_response_body(request_id)
+        )
+        return response['result']['body']
+
+    async def get_network_logs(self, filter: Optional[str] = None) -> list[NetworkLog]:
+        """
+        Get network logs.
+
+        Args:
+            filter: Filter to apply to the network logs.
+
+        Returns:
+            The network logs.
+
+        Raises:
+            NetworkEventsNotEnabled: If network events are not enabled.
+        """
+        if not self.network_events_enabled:
+            raise NetworkEventsNotEnabled('Network events must be enabled to get network logs')
+
+        logs = self._connection_handler.network_logs
+        if filter:
+            logs = [
+                log for log in logs if filter in log['params'].get('request', {}).get('url', '')
+            ]
+        return logs
+
     async def set_cookies(self, cookies: list[CookieParam]):
         """
         Set multiple cookies for current page.
@@ -512,7 +560,15 @@ class Tab(FindElementsMixin):  # noqa: PLR0904
             PageCommands.handle_javascript_dialog(accept=accept, prompt_text=prompt_text)
         )
 
-    async def execute_script(self, script: str, element: Optional[WebElement] = None):
+    @overload
+    async def execute_script(self, script: str) -> EvaluateResponse: ...
+
+    @overload
+    async def execute_script(self, script: str, element: WebElement) -> CallFunctionOnResponse: ...
+
+    async def execute_script(
+        self, script: str, element: Optional[WebElement] = None
+    ) -> Union[EvaluateResponse, CallFunctionOnResponse]:
         """
         Execute JavaScript in page context.
 
@@ -523,17 +579,17 @@ class Tab(FindElementsMixin):  # noqa: PLR0904
         Examples:
             await page.execute_script('argument.click()', element)
             await page.execute_script('argument.value = "Hello"', element)
+
+        Raises:
+            InvalidScriptWithElement: If script contains 'argument' but no element is provided.
         """
+        if 'argument' in script and element is None:
+            raise InvalidScriptWithElement('Script contains "argument" but no element was provided')
+
         if element:
-            script = script.replace('argument', 'this')
-            script = f'function(){{ {script} }}'
-            object_id = element._object_id
-            command = RuntimeCommands.call_function_on(
-                object_id=object_id, function_declaration=script, return_by_value=True
-            )
-        else:
-            command = RuntimeCommands.evaluate(expression=script)
-        return await self._execute_command(command)
+            return await self._execute_script_with_element(script, element)
+
+        return await self._execute_script_without_element(script)
 
     @asynccontextmanager
     async def expect_file_chooser(
@@ -616,7 +672,12 @@ class Tab(FindElementsMixin):  # noqa: PLR0904
             if not _before_page_events_enabled:
                 await self.disable_page_events()
 
-    async def on(self, event_name: str, callback: Callable[[dict], Any], temporary: bool = False):
+    async def on(
+        self,
+        event_name: str,
+        callback: Callable[[dict], Any],
+        temporary: bool = False,
+    ) -> int:
         """
         Register CDP event listener.
 
@@ -646,6 +707,46 @@ class Tab(FindElementsMixin):  # noqa: PLR0904
             event_name, function_to_register, temporary
         )
 
+    async def _execute_script_with_element(self, script: str, element: WebElement):
+        """
+        Execute script with element context.
+
+        Args:
+            script: JavaScript code to execute.
+            element: Element context (use 'argument' in script to reference).
+
+        Returns:
+            The result of the script execution.
+        """
+        if 'argument' not in script:
+            raise InvalidScriptWithElement('Script does not contain "argument"')
+
+        script = script.replace('argument', 'this')
+
+        if not is_script_already_function(script):
+            script = f'function(){{ {script} }}'
+
+        command = RuntimeCommands.call_function_on(
+            object_id=element._object_id, function_declaration=script, return_by_value=True
+        )
+        return await self._execute_command(command)
+
+    async def _execute_script_without_element(self, script: str):
+        """
+        Execute script without element context.
+
+        Args:
+            script: JavaScript code to execute.
+
+        Returns:
+            The result of the script execution.
+        """
+        if has_return_outside_function(script):
+            script = f'(function(){{ {script} }})()'
+
+        command = RuntimeCommands.evaluate(expression=script)
+        return await self._execute_command(command)
+
     async def _refresh_if_url_not_changed(self, url: str) -> bool:
         """Refresh page if URL hasn't changed."""
         current_url = await self.current_url

{pydoll_python-2.0.1 → pydoll_python-2.1.0}/pydoll/constants.py

@@ -913,3 +913,63 @@ class DialogType(str, Enum):
     CONFIRM = 'confirm'
     PROMPT = 'prompt'
     BEFORE_UNLOAD = 'beforeunload'
+
+
+class InitiatorType(str, Enum):
+    PARSER = 'parser'
+    SCRIPT = 'script'
+    PRELOAD = 'preload'
+    SIGNED_EXCHANGE = 'SignedExchange'
+    PREFLIGHT = 'preflight'
+    OTHER = 'other'
+
+
+class NetworkServiceWorkerRouterSourceType(str, Enum):
+    """Network service worker router source types."""
+
+    NETWORK = 'network'
+    CACHE = 'cache'
+    FETCH_EVENT = 'fetch-event'
+    RACE_NETWORK = 'race-network'
+    RACE_NETWORK_AND_FETCH_HANDLER = 'race-network-and-fetch-handler'
+    RACE_NETWORK_AND_CACHE = 'race-network-and-cache'
+
+
+class NetworkServiceWorkerResponseSource(str, Enum):
+    """Network service worker response source types."""
+
+    CACHE_STORAGE = 'cache-storage'
+    HTTP_CACHE = 'http-cache'
+    FALLBACK_CODE = 'fallback-code'
+    NETWORK = 'network'
+
+
+class AlternateProtocolUsage(str, Enum):
+    """Alternate protocol usage types."""
+
+    ALTERNATIVE_JOB_WON_WITHOUT_RACE = 'alternativeJobWonWithoutRace'
+    ALTERNATIVE_JOB_WON_RACE = 'alternativeJobWonRace'
+    MAIN_JOB_WON_RACE = 'mainJobWonRace'
+    MAPPING_MISSING = 'mappingMissing'
+    BROKEN = 'broken'
+    DNS_ALPN_H3_JOB_WON_WITHOUT_RACE = 'dnsAlpnH3JobWonWithoutRace'
+    DNS_ALPN_H3_JOB_WON_RACE = 'dnsAlpnH3JobWonRace'
+    UNSPECIFIED_REASON = 'unspecifiedReason'
+
+
+class SecurityState(str, Enum):
+    """Security state types."""
+
+    UNKNOWN = 'unknown'
+    NEUTRAL = 'neutral'
+    INSECURE = 'insecure'
+    INFO = 'info'
+    INSECURE_BROKEN = 'insecure-broken'
+
+
+class CertificateTransparencyCompliance(str, Enum):
+    """Certificate transparency compliance types."""
+
+    UNKNOWN = 'unknown'
+    NOT_COMPLIANT = 'not-compliant'
+    COMPLIANT = 'compliant'

{pydoll_python-2.0.1 → pydoll_python-2.1.0}/pydoll/elements/web_element.py

@@ -287,6 +287,7 @@ class WebElement(FindElementsMixin):  # noqa: PLR0904
 
         More realistic than insert_text() but slower.
         """
+        await self.click()
         for char in text:
             await self._execute_command(
                 InputCommands.dispatch_key_event(

{pydoll_python-2.0.1 → pydoll_python-2.1.0}/pydoll/exceptions.py

@@ -233,3 +233,21 @@ class IFrameNotFound(PydollException):
     """Raised when an iframe is not found."""
 
     message = 'The iframe was not found'
+
+
+class NetworkEventsNotEnabled(PydollException):
+    """Raised when network events are not enabled."""
+
+    message = 'Network events not enabled'
+
+
+class ScriptException(PydollException):
+    """Base class for exceptions related to JavaScript execution."""
+
+    message = 'A script execution error occurred'
+
+
+class InvalidScriptWithElement(ScriptException):
+    """Raised when a script contains 'argument' but no element is provided."""
+
+    message = 'Script contains "argument" but no element was provided'

{pydoll_python-2.0.1 → pydoll_python-2.1.0}/pydoll/protocol/network/types.py

@@ -1,16 +1,24 @@
 from typing import NotRequired, TypedDict
 
 from pydoll.constants import (
+    AlternateProtocolUsage,
+    CertificateTransparencyCompliance,
     ContentSecurityPolicySource,
     CookiePriority,
     CookieSameSite,
     CookieSourceScheme,
+    InitiatorType,
     MixedContentType,
+    NetworkServiceWorkerResponseSource,
+    NetworkServiceWorkerRouterSourceType,
     ReferrerPolicy,
     RefreshPolicy,
     ResourcePriority,
+    ResourceType,
+    SecurityState,
     TrustTokenOperationType,
 )
+from pydoll.protocol.runtime.types import StackTrace
 
 
 class SearchMatch(TypedDict):
@@ -150,3 +158,131 @@ class RequestPausedEventParams(TypedDict):
 class RequestPausedEvent(TypedDict):
     method: str
     params: RequestPausedEventParams
+
+
+class Initiator(TypedDict):
+    type: InitiatorType
+    stack: NotRequired[StackTrace]
+    url: NotRequired[str]
+    lineNumber: NotRequired[int]
+    columnNumber: NotRequired[int]
+    requestId: NotRequired[str]
+
+
+class ServiceWorkerRouterInfo(TypedDict):
+    """Service worker router info object."""
+
+    ruleIdMatched: NotRequired[int]
+    matchedSourceType: NotRequired[NetworkServiceWorkerRouterSourceType]
+    actualSourceType: NotRequired[NetworkServiceWorkerRouterSourceType]
+
+
+class ResourceTiming(TypedDict):
+    """Resource timing object."""
+
+    requestTime: float
+    proxyStart: float
+    proxyEnd: float
+    dnsStart: float
+    dnsEnd: float
+    connectStart: float
+    connectEnd: float
+    sslStart: float
+    sslEnd: float
+    workerStart: float
+    workerReady: float
+    workerFetchStart: float
+    workerRespondWithSettled: float
+    workerRouterEvaluationStart: NotRequired[float]
+    workerCacheLookupStart: NotRequired[float]
+    sendStart: float
+    sendEnd: float
+    pushStart: float
+    pushEnd: float
+    receiveHeadersStart: float
+    receiveHeadersEnd: float
+
+
+class SignedCertificateTimestamp(TypedDict):
+    """Signed certificate timestamp object."""
+
+    status: str
+    origin: str
+    logDescription: str
+    logId: str
+    timestamp: float
+    hashAlgorithm: str
+    signatureAlgorithm: str
+    signatureData: str
+
+
+class SecurityDetails(TypedDict):
+    """Security details object."""
+
+    protocol: str
+    keyExchange: str
+    keyExchangeGroup: NotRequired[str]
+    cipher: str
+    mac: NotRequired[str]
+    certificateId: int
+    subjectName: str
+    sanList: list[str]
+    issuer: str
+    validFrom: float
+    validTo: float
+    signedCertificateTimestampList: list[SignedCertificateTimestamp]
+    certificateTransparencyCompliance: CertificateTransparencyCompliance
+    serverSignatureAlgorithm: NotRequired[int]
+    encryptedClientHello: bool
+
+
+class Response(TypedDict):
+    url: str
+    status: int
+    statusText: str
+    headers: list[dict]
+    headersText: NotRequired[str]
+    mimeType: str
+    charset: str
+    requestHeaders: NotRequired[list[dict]]
+    requestHeadersText: NotRequired[str]
+    connectionReused: bool
+    connectionId: float
+    remoteIPAddress: NotRequired[str]
+    remotePort: NotRequired[int]
+    fromDiskCache: NotRequired[bool]
+    fromServiceWorker: NotRequired[bool]
+    fromPrefetchCache: NotRequired[bool]
+    fromEarlyHints: NotRequired[bool]
+    serviceWorkerRouterInfo: NotRequired[ServiceWorkerRouterInfo]
+    encodedDataLength: float
+    timing: NotRequired[ResourceTiming]
+    serviceWorkerResponseSource: NotRequired[NetworkServiceWorkerResponseSource]
+    responseTime: NotRequired[float]
+    cacheStorageCacheName: NotRequired[str]
+    protocol: NotRequired[str]
+    alternateProtocolUsage: NotRequired[AlternateProtocolUsage]
+    securityState: SecurityState
+    securityDetails: NotRequired[SecurityDetails]
+
+
+class NetworkLogParams(TypedDict):
+    requestId: str
+    loaderId: str
+    documentURL: str
+    request: Request
+    timestamp: float
+    wallTime: float
+    initiator: Initiator
+    redirectHasExtraInfo: bool
+    redirectResponse: NotRequired[Response]
+    type: NotRequired[ResourceType]
+    frameId: NotRequired[str]
+    hasUserGesture: NotRequired[bool]
+
+
+class NetworkLog(TypedDict):
+    """Network log object."""
+
+    method: str
+    params: RequestPausedEventParams

pydoll_python-2.1.0/pydoll/utils.py

@@ -0,0 +1,166 @@
+import base64
+import logging
+import os
+import re
+
+import aiohttp
+
+from pydoll.exceptions import InvalidBrowserPath, InvalidResponse, NetworkError
+
+logger = logging.getLogger(__name__)
+
+
+def decode_base64_to_bytes(image: str) -> bytes:
+    """
+    Decodes a base64 image string to bytes.
+
+    Args:
+        image (str): The base64 image string to decode.
+
+    Returns:
+        bytes: The decoded image as bytes.
+    """
+    return base64.b64decode(image.encode('utf-8'))
+
+
+async def get_browser_ws_address(port: int) -> str:
+    """
+    Fetches the WebSocket address for the browser instance.
+
+    Returns:
+        str: The WebSocket address for the browser.
+
+    Raises:
+        NetworkError: If the address cannot be fetched due to network errors
+            or missing data.
+        InvalidResponse: If the response is not valid JSON.
+    """
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f'http://localhost:{port}/json/version') as response:
+                response.raise_for_status()
+                data = await response.json()
+                return data['webSocketDebuggerUrl']
+
+    except aiohttp.ClientError as e:
+        raise NetworkError(f'Failed to get browser ws address: {e}')
+
+    except KeyError as e:
+        raise InvalidResponse(f'Failed to get browser ws address: {e}')
+
+
+def validate_browser_paths(paths: list[str]) -> str:
+    """
+    Validates potential browser executable paths and returns the first valid one.
+
+    Checks a list of possible browser binary locations to find an existing,
+    executable browser. This is used by browser-specific subclasses to locate
+    the browser executable when no explicit binary path is provided.
+
+    Args:
+        paths: List of potential file paths to check for the browser executable.
+            These should be absolute paths appropriate for the current OS.
+
+    Returns:
+        str: The first valid browser executable path found.
+
+    Raises:
+        InvalidBrowserPath: If the browser executable is not found at the path.
+    """
+    for path in paths:
+        if os.path.exists(path) and os.access(path, os.X_OK):
+            return path
+    raise InvalidBrowserPath(f'No valid browser path found in: {paths}')
+
+
+def clean_script_for_analysis(script: str) -> str:
+    """
+    Clean JavaScript code by removing comments and string literals.
+
+    This helps avoid false positives when analyzing script structure.
+
+    Args:
+        script: JavaScript code to clean.
+
+    Returns:
+        str: Cleaned script with comments and strings removed.
+    """
+    # Remove line comments
+    cleaned = re.sub(r'//.*?$', '', script, flags=re.MULTILINE)
+    # Remove block comments
+    cleaned = re.sub(r'/\*.*?\*/', '', cleaned, flags=re.DOTALL)
+    # Remove double quoted strings
+    cleaned = re.sub(r'"[^"]*"', '""', cleaned)
+    # Remove single quoted strings
+    cleaned = re.sub(r"'[^']*'", "''", cleaned)
+    # Remove template literals
+    cleaned = re.sub(r'`[^`]*`', '``', cleaned)
+
+    return cleaned
+
+
+def is_script_already_function(script: str) -> bool:
+    """
+    Check if a JavaScript script is already wrapped in a function.
+
+    Args:
+        script: JavaScript code to analyze.
+
+    Returns:
+        bool: True if script is already a function, False otherwise.
+    """
+    cleaned_script = clean_script_for_analysis(script)
+
+    function_pattern = r'^\s*function\s*\([^)]*\)\s*\{'
+    arrow_function_pattern = r'^\s*\([^)]*\)\s*=>\s*\{'
+
+    return bool(
+        re.match(function_pattern, cleaned_script.strip())
+        or re.match(arrow_function_pattern, cleaned_script.strip())
+    )
+
+
+def has_return_outside_function(script: str) -> bool:
+    """
+    Check if a JavaScript script has return statements outside of functions.
+
+    Args:
+        script: JavaScript code to analyze.
+
+    Returns:
+        bool: True if script has return outside function, False otherwise.
+    """
+    cleaned_script = clean_script_for_analysis(script)
+
+    # If already a function, no need to check
+    if is_script_already_function(cleaned_script):
+        return False
+
+    # Look for 'return' statements
+    return_pattern = r'\breturn\b'
+    if not re.search(return_pattern, cleaned_script):
+        return False
+
+    # Check if return is inside a function by counting braces
+    lines = cleaned_script.split('\n')
+    brace_count = 0
+    in_function = False
+
+    for line in lines:
+        # Check for function declarations
+        if re.search(r'\bfunction\b', line) or re.search(r'=>', line):
+            in_function = True
+
+        # Count braces
+        brace_count += line.count('{') - line.count('}')
+
+        # Check for return statement
+        if re.search(return_pattern, line):
+            if not in_function or brace_count <= 0:
+                return True
+
+        # Reset function flag if we're back to top level
+        if brace_count <= 0:
+            in_function = False
+
+    return False

{pydoll_python-2.0.1 → pydoll_python-2.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pydoll-python"
-version = "2.0.1"
+version = "2.1.0"
 description = ""
 authors = ["Thalison Fernandes <thalissfernandes99@gmail.com>"]
 readme = "README.md"

pydoll_python-2.0.1/pydoll/utils.py

@@ -1,72 +0,0 @@
-import base64
-import logging
-import os
-
-import aiohttp
-
-from pydoll.exceptions import InvalidBrowserPath, InvalidResponse, NetworkError
-
-logger = logging.getLogger(__name__)
-
-
-def decode_base64_to_bytes(image: str) -> bytes:
-    """
-    Decodes a base64 image string to bytes.
-
-    Args:
-        image (str): The base64 image string to decode.
-
-    Returns:
-        bytes: The decoded image as bytes.
-    """
-    return base64.b64decode(image.encode('utf-8'))
-
-
-async def get_browser_ws_address(port: int) -> str:
-    """
-    Fetches the WebSocket address for the browser instance.
-
-    Returns:
-        str: The WebSocket address for the browser.
-
-    Raises:
-        NetworkError: If the address cannot be fetched due to network errors
-            or missing data.
-        InvalidResponse: If the response is not valid JSON.
-    """
-    try:
-        async with aiohttp.ClientSession() as session:
-            async with session.get(f'http://localhost:{port}/json/version') as response:
-                response.raise_for_status()
-                data = await response.json()
-                return data['webSocketDebuggerUrl']
-
-    except aiohttp.ClientError as e:
-        raise NetworkError(f'Failed to get browser ws address: {e}')
-
-    except KeyError as e:
-        raise InvalidResponse(f'Failed to get browser ws address: {e}')
-
-
-def validate_browser_paths(paths: list[str]) -> str:
-    """
-    Validates potential browser executable paths and returns the first valid one.
-
-    Checks a list of possible browser binary locations to find an existing,
-    executable browser. This is used by browser-specific subclasses to locate
-    the browser executable when no explicit binary path is provided.
-
-    Args:
-        paths: List of potential file paths to check for the browser executable.
-            These should be absolute paths appropriate for the current OS.
-
-    Returns:
-        str: The first valid browser executable path found.
-
-    Raises:
-        InvalidBrowserPath: If the browser executable is not found at the path.
-    """
-    for path in paths:
-        if os.path.exists(path) and os.access(path, os.X_OK):
-            return path
-    raise InvalidBrowserPath(f'No valid browser path found in: {paths}')