camoufox 0.3.8__py3-none-any.whl

camoufox/__init__.py

@@ -0,0 +1,13 @@
+from .addons import DefaultAddons
+from .async_api import AsyncCamoufox, AsyncNewBrowser
+from .sync_api import Camoufox, NewBrowser
+from .utils import launch_options
+
+__all__ = [
+    "Camoufox",
+    "NewBrowser",
+    "AsyncCamoufox",
+    "AsyncNewBrowser",
+    "DefaultAddons",
+    "launch_options",
+]

camoufox/__main__.py

@@ -0,0 +1,172 @@
+"""
+CLI package manager for Camoufox.
+
+Adapted from https://github.com/daijro/hrequests/blob/main/hrequests/__main__.py
+"""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as pkg_version
+from os import environ
+from typing import Optional
+
+import click
+
+from .addons import DefaultAddons
+from .locale import ALLOW_GEOIP, download_mmdb, remove_mmdb
+from .pkgman import INSTALL_DIR, CamoufoxFetcher, installed_verstr, rprint
+from .xpi_dl import maybe_download_addons
+
+try:
+    from browserforge.download import download as update_browserforge
+except ImportError:
+    # Account for other Browserforge versions
+    from browserforge.download import Download as update_browserforge
+
+
+class CamoufoxUpdate(CamoufoxFetcher):
+    """
+    Checks & updates Camoufox
+    """
+
+    def __init__(self) -> None:
+        """
+        Initializes the CamoufoxUpdate class
+        """
+        super().__init__()
+        self.current_verstr: Optional[str]
+        try:
+            self.current_verstr = installed_verstr()
+        except FileNotFoundError:
+            self.current_verstr = None
+
+    def is_updated_needed(self) -> bool:
+        # Camoufox is not installed
+        if self.current_verstr is None:
+            return True
+        # If the installed version is not the latest version
+        if self.current_verstr != self.verstr:
+            return True
+        return False
+
+    def update(self) -> None:
+        """
+        Updates Camoufox if needed
+        """
+        # Check if the version is the same as the latest available version
+        if not self.is_updated_needed():
+            rprint("Camoufox binaries up to date!", fg="green")
+            rprint(f"Current version: v{self.current_verstr}", fg="green")
+            return
+
+        # Download updated file
+        if self.current_verstr is not None:
+            # Display an updating message
+            rprint(
+                f"Updating Camoufox binaries from v{self.current_verstr} => v{self.verstr}",
+                fg="yellow",
+            )
+        else:
+            rprint(f"Fetching Camoufox binaries v{self.verstr}...", fg="yellow")
+        # Install the new version
+        self.install()
+
+
+@click.group()
+def cli() -> None:
+    pass
+
+
+@cli.command(name='fetch')
+@click.option(
+    '--browserforge', is_flag=True, help='Update browserforge\'s header and fingerprint definitions'
+)
+def fetch(browserforge=False) -> None:
+    """
+    Fetch the latest version of Camoufox and optionally update Browserforge's database
+    """
+    CamoufoxUpdate().update()
+    # Fetch the GeoIP database
+    if ALLOW_GEOIP:
+        download_mmdb()
+
+    # Download default addons
+    maybe_download_addons(list(DefaultAddons))
+
+    if browserforge:
+        update_browserforge(headers=True, fingerprints=True)
+
+
+@cli.command(name='remove')
+def remove() -> None:
+    """
+    Remove all downloaded files
+    """
+    if not CamoufoxUpdate().cleanup():
+        rprint("Camoufox binaries not found!", fg="red")
+    # Remove the GeoIP database
+    remove_mmdb()
+
+
+@cli.command(name='test')
+@click.argument('url', default=None, required=False)
+def test(url: Optional[str] = None) -> None:
+    """
+    Open the Playwright inspector
+    """
+    from .sync_api import Camoufox
+
+    with Camoufox(headless=False, env=environ) as browser:
+        page = browser.new_page()
+        if url:
+            page.goto(url)
+        page.pause()  # Open the Playwright inspector
+
+
+@cli.command(name='server')
+def server() -> None:
+    """
+    Launch a Playwright server
+    """
+    from .server import launch_server
+
+    launch_server()
+
+
+@cli.command(name='path')
+def path() -> None:
+    """
+    Display the path to the Camoufox executable
+    """
+    rprint(INSTALL_DIR, fg="green")
+
+
+@cli.command(name='version')
+def version() -> None:
+    """
+    Display the current version
+    """
+    # python package version
+    try:
+        rprint(f"Pip package:\tv{pkg_version('camoufox')}", fg="green")
+    except PackageNotFoundError:
+        rprint("Pip package:\tNot installed!", fg="red")
+
+    updater = CamoufoxUpdate()
+    bin_ver = updater.current_verstr
+
+    # If binaries are not downloaded
+    if not bin_ver:
+        rprint("Camoufox:\tNot downloaded!", fg="red")
+        return
+    # Print the base version
+    rprint(f"Camoufox:\tv{bin_ver} ", fg="green", nl=False)
+
+    # Check for Camoufox updates
+    if updater.is_updated_needed():
+        rprint(f"(Latest supported: v{updater.verstr})", fg="red")
+    else:
+        rprint("(Up to date!)", fg="yellow")
+
+
+if __name__ == '__main__':
+    cli()

