lumivor 0.1.7__py3-none-any.whl

lumivor/dom/tests/extraction_test.py

@@ -0,0 +1,44 @@
+import time
+
+from tokencost import count_string_tokens
+
+from lumivor.browser.browser import Browser, BrowserConfig
+
+# from lumivor.browser.service import Browser
+from lumivor.dom.service import DomService
+from lumivor.utils import time_execution_sync
+
+
+# @pytest.mark.skip("slow af")
+async def test_process_html_file():
+    browser = Browser(config=BrowserConfig(headless=False))
+
+    async with await browser.new_context() as context:
+        page = await context.get_current_page()
+
+        dom_service = DomService(page)
+
+        # await page.goto('https://kayak.com/flights')
+        # browser.go_to_url('https://google.com/flights')
+        await page.goto('https://immobilienscout24.de')
+
+        time.sleep(3)
+        # browser._click_element_by_xpath(
+        # 	'/html/body/div[5]/div/div[2]/div/div/div[3]/div/div[1]/button[1]'
+        # )
+        # browser._click_element_by_xpath("//button[div/div[text()='Alle akzeptieren']]")
+
+        dom_state = await time_execution_sync('get_clickable_elements')(
+            dom_service.get_clickable_elements
+        )()
+        elements = dom_state.element_tree
+        selector_map = dom_state.selector_map
+
+        print(elements.clickable_elements_to_string())
+        print(
+            'Tokens:', count_string_tokens(
+                elements.clickable_elements_to_string(), model='gpt-4o')
+        )
+        print(len(selector_map.keys()), 'elements highlighted')
+
+        input('Press Enter to continue...')

lumivor/dom/tests/process_dom_test.py

@@ -0,0 +1,40 @@
+import json
+import os
+import time
+
+from lumivor.browser.browser import Browser, BrowserConfig
+
+
+async def test_process_dom():
+    browser = Browser(config=BrowserConfig(headless=False))
+
+    async with await browser.new_context() as context:
+        page = await context.get_current_page()
+        await page.goto('https://kayak.com/flights')
+        # await page.goto('https://google.com/flights')
+        # await page.goto('https://immobilienscout24.de')
+        # await page.goto('https://seleniumbase.io/w3schools/iframes')
+
+        time.sleep(3)
+
+        with open('lumivor/dom/process_dom.js', 'r') as f:
+            js_code = f.read()
+
+        start = time.time()
+        dom_tree = await page.evaluate(js_code)
+        end = time.time()
+
+        # print(dom_tree)
+        print(f'Time: {end - start:.2f}s')
+
+        os.makedirs('./tmp', exist_ok=True)
+        with open('./tmp/dom.json', 'w') as f:
+            json.dump(dom_tree, f, indent=1)
+
+        # both of these work for immobilienscout24.de
+        # await page.click('.sc-dcJsrY.ezjNCe')
+        # await page.click(
+        # 	'div > div:nth-of-type(2) > div > div:nth-of-type(2) > div > div:nth-of-type(2) > div > div > div > button:nth-of-type(2)'
+        # )
+
+        input('Press Enter to continue...')

lumivor/dom/views.py

