intuned-runtime 1.0.0__py3-none-any.whl → 1.1.1__py3-none-any.whl

runtime/browser/launch_chromium.py

@@ -1,31 +1,15 @@
+import asyncio
 import json
+import logging
 import os
-import tempfile
 from contextlib import asynccontextmanager
-from os.path import join
 from typing import Any
-from typing import Optional
-from typing import Literal
-import logging
-import aiofiles
-from playwright.async_api import async_playwright
-from playwright.async_api import Browser
-from playwright.async_api import ProxySettings
 
-logger = logging.getLogger(__name__)
+import anyio
 
+from .helpers import get_proxy_env
 
-def get_proxy_env() -> Optional[ProxySettings]:
-    server = os.getenv("PROXY_SERVER")
-    username = os.getenv("PROXY_USERNAME")
-    password = os.getenv("PROXY_PASSWORD")
-    if server is None or username is None or password is None:
-        return None
-    return {
-        "server": server,
-        "username": username,
-        "password": password,
-    }
+logger = logging.getLogger(__name__)
 
 
 chromium_launch_args_to_ignore = [
@@ -64,12 +48,12 @@ chromium_launch_args_to_ignore = [
 
 async def create_user_dir_with_preferences():
     # Create a temporary directory
-    playwright_temp_dir = tempfile.mkdtemp(prefix="pw-")
-    user_dir = join(playwright_temp_dir, "userdir")
-    default_dir = join(user_dir, "Default")
+    playwright_temp_dir = anyio.Path(await anyio.mkdtemp(prefix="pw-"))
+    user_dir = playwright_temp_dir / "userdir"
+    default_dir = user_dir / "Default"
 
     # Create the default directory recursively
-    os.makedirs(default_dir, exist_ok=True)
+    await default_dir.mkdir(parents=True, exist_ok=True)
 
     # Preferences data
     preferences = {
@@ -79,10 +63,10 @@ async def create_user_dir_with_preferences():
     }
 
     # Write preferences to file
-    async with aiofiles.open(join(default_dir, "Preferences"), mode="w") as f:
+    async with await (default_dir / "Preferences").open("w") as f:
         await f.write(json.dumps(preferences))
 
-    return os.path.abspath(user_dir)
+    return await user_dir.absolute(), await playwright_temp_dir.absolute()
 
 
 extra_args = [
@@ -95,7 +79,9 @@ extra_args = [
     "--disable-blink-features=AutomationControlled",
 ]
 
-default_user_agent = "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36"
+default_user_agent = (
+    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36"
+)
 
 
 @asynccontextmanager
@@ -105,13 +91,17 @@ async def launch_chromium(
     cdp_address: str | None = None,
     **kwargs: Any,
 ):
+    from playwright.async_api import async_playwright
+    from playwright.async_api import Browser
+
     async with async_playwright() as playwright:
         if cdp_address is not None:
             browser: Browser = await playwright.chromium.connect_over_cdp(cdp_address)
             context = browser.contexts[0]
-            dir = None
+            user_preferences_dir = None
+            dir_to_clean = None
         else:
-            dir = await create_user_dir_with_preferences()
+            user_preferences_dir, dir_to_clean = await create_user_dir_with_preferences()
             if kwargs.get("proxy") is None:
                 proxy_env = get_proxy_env()
             else:
@@ -126,7 +116,7 @@ async def launch_chromium(
                 extra_args.append("--headless=new")
 
             context = await playwright.chromium.launch_persistent_context(
-                dir,
+                os.fspath(user_preferences_dir),
                 headless=headless,
                 viewport=viewport,
                 proxy=proxy_env,
@@ -138,9 +128,19 @@ async def launch_chromium(
         context.set_default_timeout(timeout * 1000)
 
         async def remove_dir_after_close(*_: Any, **__: Any) -> None:
-            if not dir:
+            if not dir_to_clean:
                 return
-            os.system(f"rm -rf {os.path.realpath(dir)}")
+            if not await dir_to_clean.exists():
+                return
+
+            process = await asyncio.create_subprocess_exec(
+                "rm",
+                "-rf",
+                os.fspath(dir_to_clean),  # Using subprocess to remove the directory
+                stdout=asyncio.subprocess.DEVNULL,
+                stderr=asyncio.subprocess.DEVNULL,
+            )
+            await process.wait()
 
         context.once("close", remove_dir_after_close)
         yield context, context.pages[0]
@@ -149,31 +149,25 @@ async def launch_chromium(
 async def dangerous_launch_chromium(
     headless: bool = True,
     timeout: int = 10,
-    web_socket: str | None = None,
     cdp_url: str | None = None,
-    connection_method: Literal["ws", "cdp"] | None = None,
+    port: int | None = None,
     **kwargs: Any,
 ):
+    from playwright.async_api import async_playwright
+    from playwright.async_api import Browser
+
     playwright = await async_playwright().start()
-    if web_socket is not None and connection_method == "ws":
-        logging.info(f"Connecting to ws: {web_socket}")
-        browser: Browser = await playwright.chromium.connect(web_socket)
-        browser.on("disconnected", lambda: logging.info("Browser Session disconnected"))
-        await browser.new_context(
-            viewport={"width": 1280, "height": 800}, user_agent=default_user_agent
-        )
-        context = browser.contexts[0]
-        dir = None
-    elif cdp_url is not None and connection_method == "cdp":
+    if cdp_url is not None:
         logging.info(f"Connecting to cdp: {cdp_url}")
         browser: Browser = await playwright.chromium.connect_over_cdp(cdp_url)
-        browser.on("disconnected", lambda: logging.info("Browser Session disconnected"))
+        browser.on("disconnected", lambda _: logging.info("Browser Session disconnected"))
         context = browser.contexts[0]
-        dir = None
-    elif web_socket is None and cdp_url is None and connection_method is None:
+        user_preferences_dir = None
+        dir_to_clean = None
+    else:
         logging.info("Launching local browser")
-        dir = await create_user_dir_with_preferences()
-        logging.info(f"Using user data directory: {dir}")
+        user_preferences_dir, dir_to_clean = await create_user_dir_with_preferences()
+        logging.info(f"Using user data directory: {user_preferences_dir}")
         if kwargs.get("proxy") is None:
             proxy_env = get_proxy_env()
         else:
@@ -187,8 +181,11 @@ async def dangerous_launch_chromium(
             chromium_launch_args_to_ignore.append("--headless")
             extra_args.append("--headless=new")
 
+        if port:
+            extra_args.append(f"--remote-debugging-port={port}")
+
         context = await playwright.chromium.launch_persistent_context(
-            dir,
+            os.fspath(user_preferences_dir),
             headless=headless,
             viewport=viewport,
             proxy=proxy_env,
@@ -197,16 +194,22 @@ async def dangerous_launch_chromium(
             args=extra_args,
             **kwargs,
         )
-    else:
-        raise ValueError(
-            "You have to provide method if you are launching a remote browser with ws or cdp"
-        )
-    context.set_default_timeout(timeout * 1000)
+        context.set_default_timeout(timeout * 1000)
 
-    async def remove_dir_after_close(*_: Any, **__: Any) -> None:
-        if not dir:
-            return
-        os.system(f"rm -rf {os.path.realpath(dir)}")
+        async def remove_dir_after_close(*_: Any, **__: Any) -> None:
+            if not dir_to_clean:
+                return
+            if not await dir_to_clean.exists():
+                return
 
-    context.once("close", remove_dir_after_close)
+            process = await asyncio.create_subprocess_exec(
+                "rm",
+                "-rf",
+                os.fspath(dir_to_clean),  # Using subprocess to remove the directory
+                stdout=asyncio.subprocess.DEVNULL,
+                stderr=asyncio.subprocess.DEVNULL,
+            )
+            await process.wait()
+
+        context.once("close", remove_dir_after_close)
     return playwright, context

runtime/browser/storage_state.py

@@ -1,23 +1,22 @@
 from typing import Any
+from typing import TYPE_CHECKING
 
-from playwright.async_api import BrowserContext
-from playwright.async_api import Error as PlaywrightError
+if TYPE_CHECKING:
+    from playwright.async_api import BrowserContext
+
+import logging
 
 from ..types.run_types import Cookie
 from ..types.run_types import Origin
 from ..types.run_types import SessionStorageOrigin
 from ..types.run_types import StorageState
 
-import logging
-
 logger = logging.getLogger(__name__)
 
 
-async def set_storage_state(context: BrowserContext, state: StorageState):
+async def set_storage_state(context: "BrowserContext", state: StorageState):
     # Add cookies if they exist
-    await context.add_cookies(
-        [cookie.model_dump(by_alias=True) for cookie in state.cookies]
-    )  # type: ignore
+    await context.add_cookies([cookie.model_dump(by_alias=True) for cookie in state.cookies])  # type: ignore
 
     # Apply localStorage for each origin
     page = await context.new_page()
@@ -67,7 +66,9 @@ async def set_storage_state(context: BrowserContext, state: StorageState):
     await page.close()
 
 
-async def get_storage_state(context: BrowserContext) -> StorageState:
+async def get_storage_state(context: "BrowserContext") -> StorageState:
+    from playwright.async_api import Error as PlaywrightError
+
     storage_state = await context.storage_state()
     cookies = storage_state.get("cookies") or []
     origins = storage_state.get("origins") or []
@@ -92,9 +93,7 @@ async def get_storage_state(context: BrowserContext) -> StorageState:
             session_storage.append(SessionStorageOrigin(**session_data))
         except PlaywrightError as e:
             if "SecurityError" in e.message:
-                logger.warning(
-                    f"Could not get storage state for page due '{page.url}' to security error."
-                )
+                logger.warning(f"Could not get storage state for page due '{page.url}' to security error.")
                 continue
             raise e
 

runtime/env.py

@@ -11,3 +11,7 @@ def get_project_id():
 
 def get_functions_domain():
     return os.environ.get("FUNCTIONS_DOMAIN")
+
+
+def get_browser_type():
+    return os.environ.get("BROWSER_TYPE")

runtime/errors/run_api_errors.py

@@ -66,22 +66,30 @@ class AutomationNotCoroutineError(RunApiError):
 
 
 class AutomationError(RunApiError):
-    def __init__(self, exception: BaseException):
+    _error: BaseException
+
+    def __init__(self, error: BaseException):
         # Get all public attributes of the exception
-        error_props = {key: str(value) for key, value in exception.__dict__.items() if not key.startswith("_")}
+        error_props = {key: str(value) for key, value in error.__dict__.items() if not key.startswith("_")}
 
         super().__init__(
-            str(exception),
+            str(error),
             "AutomationError",
         )
 
+        self._error = error
+
         self.details = {
             "error_props": error_props,
-            "error_type": exception.__class__.__name__,
-            "name": exception.__class__.__name__,
-            "message": str(exception),
+            "error_type": error.__class__.__name__,
+            "name": error.__class__.__name__,
+            "message": str(error),
         }
 
+    @property
+    def error(self) -> BaseException:
+        return self._error
+
 
 class AutomationTimeoutError(RunApiError):
     def __init__(self):
@@ -111,10 +119,6 @@ class InternalInvalidInputError(RunApiError):
     def __init__(self, message: str, details: Any | None = None):
         super().__init__(
             f"Internal error: {message}. Please report this issue to the Intuned team.",
-            RunApiResponse(
-                status_code=500,
-                response={"error": "Internal error", "message": f"Internal error: {message}"},
-            ),
             "InternalInvalidInputError",
         )
         self.details = details

runtime/run/playwright_constructs.py

@@ -1,18 +1,19 @@
 from contextlib import asynccontextmanager
+from typing import TYPE_CHECKING
 
-from playwright.async_api import ProxySettings
-
-from ..browser import launch_chromium
+if TYPE_CHECKING:
+    from playwright.async_api import ProxySettings
+from ..browser import launch_browser
 
 
 @asynccontextmanager
 async def get_production_playwright_constructs(
-    proxy: ProxySettings | None = None,
+    proxy: "ProxySettings | None" = None,
     headless: bool = False,
     *,
     cdp_address: str | None = None,
 ):
-    async with launch_chromium(headless=headless, cdp_address=cdp_address, proxy=proxy) as (context, page):
+    async with launch_browser(headless=headless, cdp_address=cdp_address, proxy=proxy) as (context, page):
         try:
             yield context, page
         finally:

runtime/run/pydantic_encoder.py

@@ -0,0 +1,15 @@
+import json
+from typing import Any
+from typing import override
+
+from pydantic import BaseModel
+
+
+class PydanticEncoder(json.JSONEncoder):
+    @override
+    def default(self, o: Any):
+        if isinstance(o, BaseModel):
+            return o.model_dump(
+                by_alias=True,
+            )
+        return super().default(o)

runtime/run/run_api.py

@@ -31,7 +31,7 @@ from ..errors import AutomationError
 from ..errors import AutomationNotCoroutineError
 from ..errors import NoAutomationInApiError
 from .playwright_constructs import get_production_playwright_constructs
-from .playwright_constructs import ProxySettings
+from .pydantic_encoder import PydanticEncoder
 
 
 def import_function_from_api_dir(
@@ -111,7 +111,9 @@ async def run_api(
     parameters: RunApiParameters,
     *,
     import_function: ImportFunction | None = None,
-):
+) -> RunAutomationSuccessResult:
+    from playwright.async_api import ProxySettings
+
     trace_started: bool = False
 
     headless = False
@@ -145,7 +147,6 @@ async def run_api(
                 context=context,
                 state=state,
             )
-
         import_function = import_function or (
             lambda file_path, name=None: import_function_from_api_dir(
                 file_path=file_path, automation_function_name=name
@@ -181,7 +182,7 @@ async def run_api(
                 else:
                     automation_result = await automation_coroutine_with_page(parameters.automation_function.params)
                 try:
-                    json.dumps(automation_result)
+                    json.dumps(automation_result, cls=PydanticEncoder)
                 except TypeError as e:
                     raise AutomationError(TypeError("Result is not JSON serializable")) from e
 

runtime/types/run_types.py

@@ -5,6 +5,7 @@ from typing import List
 from typing import Literal
 from typing import Optional
 from typing import Union
+from urllib.parse import urlparse
 
 from pydantic import BaseModel
 from pydantic import ConfigDict
@@ -24,6 +25,21 @@ class ProxyConfig(CamelBaseModel):
     username: str
     password: str
 
+    @classmethod
+    def parse_from_str(cls, proxy_str: str) -> "ProxyConfig":
+        parts = urlparse(proxy_str)
+        username = parts.username or ""
+        password = parts.password or ""
+        hostname = parts.hostname or ""
+        port = f":{parts.port}" if parts.port else ""
+        domain = f"{parts.scheme}://{hostname}{port}"
+
+        return ProxyConfig(
+            server=domain,
+            username=username,
+            password=password,
+        )
+
 
 class SameSite(str, Enum):
     STRICT = "Strict"

intuned_runtime-1.0.0.dist-info/RECORD

@@ -1,58 +0,0 @@
-cli/__init__.py,sha256=QvTM82L3VLVOFGpu_bziWupgwjsAgv07u6o_gUwO3z0,1314
-cli/commands/__init__.py,sha256=QF-zy-iOZXY-9m-1O-JjWnugjulgJtsODtnkhvlNKq8,944
-cli/commands/ai_source/__init__.py,sha256=lg7owgcK8owNn2a4VBUP9RKxzFsLruhtnnQV0F_z6pc,149
-cli/commands/ai_source/ai_source.py,sha256=2woQtCmhxKvLfEz832eUoCT9gMsuSvEE6rMnHSYXC7w,138
-cli/commands/ai_source/deploy.py,sha256=XVN_alilwIaoVniuSpE8RkAveuaB3MaUtsRjIcpQTXo,2440
-cli/commands/browser/__init__.py,sha256=AuVbvh7aSBTFKYvewXZyPoIvfBTe2uHiPcnaAkzapas,95
-cli/commands/browser/save_state.py,sha256=eHKfvBfeFR_U9VQbsjOnIZjWepyDjNn9NL3naDYWP2s,841
-cli/commands/init.py,sha256=8rWBenWZfwNtLxOBqhEMbOATyQNEnmDUmrFJ1xBGyxI,4384
-cli/commands/project/__init__.py,sha256=t97wvhSenerYRdbSeCKXqHASA6EWA3lc1hnRhF9baOE,734
-cli/commands/project/auth_session/__init__.py,sha256=gt7mlaW6xmqAc_4-pfF_FiecsR51C6fqCaq_NFbcbwA,300
-cli/commands/project/auth_session/check.py,sha256=AFILp7m34nAO_RD3IfRpuJm5Zh0wnCRtBXqIrerdbwo,4565
-cli/commands/project/auth_session/create.py,sha256=r-eYu3uLUo2mzF836CbVgu4oBzcIIDekzzFwwekxmg0,3374
-cli/commands/project/auth_session/load.py,sha256=UUvg9Vyj15xiR44XlJzojLoFm5esv-o4E3qA3JqnBsE,1201
-cli/commands/project/project.py,sha256=_MSh6Xor2Cbh-ItifwgOPq_BP8UDuKB7S6w796FULKQ,137
-cli/commands/project/run.py,sha256=FDYYkU24aURYbljyYLFo8wLF-nvb86EVr9gMEjAfeE0,12274
-cli/commands/project/run_interface.py,sha256=4RyR8WZriIF7Va4z1wt-q6zZDQOI31n62Ho2dyimzUY,8717
-cli/commands/project/type_check.py,sha256=3BKMqTzJ73_J-RYrjba7Yv2mM_VzHR0gnXQEg_Us7JA,3384
-cli/commands/project/upgrade.py,sha256=XmkZLflM4O-mwvhwcswlZpazRotwi3xesLgE0Zz8fTI,3061
-cli/commands/publish_packages.py,sha256=sijkaG7_s0I1EWgLekGy1qm8Aqi_gYY8poXbMX0B6Yw,10505
-cli/logger.py,sha256=bZK3q-KUdGxk_qzDb6pn-n0LOhKJvi6a9p8oSwZtq3s,594
-cli/utils/ai_source_project.py,sha256=xUCM6p3i1XN4bJbuQz8LCzeI4BwqAdSvCl_vwDAEi0k,831
-cli/utils/code_tree.py,sha256=1wfxZoQ5kRCfqs2SEPAicbAIPTiD6P1LxSuwYu_eeaI,2790
-cli/utils/run_apis.py,sha256=Zee4zkgt9R8XY1XCGzj2Nc4zJ3jlRz1xnO493wotuWw,4690
-cli/utils/unix_socket.py,sha256=UISmkJMHrir5iBLUm6vxC3uzTGIFyOk_wa0C9LUw4Cc,1889
-runtime/__init__.py,sha256=wgS7k3f10LBbjSYJdjKeKUptizNw6OrBgNx-ECT5Ox8,124
-runtime/backend_functions/__init__.py,sha256=j2EaK4FK8bmdFtqc5FxtFwx1KhIn_7qKPChrrAhJI3s,119
-runtime/backend_functions/_call_backend_function.py,sha256=sER0op3vE9EVEB5-ZNwpGraxrqkFh5ZgOIV2B5fgmg4,3028
-runtime/backend_functions/get_auth_session_parameters.py,sha256=pOvB7XiWpphEuBpazdKALw9EWgBU1PeY3gkzBfVLpkc,869
-runtime/browser/__init__.py,sha256=9Nqf-80l1F7KGjy2pYBC5S5SeEXJ4YJ4Dl71hi_GWdI,132
-runtime/browser/launch_chromium.py,sha256=sML_XpjmlMf5QpuqMGeaS42D43pAXWKswm2q-3a2jAM,7459
-runtime/browser/storage_state.py,sha256=AmiHMfWbFVr7XUEYXoaWWZH4pXGdPv4wTNPXunm19rA,3591
-runtime/context/__init__.py,sha256=hg8ejm4bJy4tNkwmZ9lKgYJx6bU7OgOdBS684Uv5XGg,73
-runtime/context/context.py,sha256=pl_0x77_d5CiAznz1qGSk6o9cW-msNvlCt-2eFoMKlA,1739
-runtime/env.py,sha256=h4BJI-XVSZKgtTxjkzj2HsyN3DlY5Ml9GZqeH4CKDE8,238
-runtime/errors/__init__.py,sha256=oqiBSvT_yFLQ3hG0AbCUA3WYFaxkTDVkDMSy59xvBCo,688
-runtime/errors/auth_session_errors.py,sha256=6b4XTI8UCDHDPX4jEA8_HyrNUp4VZ1TrEA8DRh6Z3rM,228
-runtime/errors/run_api_errors.py,sha256=etqS18ZxDzr30qUezG6D8gcH0Yc1XNtQ8GMkUZx3Rmw,3400
-runtime/errors/trace_errors.py,sha256=Lzfo0sH3zGaWz1kn5DHcAXQMn3aR2y2bnauj6xP1LYE,110
-runtime/helpers/__init__.py,sha256=jozYPKHgZJ7Na5U1Wjt83egzjPATMZ_OMInEI6swSbY,234
-runtime/helpers/extend_payload.py,sha256=towZF08WTpTTDBL4AV1bUU3XpKAQHEB66kGUfTICDe0,246
-runtime/helpers/extend_timeout.py,sha256=KjfSLEUrqoz7v00rhnPAKq2OmUzEzcv-eQ3M8c2U46s,348
-runtime/helpers/get_auth_session_parameters.py,sha256=7bopGhJ7vjKAn_UxnHSAah-k2rVOPbq0zi9FQOOCFds,472
-runtime/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-runtime/run/__init__.py,sha256=zxMYVb7hn147YTrhMLsrcX6-KTd71HLrYHstJOWeWXQ,52
-runtime/run/intuned_settings.py,sha256=vy2-ktEzUfUp5Z90dp3l7jPKHNjgB-8GSMDgAY-rYaU,1074
-runtime/run/playwright_constructs.py,sha256=kOa95d4m4DTcIDKq_QajBs-9FkPz5yZFcsafLtx5288,519
-runtime/run/run_api.py,sha256=88u91YS5-m_aGwQnNfeN7Mszm1MRfOmciCpzuAXjdoI,8853
-runtime/run/traces.py,sha256=fKzh11LqV47ujgq_9I2tdp-dgld566wffWaHwU_4gis,1123
-runtime/types/__init__.py,sha256=IJkDfqsau8F8R_j8TO6j-JwW4ElQr6aU6LNaWRehg5U,401
-runtime/types/payload.py,sha256=sty8HgDEn3nJbZrwEOMCXyuG7_ICGDwlBIIWSON5ABY,124
-runtime/types/run_types.py,sha256=_ZoW0rv4VnjqVwVxJBWsdh0S5toppNL3AfL456rn5yM,4076
-runtime_helpers/__init__.py,sha256=XBrEiE9yNC8Lgn8NgIkqNXbI6e4ap237E83Zj_nlhCQ,249
-runtime_helpers/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-intuned_runtime-1.0.0.dist-info/LICENSE,sha256=9LIjQdgyU_ptzNIfItNCR7VmEHqYnrY1f1XwOreKFI0,3714
-intuned_runtime-1.0.0.dist-info/METADATA,sha256=i6-dbJpG78FttN_tw7HgA3qd_fE99cHW7bkASh2z16o,5134
-intuned_runtime-1.0.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-intuned_runtime-1.0.0.dist-info/entry_points.txt,sha256=4VXmTtVfaolAgt2owC9QF1bQpzCVv6Qh_cqW6ZGpftw,35
-intuned_runtime-1.0.0.dist-info/RECORD,,

intuned_runtime-1.0.0.dist-info/entry_points.txt

@@ -1,3 +0,0 @@
-[console_scripts]
-intuned=cli:run
-