camoufox/__version__.py

@@ -0,0 +1,19 @@
+"""
+Camoufox version constants.
+"""
+
+
+class CONSTRAINTS:
+    """
+    The minimum and maximum supported versions of the Camoufox browser.
+    """
+
+    MIN_VERSION = 'beta.12'
+    MAX_VERSION = '1'
+
+    @staticmethod
+    def as_range() -> str:
+        """
+        Returns the version range as a string.
+        """
+        return f">={CONSTRAINTS.MIN_VERSION}, <{CONSTRAINTS.MAX_VERSION}"

camoufox/addons.py

@@ -0,0 +1,189 @@
+import asyncio
+import os
+import socket
+import threading
+import time
+from enum import Enum
+from typing import List
+
+import orjson
+
+from .exceptions import InvalidAddonPath, InvalidDebugPort, MissingDebugPort
+
+
+class DefaultAddons(Enum):
+    """
+    Default addons to be downloaded
+    """
+
+    UBO = "https://addons.mozilla.org/firefox/downloads/latest/ublock-origin/latest.xpi"
+    # Disable by default. Not always necessary, and increases the memory footprint of Camoufox.
+    # BPC = "https://gitflic.ru/project/magnolia1234/bpc_uploads/blob/raw?file=bypass_paywalls_clean-latest.xpi"
+
+
+def get_debug_port(args: List[str]) -> int:
+    """
+    Gets the debug port from the args, or creates a new one if not provided
+    """
+    for i, arg in enumerate(args):
+        # Search for debugger server port
+        if arg == "-start-debugger-server":
+            # If arg is found but no port is provided, raise an error
+            if i + 1 >= len(args):
+                raise MissingDebugPort(f"No debug port provided: {args}")
+            debug_port = args[i + 1]
+            # Try to parse the debug port as an integer
+            try:
+                return int(debug_port)
+            except ValueError as e:
+                raise InvalidDebugPort(
+                    f"Error parsing debug port. Must be an integer: {debug_port}"
+                ) from e
+
+    # Create new debugger server port
+    debug_port_int = get_open_port()
+    # Add -start-debugger-server {debug_port} to args
+    args.extend(["-start-debugger-server", str(debug_port_int)])
+
+    return debug_port_int
+
+
+def confirm_paths(paths: List[str]) -> None:
+    """
+    Confirms that the addon paths are valid
+    """
+    for path in paths:
+        if not os.path.isdir(path):
+            raise InvalidAddonPath(path)
+        if not os.path.exists(os.path.join(path, 'manifest.json')):
+            raise InvalidAddonPath(
+                'manifest.json is missing. Addon path must be a path to an extracted addon.'
+            )
+
+
+def get_open_port() -> int:
+    """
+    Gets an open port
+    """
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(('localhost', 0))
+        return s.getsockname()[1]
+
+
+def threaded_try_load_addons(debug_port_int: int, addons_list: List[str]) -> None:
+    """
+    Tries to load addons (in a separate thread)
+    """
+    thread = threading.Thread(
+        target=try_load_addons, args=(debug_port_int, addons_list), daemon=True
+    )
+    thread.start()
+
+
+def try_load_addons(debug_port_int: int, addons_list: List[str]) -> None:
+    """
+    Tries to load addons
+    """
+    # Wait for the server to be open
+    while True:
+        try:
+            with socket.create_connection(("localhost", debug_port_int)):
+                break
+        except ConnectionRefusedError:
+            time.sleep(0.05)
+
+    # Load addons
+    asyncio.run(load_all_addons(debug_port_int, addons_list))
+
+
+async def load_all_addons(debug_port_int: int, addons_list: List[str]) -> None:
+    """
+    Loads all addons
+    """
+    addon_loaders = [LoadFirefoxAddon(debug_port_int, addon) for addon in addons_list]
+    await asyncio.gather(*[addon_loader.load() for addon_loader in addon_loaders])
+
+
+class LoadFirefoxAddon:
+    '''
+    Firefox addon loader
+    https://github.com/daijro/hrequests/blob/main/hrequests/extensions.py#L95
+    '''
+
+    def __init__(self, port, addon_path):
+        self.port: int = port
+        self.addon_path: str = addon_path
+        self.success: bool = False
+        self.buffers: list = []
+        self.remaining_bytes: int = 0
+
+    async def load(self):
+        reader, writer = await asyncio.open_connection('localhost', self.port)
+        writer.write(self._format_message({"to": "root", "type": "getRoot"}))
+        await writer.drain()
+
+        while True:
+            data = await reader.read(100)  # Adjust buffer size as needed
+            if not data:
+                break
+            await self._process_data(writer, data)
+
+        writer.close()
+        await writer.wait_closed()
+        return self.success
+
+    async def _process_data(self, writer, data):
+        while data:
+            if self.remaining_bytes == 0:
+                index = data.find(b':')
+                if index == -1:
+                    self.buffers.append(data)
+                    return
+
+                total_data = b''.join(self.buffers) + data
+                size, _, remainder = total_data.partition(b':')
+
+                try:
+                    self.remaining_bytes = int(size)
+                except ValueError as e:
+                    raise ValueError("Invalid state") from e
+
+                data = remainder
+
+            if len(data) < self.remaining_bytes:
+                self.remaining_bytes -= len(data)
+                self.buffers.append(data)
+                return
+            else:
+                self.buffers.append(data[: self.remaining_bytes])
+                message = orjson.loads(b''.join(self.buffers))
+                self.buffers.clear()
+
+                await self._on_message(writer, message)
+
+                data = data[self.remaining_bytes :]
+                self.remaining_bytes = 0
+
+    async def _on_message(self, writer, message):
+        if "addonsActor" in message:
+            writer.write(
+                self._format_message(
+                    {
+                        "to": message["addonsActor"],
+                        "type": "installTemporaryAddon",
+                        "addonPath": self.addon_path,
+                    }
+                )
+            )
+            await writer.drain()
+
+        if "addon" in message:
+            self.success = True
+            writer.write_eof()
+
+        if "error" in message:
+            writer.write_eof()
+
+    def _format_message(self, data):
+        raw = orjson.dumps(data)
+        return f"{len(raw)}:".encode() + raw