@@ -0,0 +1,187 @@
+from dataclasses import dataclass
+from functools import cached_property
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from lumivor.dom.history_tree_processor.view import HashedDomElement
+
+# Avoid circular import issues
+if TYPE_CHECKING:
+    from .views import DOMElementNode
+
+
+@dataclass(frozen=False)
+class DOMBaseNode:
+    is_visible: bool
+    # Use None as default and set parent later to avoid circular reference issues
+    parent: Optional['DOMElementNode']
+
+
+@dataclass(frozen=False)
+class DOMTextNode(DOMBaseNode):
+    text: str
+    type: str = 'TEXT_NODE'
+
+    def has_parent_with_highlight_index(self) -> bool:
+        current = self.parent
+        while current is not None:
+            if current.highlight_index is not None:
+                return True
+            current = current.parent
+        return False
+
+
+@dataclass(frozen=False)
+class DOMElementNode(DOMBaseNode):
+    """
+    xpath: the xpath of the element from the last root node (shadow root or iframe OR document if no shadow root or iframe).
+    To properly reference the element we need to recursively switch the root node until we find the element (work you way up the tree with `.parent`)
+    """
+
+    tag_name: str
+    xpath: str
+    attributes: Dict[str, str]
+    children: List[DOMBaseNode]
+    is_interactive: bool = False
+    is_top_element: bool = False
+    shadow_root: bool = False
+    highlight_index: Optional[int] = None
+
+    def __repr__(self) -> str:
+        tag_str = f'<{self.tag_name}'
+
+        # Add attributes
+        for key, value in self.attributes.items():
+            tag_str += f' {key}="{value}"'
+        tag_str += '>'
+
+        # Add extra info
+        extras = []
+        if self.is_interactive:
+            extras.append('interactive')
+        if self.is_top_element:
+            extras.append('top')
+        if self.shadow_root:
+            extras.append('shadow-root')
+        if self.highlight_index is not None:
+            extras.append(f'highlight:{self.highlight_index}')
+
+        if extras:
+            tag_str += f' [{", ".join(extras)}]'
+
+        return tag_str
+
+    @cached_property
+    def hash(self) -> HashedDomElement:
+        from lumivor.dom.history_tree_processor.service import (
+            HistoryTreeProcessor,
+        )
+
+        return HistoryTreeProcessor._hash_dom_element(self)
+
+    def get_all_text_till_next_clickable_element(self) -> str:
+        text_parts = []
+
+        def collect_text(node: DOMBaseNode) -> None:
+            # Skip this branch if we hit a highlighted element (except for the current node)
+            if (
+                    isinstance(node, DOMElementNode)
+                    and node != self
+                    and node.highlight_index is not None
+            ):
+                return
+
+            if isinstance(node, DOMTextNode):
+                text_parts.append(node.text)
+            elif isinstance(node, DOMElementNode):
+                for child in node.children:
+                    collect_text(child)
+
+        collect_text(self)
+        return '\n'.join(text_parts).strip()
+
+    def clickable_elements_to_string(self, include_attributes: list[str] = []) -> str:
+        """Convert the processed DOM content to HTML."""
+        formatted_text = []
+
+        def process_node(node: DOMBaseNode, depth: int) -> None:
+            if isinstance(node, DOMElementNode):
+                # Add element with highlight_index
+                if node.highlight_index is not None:
+                    attributes_str = ''
+                    if include_attributes:
+                        attributes_str = ' ' + ' '.join(
+                            f'{key}="{value}"'
+                            for key, value in node.attributes.items()
+                            if key in include_attributes
+                        )
+                    formatted_text.append(
+                        f'{node.highlight_index}[:]<{node.tag_name}{attributes_str}>{
+                            node.get_all_text_till_next_clickable_element()}</{node.tag_name}>'
+                    )
+
+                # Process children regardless
+                for child in node.children:
+                    process_node(child, depth + 1)
+
+            elif isinstance(node, DOMTextNode):
+                # Add text only if it doesn't have a highlighted parent
+                if not node.has_parent_with_highlight_index():
+                    formatted_text.append(f'_[:]{node.text}')
+
+        process_node(self, 0)
+        return '\n'.join(formatted_text)
+
+    def get_file_upload_element(self, check_siblings: bool = True) -> Optional['DOMElementNode']:
+        # Check if current element is a file input
+        if self.tag_name == 'input' and self.attributes.get('type') == 'file':
+            return self
+
+        # Check children
+        for child in self.children:
+            if isinstance(child, DOMElementNode):
+                result = child.get_file_upload_element(check_siblings=False)
+                if result:
+                    return result
+
+        # Check siblings only for the initial call
+        if check_siblings and self.parent:
+            for sibling in self.parent.children:
+                if sibling is not self and isinstance(sibling, DOMElementNode):
+                    result = sibling.get_file_upload_element(
+                        check_siblings=False)
+                    if result:
+                        return result
+
+        return None
+
+
+class ElementTreeSerializer:
+    @staticmethod
+    def serialize_clickable_elements(element_tree: DOMElementNode) -> str:
+        return element_tree.clickable_elements_to_string()
+
+    @staticmethod
+    def dom_element_node_to_json(element_tree: DOMElementNode) -> dict:
+        def node_to_dict(node: DOMBaseNode) -> dict:
+            if isinstance(node, DOMTextNode):
+                return {'type': 'text', 'text': node.text}
+            elif isinstance(node, DOMElementNode):
+                return {
+                    'type': 'element',
+                    'tag_name': node.tag_name,
+                    'attributes': node.attributes,
+                    'highlight_index': node.highlight_index,
+                    'children': [node_to_dict(child) for child in node.children],
+                }
+            return {}
+
+        return node_to_dict(element_tree)
+
+
+SelectorMap = dict[int, DOMElementNode]
+
+
+@dataclass
+class DOMState:
+    element_tree: DOMElementNode
+    selector_map: SelectorMap

