Den 229 new ergonomics (#47)

* Added functions to basebrowser that control active page for nicer ergonomics. Also added a global browser and a fill fields function.

* added timeout to ask and improved goto and fill_fields. Removed global browser.

* Added authentication_on parameter when initiating the browser.

* Renamed LLMConfig to APIConfig to contain a Dendrite API key. It is now possible to use only a Dendrite API key when using the SDK. The option to use own API keys is still available for now.

* add script that generates almost working sync code

* update sync sdk name in script

* remove and fix all type:ignore

* update sdk with async and sync

* add poe task runner for simplifying sync generation

* add first test for sync

* fixed small typo

* added .mp3 to gitignore so that the download tests result isn't accidentally pushed

* made auth param less verbose

* Renamed to less verbose names. Added imports to top level in dendrite_sdk. Modified generate_sync to account for changed names. Added get element with dict to server with same branch name.

* Renamed to even less verbose names.

* Updated incorrect docs string

* Changes to dendrite page protocol, added more helpful mixins.

* rename playwright page

* move tests out of module

* remove unused dependencies

* update test to save download to temp

* remove unused .gitignore for mp3

---------

Co-authored-by: Arian Hanifi <[email protected]>

Author: charlesmaddock

.env.example

@@ -2,6 +2,6 @@ DENDRITE_API_KEY=
 OPENAI_API_KEY=
 ANTHROPIC_API_KEY=
 
-# If using BrowserBaseBrowser
+# If using Browserbase
 BROWSERBASE_API_KEY=
 BROWSERBASE_PROJECT_ID=

.gitignore

@@ -8,3 +8,4 @@ test_screenshots/*
 .vscode/
 dist/
 examples/
+tmp/

README.md

@@ -16,11 +16,11 @@
 With Dendrite, you can code a **email sending tool** like this:
 
 ```python
-from dendrite import DendriteBrowser
+from dendrite import AsyncDendrite
 
 # Provide this tool to an agent by using e.g crewAI, llamaIndex, langchain or your own framework
 async def send_email(to: str, subject: str, body: str):
-  async with DendriteBrowser() as dendrite:
+  async with AsyncDendrite() as dendrite:
 
     # Your agent will be able to access your outlook account now. You can mirror your browser's auth sessions to your agent with our Chrome Extension "Dendrite Vault".
     await dendrite.authenticate("outlook.live.com") 
@@ -44,7 +44,7 @@ Sending emails is cool, but if that's all our agent can do it kind of sucks. So,
 
 ```python
 async def get_and_analyze_transactions(prompt: str) -> str:
-    async with DendriteBrowser() as dendrite:
+    async with AsyncDendrite() as dendrite:
         await dendrite.authenticate("mercury.com")
         page = await dendrite.goto("https://app.mercury.com/transactions", expected_outcome="We should arrive at the dashboard") # Raise an exception if we aren't logged in. 
         await page.wait_for("The transactions page to have loaded")
@@ -64,7 +64,7 @@ Finally, it would be cool if we could add the amount of monthly visitors from Go
 
 ```python
 async def get_visitor_stats() -> int:
-    async with DendriteBrowser() as dendrite:
+    async with AsyncDendrite() as dendrite:
         await dendrite.authenticate("analytics.google.com")
         page = await dendrite.goto("https://analytics.google.com/analytics/web")
         await page.wait_for("The analytics page to have loaded")
@@ -111,11 +111,11 @@ poetry add dendrite-sdk && poetry run playwright install
 
 ## Hello World Example
 
-For our first Dendrite script, let's start the `DendriteBrowser`, go to google.com and enter "hello world" into the search field:
+For our first Dendrite script, let's start the `AsyncDendrite`, go to google.com and enter "hello world" into the search field:
 
 ```python main.py
 import asyncio
-from dendrite_sdk import DendriteBrowser
+from dendrite_sdk import AsyncDendrite
 
 
 async def hello_world():
@@ -127,13 +127,13 @@ async def hello_world():
     dendrite_api_key = "..."
 
     # Initate the Dendrite Browser
-    browser = DendriteBrowser(
+    browser = AsyncDendrite(
         openai_api_key=openai_api_key,
         anthropic_api_key=anthropic_api_key,
         dendrite_api_key=dendrite_api_key,
     )
 
-    # Navigate with `goto`, which returns a 'DendritePage' that controls the current page.
+    # Navigate with `goto`, which returns a 'AsyncPage' that controls the current page.
     page = await browser.goto("https://google.com")
 
     # Get elements from the current page with `get_element`.
@@ -156,7 +156,7 @@ For more examples
 
 When you want to scale up your AI agents, we support using browsers hosted by Browserbase. This way you can run many agents in parallel without having to worry about the infrastructure. 
 
-To start using Browserbase just swap out the `DendriteBrowser` with `BrowserbaseBrowser` and add your Browserbase API key and project id, either in the code or in a `.env` file like this:
+To start using Browserbase just swap out the `AsyncDendrite` with `AsyncBrowserbaseBrowser` and add your Browserbase API key and project id, either in the code or in a `.env` file like this:
 
 ```bash
 # ... previous keys 
@@ -167,14 +167,14 @@ BROWSERBASE_PROJECT_ID=
 
 
 ```python
-# from dendrite_python_sdk import DendriteBrowser
-from dendrite_sdk.ext.browserbase import BrowserbaseBrowser
+# from dendrite_python_sdk import AsyncDendrite
+from dendrite_sdk.async_api.ext.browserbase import AsyncBrowserbaseBrowser
 
 ... 
 
-# browser = DendriteBrowser(...)
-browser = BrowserbaseBrowser(
-    # Include the previous arguments from DendriteBrowser
+# browser = AsyncDendrite(...)
+browser = AsyncBrowserbaseBrowser(
+    # Include the previous arguments from AsyncDendrite
     browserbase_api_key="...", # or specify the browsebase keys in the .env file
     browserbase_project_id="..." 
 )

dendrite_sdk/__init__.py

@@ -1,15 +1,24 @@
-from loguru import logger
-from ._core.dendrite_browser import DendriteBrowser
-from ._core.dendrite_element import DendriteElement
-from ._core.dendrite_page import DendritePage
-from ._core.models.response import DendriteElementsResponse
+from dendrite_sdk.async_api import (
+    AsyncDendrite,
+    AsyncElement,
+    AsyncPage,
+    AsyncElementsResponse,
+)
 
-
-logger.disable("dendrite_python_sdk")
+from dendrite_sdk.sync_api import (
+    Dendrite,
+    Element,
+    Page,
+    ElementsResponse,
+)
 
 __all__ = [
-    "DendriteBrowser",
-    "DendriteElement",
-    "DendritePage",
-    "DendriteElementsResponse",
+    "AsyncDendrite",
+    "AsyncElement",
+    "AsyncPage",
+    "AsyncElementsResponse",
+    "Dendrite",
+    "Element",
+    "Page",
+    "ElementsResponse",
 ]

dendrite_sdk/_api/dto/get_elements_dto.py

@@ -5,7 +5,7 @@
 
 from loguru import logger
 
-from dendrite_sdk._exceptions._constants import INVALID_AUTH_SESSION_MSG
+from dendrite_sdk._common._exceptions._constants import INVALID_AUTH_SESSION_MSG
 
 
 class BaseDendriteException(Exception):
@@ -50,7 +50,7 @@ class IncorrectOutcomeError(BaseDendriteException):
 class BrowserNotLaunchedError(BaseDendriteException):
     def __init__(
         self,
-        message: str = "The browser should have been automatically launched by the DendriteBrowser object.. Please reach out to us on GitHub or Discord if you are facing this issue.",
+        message: str = "The browser should have been automatically launched by the AsyncDendrite object.. Please reach out to us on GitHub or Discord if you are facing this issue.",
     ) -> None:
         super().__init__(message)
 

dendrite_sdk/_api/dto/get_interaction_dto.py

@@ -0,0 +1,15 @@
+from loguru import logger
+from ._core.dendrite_browser import AsyncDendrite
+from ._core.dendrite_element import AsyncElement
+from ._core.dendrite_page import AsyncPage
+from ._core.models.response import AsyncElementsResponse
+
+
+logger.disable("dendrite_python_sdk")
+
+__all__ = [
+    "AsyncDendrite",
+    "AsyncElement",
+    "AsyncPage",
+    "AsyncElementsResponse",
+]

dendrite_sdk/_api/response/get_element_response.py

@@ -1,15 +1,15 @@
-from typing import Any, Optional
-
+from typing import Optional
 import httpx
 from loguru import logger
 
 
-from dendrite_sdk._common.constants import DENDRITE_API_BASE_URL
+from dendrite_sdk.async_api._core.models.api_config import APIConfig
+from dendrite_sdk.async_api._common.constants import DENDRITE_API_BASE_URL
 
 
 class HTTPClient:
-    def __init__(self, api_key: Optional[str] = None, session_id: Optional[str] = None):
-        self.api_key = api_key
+    def __init__(self, api_config: APIConfig, session_id: Optional[str] = None):
+        self.api_key = api_config.dendrite_api_key
         self.session_id = session_id
         self.base_url = self.resolve_base_url()
 

dendrite_sdk/_api/__init__.py renamed to dendrite_sdk/_common/_exceptions/__init__.py

@@ -1,20 +1,24 @@
 from typing import Optional
 
 from loguru import logger
-from dendrite_sdk._core.models.authentication import AuthSession
-from dendrite_sdk._api.response.get_element_response import GetElementResponse
-from dendrite_sdk._api.dto.ask_page_dto import AskPageDTO
-from dendrite_sdk._api.dto.authenticate_dto import AuthenticateDTO
-from dendrite_sdk._api.dto.get_elements_dto import GetElementsDTO
-from dendrite_sdk._api.dto.make_interaction_dto import MakeInteractionDTO
-from dendrite_sdk._api.dto.scrape_page_dto import ScrapePageDTO
-from dendrite_sdk._api.dto.try_run_script_dto import TryRunScriptDTO
-from dendrite_sdk._api.dto.upload_auth_session_dto import UploadAuthSessionDTO
-from dendrite_sdk._api.response.ask_page_response import AskPageResponse
-from dendrite_sdk._api.response.interaction_response import InteractionResponse
-from dendrite_sdk._api.response.scrape_page_response import ScrapePageResponse
-from dendrite_sdk._api._http_client import HTTPClient
-from dendrite_sdk._exceptions.dendrite_exception import InvalidAuthSessionError
+from dendrite_sdk.async_api._core.models.authentication import AuthSession
+from dendrite_sdk.async_api._api.response.get_element_response import GetElementResponse
+from dendrite_sdk.async_api._api.dto.ask_page_dto import AskPageDTO
+from dendrite_sdk.async_api._api.dto.authenticate_dto import AuthenticateDTO
+from dendrite_sdk.async_api._api.dto.get_elements_dto import GetElementsDTO
+from dendrite_sdk.async_api._api.dto.make_interaction_dto import MakeInteractionDTO
+from dendrite_sdk.async_api._api.dto.scrape_page_dto import ScrapePageDTO
+from dendrite_sdk.async_api._api.dto.try_run_script_dto import TryRunScriptDTO
+from dendrite_sdk.async_api._api.dto.upload_auth_session_dto import UploadAuthSessionDTO
+from dendrite_sdk.async_api._api.response.ask_page_response import AskPageResponse
+from dendrite_sdk.async_api._api.response.interaction_response import (
+    InteractionResponse,
+)
+from dendrite_sdk.async_api._api.response.scrape_page_response import ScrapePageResponse
+from dendrite_sdk.async_api._api._http_client import HTTPClient
+from dendrite_sdk._common._exceptions.dendrite_exception import (
+    InvalidAuthSessionError,
+)
 
 
 class BrowserAPIClient(HTTPClient):

dendrite_sdk/_exceptions/_constants.py renamed to dendrite_sdk/_common/_exceptions/_constants.py

@@ -0,0 +1,11 @@
+from typing import Any, Optional
+from pydantic import BaseModel
+from dendrite_sdk.async_api._core.models.api_config import APIConfig
+from dendrite_sdk.async_api._core.models.page_information import PageInformation
+
+
+class AskPageDTO(BaseModel):
+    prompt: str
+    return_schema: Optional[Any]
+    page_information: PageInformation
+    api_config: APIConfig

dendrite_sdk/_exceptions/dendrite_exception.py renamed to dendrite_sdk/_common/_exceptions/dendrite_exception.py

@@ -0,0 +1,13 @@
+from typing import Dict, Union
+from pydantic import BaseModel
+
+from dendrite_sdk.async_api._core.models.api_config import APIConfig
+from dendrite_sdk.async_api._core.models.page_information import PageInformation
+
+
+class GetElementsDTO(BaseModel):
+    page_information: PageInformation
+    prompt: Union[str, Dict[str, str]]
+    api_config: APIConfig
+    use_cache: bool = True
+    only_one: bool

dendrite_sdk/_core/models/llm_config.py

@@ -0,0 +1,10 @@
+from pydantic import BaseModel
+
+from dendrite_sdk.async_api._core.models.api_config import APIConfig
+from dendrite_sdk.async_api._core.models.page_information import PageInformation
+
+
+class GetInteractionDTO(BaseModel):
+    page_information: PageInformation
+    api_config: APIConfig
+    prompt: str

dendrite_sdk/_core/protocol/page_protocol.py

@@ -0,0 +1,12 @@
+from typing import Optional
+from pydantic import BaseModel
+from dendrite_sdk.async_api._core.models.api_config import APIConfig
+from dendrite_sdk.async_api._core.models.page_information import PageInformation
+
+
+class GoogleSearchDTO(BaseModel):
+    query: str
+    country: Optional[str] = None
+    filter_results_prompt: Optional[str] = None
+    page_information: PageInformation
+    api_config: APIConfig

dendrite_sdk/async_api/__init__.py

@@ -0,0 +1,19 @@
+from typing import Literal, Optional
+from pydantic import BaseModel
+from dendrite_sdk.async_api._core.models.api_config import APIConfig
+from dendrite_sdk.async_api._core.models.page_diff_information import (
+    PageDiffInformation,
+)
+
+
+InteractionType = Literal["click", "fill", "hover"]
+
+
+class MakeInteractionDTO(BaseModel):
+    url: str
+    dendrite_id: str
+    interaction_type: InteractionType
+    value: Optional[str] = None
+    expected_outcome: Optional[str]
+    page_delta_information: PageDiffInformation
+    api_config: APIConfig