camoufox/async_api.py

@@ -0,0 +1,94 @@
+from typing import Any, Dict, Optional, Union, overload
+
+from playwright.async_api import (
+    Browser,
+    BrowserContext,
+    Playwright,
+    PlaywrightContextManager,
+)
+from typing_extensions import Literal
+
+from camoufox.virtdisplay import VirtualDisplay
+
+from .utils import async_attach_vd, launch_options
+
+
+class AsyncCamoufox(PlaywrightContextManager):
+    """
+    Wrapper around playwright.async_api.PlaywrightContextManager that automatically
+    launches a browser and closes it when the context manager is exited.
+    """
+
+    def __init__(self, **launch_options):
+        super().__init__()
+        self.launch_options = launch_options
+        self.browser: Optional[Union[Browser, BrowserContext]] = None
+
+    async def __aenter__(self) -> Union[Browser, BrowserContext]:
+        _playwright = await super().__aenter__()
+        self.browser = await AsyncNewBrowser(_playwright, **self.launch_options)
+        return self.browser
+
+    async def __aexit__(self, *args: Any):
+        if self.browser:
+            await self.browser.close()
+        await super().__aexit__(*args)
+
+
+@overload
+async def AsyncNewBrowser(
+    playwright: Playwright,
+    *,
+    from_options: Optional[Dict[str, Any]] = None,
+    persistent_context: Literal[False] = False,
+    **kwargs,
+) -> Browser: ...
+
+
+@overload
+async def AsyncNewBrowser(
+    playwright: Playwright,
+    *,
+    from_options: Optional[Dict[str, Any]] = None,
+    persistent_context: Literal[True],
+    **kwargs,
+) -> BrowserContext: ...
+
+
+async def AsyncNewBrowser(
+    playwright: Playwright,
+    *,
+    headless: Optional[Union[bool, Literal['virtual']]] = None,
+    from_options: Optional[Dict[str, Any]] = None,
+    persistent_context: bool = False,
+    debug: Optional[bool] = None,
+    **kwargs,
+) -> Union[Browser, BrowserContext]:
+    """
+    Launches a new browser instance for Camoufox given a set of launch options.
+
+    Parameters:
+        from_options (Dict[str, Any]):
+            A set of launch options generated by `launch_options()` to use
+        persistent_context (bool):
+            Whether to use a persistent context.
+        **kwargs:
+            All other keyword arugments passed to `launch_options()`.
+    """
+    if headless == 'virtual':
+        virtual_display = VirtualDisplay(debug=debug)
+        kwargs['virtual_display'] = virtual_display.get()
+        headless = False
+    else:
+        virtual_display = None
+
+    opt = from_options or launch_options(headless=headless, debug=debug, **kwargs)
+
+    # Persistent context
+    if persistent_context:
+        context = await playwright.firefox.launch_persistent_context(**opt)
+        return await async_attach_vd(context, virtual_display)
+
+    # Browser
+    browser = await playwright.firefox.launch(**opt)
+    return await async_attach_vd(browser, virtual_display)