lumivor/logging_config.py

@@ -0,0 +1,128 @@
+import logging
+import os
+import sys
+
+
+def addLoggingLevel(levelName, levelNum, methodName=None):
+    """
+    Comprehensively adds a new logging level to the `logging` module and the
+    currently configured logging class.
+
+    `levelName` becomes an attribute of the `logging` module with the value
+    `levelNum`. `methodName` becomes a convenience method for both `logging`
+    itself and the class returned by `logging.getLoggerClass()` (usually just
+    `logging.Logger`). If `methodName` is not specified, `levelName.lower()` is
+    used.
+
+    To avoid accidental clobberings of existing attributes, this method will
+    raise an `AttributeError` if the level name is already an attribute of the
+    `logging` module or if the method name is already present
+
+    Example
+    -------
+    >>> addLoggingLevel('TRACE', logging.DEBUG - 5)
+    >>> logging.getLogger(__name__).setLevel('TRACE')
+    >>> logging.getLogger(__name__).trace('that worked')
+    >>> logging.trace('so did this')
+    >>> logging.TRACE
+    5
+
+    """
+    if not methodName:
+        methodName = levelName.lower()
+
+    if hasattr(logging, levelName):
+        raise AttributeError(
+            '{} already defined in logging module'.format(levelName))
+    if hasattr(logging, methodName):
+        raise AttributeError(
+            '{} already defined in logging module'.format(methodName))
+    if hasattr(logging.getLoggerClass(), methodName):
+        raise AttributeError(
+            '{} already defined in logger class'.format(methodName))
+
+    # This method was inspired by the answers to Stack Overflow post
+    # http://stackoverflow.com/q/2183233/2988730, especially
+    # http://stackoverflow.com/a/13638084/2988730
+    def logForLevel(self, message, *args, **kwargs):
+        if self.isEnabledFor(levelNum):
+            self._log(levelNum, message, args, **kwargs)
+
+    def logToRoot(message, *args, **kwargs):
+        logging.log(levelNum, message, *args, **kwargs)
+
+    logging.addLevelName(levelNum, levelName)
+    setattr(logging, levelName, levelNum)
+    setattr(logging.getLoggerClass(), methodName, logForLevel)
+    setattr(logging, methodName, logToRoot)
+
+
+def setup_logging():
+    # Try to add RESULT level, but ignore if it already exists
+    try:
+        addLoggingLevel('RESULT', 35)  # This allows ERROR, FATAL and CRITICAL
+    except AttributeError:
+        pass  # Level already exists, which is fine
+
+    log_type = os.getenv('LUMIVOR_LOGGING_LEVEL', 'info').lower()
+
+    # Check if handlers are already set up
+    if logging.getLogger().hasHandlers():
+        return
+
+    # Clear existing handlers
+    root = logging.getLogger()
+    root.handlers = []
+
+    class BrowserUseFormatter(logging.Formatter):
+        def format(self, record):
+            if record.name.startswith('lumivor.'):
+                record.name = record.name.split('.')[-2]
+            return super().format(record)
+
+    # Setup single handler for all loggers
+    console = logging.StreamHandler(sys.stdout)
+
+    # adittional setLevel here to filter logs
+    if log_type == 'result':
+        console.setLevel('RESULT')
+        console.setFormatter(BrowserUseFormatter('%(message)s'))
+    else:
+        console.setFormatter(BrowserUseFormatter(
+            '%(levelname)-8s [%(name)s] %(message)s'))
+
+    # Configure root logger only
+    root.addHandler(console)
+
+    # switch cases for log_type
+    if log_type == 'result':
+        root.setLevel('RESULT')  # string usage to avoid syntax error
+    elif log_type == 'debug':
+        root.setLevel(logging.DEBUG)
+    else:
+        root.setLevel(logging.INFO)
+
+    # Configure lumivor logger
+    lumivor_logger = logging.getLogger('lumivor')
+    lumivor_logger.propagate = False  # Don't propagate to root logger
+    lumivor_logger.addHandler(console)
+    lumivor_logger.setLevel(root.level)  # Set same level as root logger
+
+    logger = logging.getLogger('lumivor')
+    logger.info('BrowserUse logging setup complete with level %s', log_type)
+    # Silence third-party loggers
+    for logger in [
+            'WDM',
+            'httpx',
+            'selenium',
+            'playwright',
+            'urllib3',
+            'asyncio',
+            'langchain',
+            'openai',
+            'httpcore',
+            'charset_normalizer',
+    ]:
+        third_party = logging.getLogger(logger)
+        third_party.setLevel(logging.ERROR)
+        third_party.propagate = False