camoufox/browserforge.yml

@@ -0,0 +1,67 @@
+# Mappings of Browserforge fingerprints to Camoufox config properties.
+
+navigator:
+  # Note: Browserforge tends to have outdated UAs.
+  # The version will be replaced in Camoufox.
+  userAgent: navigator.userAgent
+  # userAgentData not in Firefox
+  doNotTrack: navigator.doNotTrack
+  appCodeName: navigator.appCodeName
+  appName: navigator.appName
+  appVersion: navigator.appVersion
+  oscpu: navigator.oscpu
+  # webdriver is always True
+  # Locale is now implemented separately:
+  #   language: navigator.language
+  #   languages: navigator.languages
+  platform: navigator.platform
+  # deviceMemory not in Firefox
+  hardwareConcurrency: navigator.hardwareConcurrency
+  product: navigator.product
+  productSub: navigator.productSub
+  # vendor is not necessary
+  # vendorSub is not necessary
+  maxTouchPoints: navigator.maxTouchPoints
+  extraProperties:
+    # Note: Changing pdfViewerEnabled is not recommended. This will be kept to True.
+    globalPrivacyControl: navigator.globalPrivacyControl
+
+screen:
+  # hasHDR is not implemented in Camoufox
+  availLeft: screen.availLeft
+  availTop: screen.availTop
+  availWidth: screen.availWidth
+  availHeight: screen.availHeight
+  height: screen.height
+  width: screen.width
+  colorDepth: screen.colorDepth
+  pixelDepth: screen.pixelDepth
+  # devicePixelRatio is not recommended. Any value other than 1.0 is suspicious.
+  pageXOffset: screen.pageXOffset
+  pageYOffset: screen.pageYOffset
+  outerHeight: window.outerHeight
+  outerWidth: window.outerWidth
+  innerHeight: window.innerHeight
+  innerWidth: window.innerWidth
+  screenX: window.screenX
+  screenY: window.screenY
+  # Tends to generate out of bounds (network inconsistencies):
+  #   clientWidth: document.body.clientWidth
+  #   clientHeight: document.body.clientHeight
+
+# videoCard:
+#  renderer: webgl:renderer
+#  vendor: webgl:vendor
+
+headers:
+  # headers.User-Agent is redundant with navigator.userAgent
+  # headers.Accept-Language is redundant with locale:*
+  Accept-Encoding: headers.Accept-Encoding
+
+battery:
+  charging: battery:charging
+  chargingTime: battery:chargingTime
+  dischargingTime: battery:dischargingTime
+
+# Unsupported: videoCodecs, audioCodecs, pluginsData, multimediaDevices
+# Fonts are listed through the launcher.