lumivor/telemetry/service.py

@@ -0,0 +1,114 @@
+import logging
+import os
+import uuid
+from pathlib import Path
+
+from dotenv import load_dotenv
+from posthog import Posthog
+
+from lumivor.telemetry.views import BaseTelemetryEvent
+from lumivor.utils import singleton
+
+load_dotenv()
+
+
+logger = logging.getLogger(__name__)
+
+
+POSTHOG_EVENT_SETTINGS = {
+    'process_person_profile': True,
+    'geoip_city_name': None,
+    'geoip_country_name': None,
+    'geoip_country_code': None,
+    'geoip_continent_name': None,
+    'geoip_continent_code': None,
+    'geoip_time_zone': None,
+}
+
+
+@singleton
+class ProductTelemetry:
+    """
+    Service for capturing anonymized telemetry data.
+
+    If the environment variable `ANONYMIZED_TELEMETRY=False`, anonymized telemetry will be disabled.
+    """
+
+    USER_ID_PATH = str(Path.home() / '.cache' /
+                       'lumivor' / 'telemetry_user_id')
+    PROJECT_API_KEY = 'phc_F8JMNjW1i2KbGUTaW1unnDdLSPCoyc52SGRU0JecaUh'
+    HOST = 'https://eu.i.posthog.com'
+    UNKNOWN_USER_ID = 'UNKNOWN'
+
+    _curr_user_id = None
+
+    def __init__(self) -> None:
+        telemetry_disabled = os.getenv(
+            'ANONYMIZED_TELEMETRY', 'true').lower() == 'false'
+        self.debug_logging = os.getenv(
+            'LUMIVOR_LOGGING_LEVEL', 'info').lower() == 'debug'
+
+        if telemetry_disabled:
+            self._posthog_client = None
+        else:
+            logging.info(
+                'Anonymized telemetry enabled. See https://github.com/Lumivor-Labs/lumivor for more information.'
+            )
+            self._posthog_client = Posthog(
+                project_api_key=self.PROJECT_API_KEY,
+                host=self.HOST,
+                disable_geoip=False,
+            )
+
+            # Silence posthog's logging
+            if not self.debug_logging:
+                posthog_logger = logging.getLogger('posthog')
+                posthog_logger.disabled = True
+
+        if self._posthog_client is None:
+            logger.debug('Telemetry disabled')
+
+    def capture(self, event: BaseTelemetryEvent) -> None:
+        if self._posthog_client is None:
+            return
+
+        if self.debug_logging:
+            logger.debug(f'Telemetry event: {event.name} {event.properties}')
+        self._direct_capture(event)
+
+    def _direct_capture(self, event: BaseTelemetryEvent) -> None:
+        """
+        Should not be thread blocking because posthog magically handles it
+        """
+        if self._posthog_client is None:
+            return
+
+        try:
+            self._posthog_client.capture(
+                self.user_id,
+                event.name,
+                {**event.properties, **POSTHOG_EVENT_SETTINGS},
+            )
+        except Exception as e:
+            logger.error(f'Failed to send telemetry event {event.name}: {e}')
+
+    @property
+    def user_id(self) -> str:
+        if self._curr_user_id:
+            return self._curr_user_id
+
+        # File access may fail due to permissions or other reasons. We don't want to
+        # crash so we catch all exceptions.
+        try:
+            if not os.path.exists(self.USER_ID_PATH):
+                os.makedirs(os.path.dirname(self.USER_ID_PATH), exist_ok=True)
+                with open(self.USER_ID_PATH, 'w') as f:
+                    new_user_id = str(uuid.uuid4())
+                    f.write(new_user_id)
+                self._curr_user_id = new_user_id
+            else:
+                with open(self.USER_ID_PATH, 'r') as f:
+                    self._curr_user_id = f.read()
+        except Exception:
+            self._curr_user_id = 'UNKNOWN_USER_ID'
+        return self._curr_user_id

lumivor/telemetry/views.py

@@ -0,0 +1,51 @@
+from abc import ABC, abstractmethod
+from dataclasses import asdict, dataclass
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class BaseTelemetryEvent(ABC):
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        pass
+
+    @property
+    def properties(self) -> Dict[str, Any]:
+        return {k: v for k, v in asdict(self).items() if k != "name"}
+
+
+@dataclass
+class RegisteredFunction:
+    name: str
+    params: dict[str, Any]
+
+
+@dataclass
+class ControllerRegisteredFunctionsTelemetryEvent(BaseTelemetryEvent):
+    registered_functions: list[RegisteredFunction]
+    name: str = "controller_registered_functions"
+
+
+@dataclass
+class AgentRunTelemetryEvent(BaseTelemetryEvent):
+    agent_id: str
+    task: str
+    name: str = "agent_run"
+
+
+@dataclass
+class AgentStepErrorTelemetryEvent(BaseTelemetryEvent):
+    agent_id: str
+    error: str
+    name: str = "agent_step_error"
+
+
+@dataclass
+class AgentEndTelemetryEvent(BaseTelemetryEvent):
+    agent_id: str
+    task: str
+    steps: int
+    success: bool
+    error: Optional[str] = None
+    name: str = "agent_end"

lumivor/utils.py

@@ -0,0 +1,54 @@
+import logging
+import time
+from functools import wraps
+from typing import Any, Callable, Coroutine, ParamSpec, TypeVar
+
+logger = logging.getLogger(__name__)
+
+
+# Define generic type variables for return type and parameters
+R = TypeVar('R')
+P = ParamSpec('P')
+
+
+def time_execution_sync(additional_text: str = '') -> Callable[[Callable[P, R]], Callable[P, R]]:
+	def decorator(func: Callable[P, R]) -> Callable[P, R]:
+		@wraps(func)
+		def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+			start_time = time.time()
+			result = func(*args, **kwargs)
+			execution_time = time.time() - start_time
+			logger.debug(f'{additional_text} Execution time: {execution_time:.2f} seconds')
+			return result
+
+		return wrapper
+
+	return decorator
+
+
+def time_execution_async(
+	additional_text: str = '',
+) -> Callable[[Callable[P, Coroutine[Any, Any, R]]], Callable[P, Coroutine[Any, Any, R]]]:
+	def decorator(func: Callable[P, Coroutine[Any, Any, R]]) -> Callable[P, Coroutine[Any, Any, R]]:
+		@wraps(func)
+		async def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+			start_time = time.time()
+			result = await func(*args, **kwargs)
+			execution_time = time.time() - start_time
+			logger.debug(f'{additional_text} Execution time: {execution_time:.2f} seconds')
+			return result
+
+		return wrapper
+
+	return decorator
+
+
+def singleton(cls):
+	instance = [None]
+
+	def wrapper(*args, **kwargs):
+		if instance[0] is None:
+			instance[0] = cls(*args, **kwargs)
+		return instance[0]
+
+	return wrapper