PyPI - intuned-runtime - Versions diffs - 1.0.0__py3-none-any.whl - Mend

intuned-runtime 1.0.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (58) hide show

cli/__init__.py +45 -0
cli/commands/__init__.py +25 -0
cli/commands/ai_source/__init__.py +4 -0
cli/commands/ai_source/ai_source.py +10 -0
cli/commands/ai_source/deploy.py +64 -0
cli/commands/browser/__init__.py +3 -0
cli/commands/browser/save_state.py +32 -0
cli/commands/init.py +127 -0
cli/commands/project/__init__.py +20 -0
cli/commands/project/auth_session/__init__.py +5 -0
cli/commands/project/auth_session/check.py +118 -0
cli/commands/project/auth_session/create.py +96 -0
cli/commands/project/auth_session/load.py +39 -0
cli/commands/project/project.py +10 -0
cli/commands/project/run.py +340 -0
cli/commands/project/run_interface.py +265 -0
cli/commands/project/type_check.py +86 -0
cli/commands/project/upgrade.py +92 -0
cli/commands/publish_packages.py +264 -0
cli/logger.py +19 -0
cli/utils/ai_source_project.py +31 -0
cli/utils/code_tree.py +83 -0
cli/utils/run_apis.py +147 -0
cli/utils/unix_socket.py +55 -0
intuned_runtime-1.0.0.dist-info/LICENSE +42 -0
intuned_runtime-1.0.0.dist-info/METADATA +113 -0
intuned_runtime-1.0.0.dist-info/RECORD +58 -0
intuned_runtime-1.0.0.dist-info/WHEEL +4 -0
intuned_runtime-1.0.0.dist-info/entry_points.txt +3 -0
runtime/__init__.py +3 -0
runtime/backend_functions/__init__.py +5 -0
runtime/backend_functions/_call_backend_function.py +86 -0
runtime/backend_functions/get_auth_session_parameters.py +30 -0
runtime/browser/__init__.py +3 -0
runtime/browser/launch_chromium.py +212 -0
runtime/browser/storage_state.py +106 -0
runtime/context/__init__.py +5 -0
runtime/context/context.py +51 -0
runtime/env.py +13 -0
runtime/errors/__init__.py +21 -0
runtime/errors/auth_session_errors.py +9 -0
runtime/errors/run_api_errors.py +120 -0
runtime/errors/trace_errors.py +3 -0
runtime/helpers/__init__.py +5 -0
runtime/helpers/extend_payload.py +9 -0
runtime/helpers/extend_timeout.py +13 -0
runtime/helpers/get_auth_session_parameters.py +14 -0
runtime/py.typed +0 -0
runtime/run/__init__.py +3 -0
runtime/run/intuned_settings.py +38 -0
runtime/run/playwright_constructs.py +19 -0
runtime/run/run_api.py +233 -0
runtime/run/traces.py +36 -0
runtime/types/__init__.py +15 -0
runtime/types/payload.py +7 -0
runtime/types/run_types.py +177 -0
runtime_helpers/__init__.py +5 -0
runtime_helpers/py.typed +0 -0

runtime/browser/storage_state.py ADDED Viewed

@@ -0,0 +1,106 @@
+from typing import Any
+from playwright.async_api import BrowserContext
+from playwright.async_api import Error as PlaywrightError
+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):
+    # Add cookies if they exist
+    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()
+    for origin_data in state.origins or []:
+        origin = origin_data.origin
+        await page.route(
+            f"{origin}/*",
+            lambda route: route.fulfill(
+                body="<html><head><title>Set Storage</title></head><body><h1>Set Storage</h1></body></html>",
+                content_type="text/html",
+                status=200,
+            ),
+        )
+        try:
+            await page.goto(origin)
+            # Set localStorage items
+            for item in origin_data.local_storage:
+                await page.evaluate(
+                    """
+                    ([key, value]) => {
+                        window.localStorage.setItem(key, value)
+                    }
+                """,
+                    [item.name, item.value],
+                )
+        finally:
+            await page.unroute(origin)
+    # Apply sessionStorage if available
+    if state.session_storage is not None:
+        await context.add_init_script(f"""
+        const storage = {[s.model_dump(by_alias=True) for s in state.session_storage]};
+        for (const {{ origin, sessionStorage }} of storage) {{
+            if (window.location.origin === origin) {{
+                for (const item of sessionStorage){{
+                    const value = window.sessionStorage.getItem(item.name);
+                    console.log("value", value);
+                    if (!value) {{
+                        window.sessionStorage.setItem(item.name, item.value);
+                    }}
+                    }}
+            }}
+        }}
+    """)
+    await page.close()
+async def get_storage_state(context: BrowserContext) -> StorageState:
+    storage_state = await context.storage_state()
+    cookies = storage_state.get("cookies") or []
+    origins = storage_state.get("origins") or []
+    session_storage: list[SessionStorageOrigin] = []
+    for page in context.pages:
+        try:
+            session_data: dict[str, Any] = await page.evaluate(
+                """
+() => {
+    const items = { ...window.sessionStorage };
+    return {
+        origin: window.location.origin,
+        sessionStorage: Object.entries(items).map(([name, value]) => ({
+        name,
+        value,
+        })),
+    };
+}
+    """
+            )
+            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."
+                )
+                continue
+            raise e
+    # Ignoring types here because it expects snake case from constructors, but we have alias configured to accept any case correctly
+    return StorageState(
+        cookies=[Cookie(**cookie) for cookie in cookies],  # type: ignore
+        origins=[Origin(**origin) for origin in origins],  # type: ignore
+        session_storage=session_storage,
+    )

runtime/context/__init__.py ADDED Viewed

@@ -0,0 +1,5 @@
+from .context import IntunedContext
+__all__ = [
+    "IntunedContext",
+]

runtime/context/context.py ADDED Viewed

@@ -0,0 +1,51 @@
+from contextvars import ContextVar
+from contextvars import Token
+from typing import Any
+from typing import Awaitable
+from typing import Callable
+from typing import ClassVar
+from typing import Optional
+from pydantic import BaseModel
+from pydantic import Field
+from ..types import Payload
+from ..types.run_types import IntunedRunContext
+class IntunedContext(BaseModel):
+    _current: ClassVar[ContextVar["IntunedContext"]] = ContextVar("_current")
+    functions_token: str | None = None
+    extend_timeout: Callable[[], Awaitable[Any]] | None = None
+    extended_payloads: list[Payload] = Field(default_factory=lambda: list[Payload]())
+    run_context: IntunedRunContext | None = None
+    get_auth_session_parameters: Callable[[], Awaitable[dict[str, Any]]] | None = None
+    _token: Token["IntunedContext"] | None = None
+    @classmethod
+    def current(cls) -> "IntunedContext":
+        try:
+            current_context = cls._current.get()
+        except LookupError as e:
+            raise LookupError("No context found. Please use `IntunedContext.use()` to create a new context.") from e
+        return current_context
+    def __enter__(self) -> "IntunedContext":
+        """
+        Enter the context.
+        """
+        if self._token:
+            raise RuntimeError("Context was already entered with `__enter__`.")
+        self._token = self._current.set(self)
+        return self
+    def __exit__(self, exc_type: Optional[type], exc_value: Optional[BaseException], traceback: Optional[Any]) -> None:
+        """
+        Exit the context.
+        """
+        if not self._token:
+            raise RuntimeError("Context was not entered with `__enter__`.")
+        self._current.reset(self._token)
+        self._token = None

runtime/env.py ADDED Viewed

@@ -0,0 +1,13 @@
+import os
+def get_workspace_id():
+    return os.environ.get("INTUNED_WORKSPACE_ID")
+def get_project_id():
+    return os.environ.get("INTUNED_INTEGRATION_ID")
+def get_functions_domain():
+    return os.environ.get("FUNCTIONS_DOMAIN")

runtime/errors/__init__.py ADDED Viewed

@@ -0,0 +1,21 @@
+from .run_api_errors import ApiNotFoundError
+from .run_api_errors import AutomationError
+from .run_api_errors import AutomationNotCoroutineError
+from .run_api_errors import AutomationTimeoutError
+from .run_api_errors import NoAutomationInApiError
+from .run_api_errors import RunApiError
+from .run_api_errors import RunIdNotProvidedError
+from .run_api_errors import SessionMissingError
+from .trace_errors import TraceNotFoundError
+__all__ = [
+    "RunApiError",
+    "RunIdNotProvidedError",
+    "ApiNotFoundError",
+    "NoAutomationInApiError",
+    "AutomationNotCoroutineError",
+    "AutomationError",
+    "AutomationTimeoutError",
+    "TraceNotFoundError",
+    "SessionMissingError",
+]

runtime/errors/auth_session_errors.py ADDED Viewed

@@ -0,0 +1,9 @@
+from .run_api_errors import RunApiError
+class AuthSessionsNotEnabledError(RunApiError):
+    def __init__(self):
+        super().__init__(
+            "Auth sessions are not enabled",
+            "AuthRequiredError",
+        )

runtime/errors/run_api_errors.py ADDED Viewed

@@ -0,0 +1,120 @@
+from abc import ABC
+from typing import Any
+from typing import Iterable
+from typing import Literal
+RunErrorCode = Literal[
+    "APINotFoundError",
+    "InvalidAPIError",
+    "InvalidCheckError",
+    "AbortedError",
+    "AuthRequiredError",
+    "AuthCheckNotFoundError",
+    "AuthCheckFailedError",
+    "MaxLevelsExceededError",
+    "AutomationError",
+    "InternalInvalidInputError",
+]
+class RunApiError(Exception, ABC):
+    def __init__(self, message: str, code: RunErrorCode):
+        super().__init__(message)
+        self.code = code
+        self.details: Any = None
+    @property
+    def json(self) -> dict[str, Any]:
+        return {
+            "code": self.code,
+            "details": self.details,
+        }
+class RunIdNotProvidedError(RunApiError):
+    def __init__(self):
+        super().__init__(
+            "runId header not provided",
+            "InvalidAPIError",
+        )
+class ApiNotFoundError(RunApiError):
+    def __init__(self, module: str):
+        super().__init__(
+            f"Module {module} not found",
+            "APINotFoundError",
+        )
+class NoAutomationInApiError(RunApiError):
+    def __init__(self, module: str, automation_function_names: str | Iterable[str] = "automation"):
+        if isinstance(automation_function_names, str):
+            automation_function_names = [automation_function_names]
+        super().__init__(
+            f"Module {module} does not have {" or ".join([f"`{fn}`" for fn in automation_function_names])} function defined",
+            "APINotFoundError",
+        )
+class AutomationNotCoroutineError(RunApiError):
+    def __init__(self, module: str, automation_function_name: str = "automation"):
+        super().__init__(
+            f"`{automation_function_name}` function in module {module} is not a coroutine function",
+            "InvalidAPIError",
+        )
+class AutomationError(RunApiError):
+    def __init__(self, exception: BaseException):
+        # Get all public attributes of the exception
+        error_props = {key: str(value) for key, value in exception.__dict__.items() if not key.startswith("_")}
+        super().__init__(
+            str(exception),
+            "AutomationError",
+        )
+        self.details = {
+            "error_props": error_props,
+            "error_type": exception.__class__.__name__,
+            "name": exception.__class__.__name__,
+            "message": str(exception),
+        }
+class AutomationTimeoutError(RunApiError):
+    def __init__(self):
+        super().__init__(
+            "Run timed out",
+            "AbortedError",
+        )
+class SessionMissingError(RunApiError):
+    def __init__(self):
+        super().__init__(
+            "Session missing",
+            "AuthRequiredError",
+        )
+class InvalidSessionError(RunApiError):
+    def __init__(self):
+        super().__init__(
+            "Invalid auth session",
+            "AuthCheckFailedError",
+        )
+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/errors/trace_errors.py ADDED Viewed

@@ -0,0 +1,3 @@
+class TraceNotFoundError(Exception):
+    def __init__(self):
+        super().__init__("Trace file not found")

runtime/helpers/__init__.py ADDED Viewed

@@ -0,0 +1,5 @@
+from .extend_payload import extend_payload
+from .extend_timeout import extend_timeout
+from .get_auth_session_parameters import get_auth_session_parameters
+__all__ = ["extend_payload", "extend_timeout", "get_auth_session_parameters"]

runtime/helpers/extend_payload.py ADDED Viewed

@@ -0,0 +1,9 @@
+from runtime.context.context import IntunedContext
+from ..types import Payload
+from .extend_timeout import extend_timeout
+def extend_payload(*payload: Payload):
+    IntunedContext.current().extended_payloads += [*payload]
+    extend_timeout()

runtime/helpers/extend_timeout.py ADDED Viewed

@@ -0,0 +1,13 @@
+import asyncio
+from runtime.context.context import IntunedContext
+_debounce_time = 60  # seconds
+def extend_timeout():
+    context = IntunedContext.current()
+    if context.extend_timeout is not None:
+        call_extend_timeout_api = context.extend_timeout
+        asyncio.create_task(asyncio.wait_for(call_extend_timeout_api(), timeout=10))

runtime/helpers/get_auth_session_parameters.py ADDED Viewed

@@ -0,0 +1,14 @@
+from typing import Any
+from runtime.context.context import IntunedContext
+async def get_auth_session_parameters() -> dict[str, Any]:
+    """
+    Get the auth session parameters from the IntunedContext.
+    """
+    context = IntunedContext.current()
+    if context.get_auth_session_parameters is None:
+        raise Exception("get_auth_session_parameters failed due to an internal error (context was not found).")
+    return await context.get_auth_session_parameters()

runtime/py.typed ADDED Viewed

File without changes

runtime/run/__init__.py ADDED Viewed

@@ -0,0 +1,3 @@
+from .run_api import run_api
+__all__ = ["run_api"]

runtime/run/intuned_settings.py ADDED Viewed

@@ -0,0 +1,38 @@
+import json
+import os
+from dataclasses import dataclass
+from dataclasses import field
+from typing import Any
+from aiofiles import open
+@dataclass
+class AuthSessions:
+    enabled: bool = False
+@dataclass
+class IntunedSettings:
+    auth_sessions: AuthSessions = field(default_factory=AuthSessions)
+default_settings = IntunedSettings()
+def validate_settings(settings_dict: dict[Any, Any]) -> IntunedSettings:
+    auth_sessions = AuthSessions(enabled=settings_dict.get("authSessions", {}).get("enabled", False))
+    return IntunedSettings(auth_sessions=auth_sessions)
+async def load_intuned_settings() -> IntunedSettings:
+    settings_path = os.path.join(os.getcwd(), "Intuned.json")
+    if not os.path.exists(settings_path):
+        return default_settings
+    try:
+        async with open(settings_path) as settings_file:
+            content = await settings_file.read()
+            settings_dict = json.loads(content)
+        return validate_settings(settings_dict)
+    except json.JSONDecodeError as e:
+        raise Exception("Invalid Intuned.json file") from e

runtime/run/playwright_constructs.py ADDED Viewed

@@ -0,0 +1,19 @@
+from contextlib import asynccontextmanager
+from playwright.async_api import ProxySettings
+from ..browser import launch_chromium
+@asynccontextmanager
+async def get_production_playwright_constructs(
+    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):
+        try:
+            yield context, page
+        finally:
+            await context.close()

runtime/run/run_api.py ADDED Viewed

@@ -0,0 +1,233 @@
+import asyncio
+import functools
+import json
+import os.path
+from importlib import import_module
+from importlib.util import module_from_spec
+from importlib.util import spec_from_file_location
+from inspect import iscoroutinefunction
+from typing import Any
+from typing import Callable
+from typing import Coroutine
+from typing import Optional
+from typing import Protocol
+from tenacity import retry
+from tenacity import retry_if_not_result
+from tenacity import RetryError
+from tenacity import stop_after_attempt
+from runtime.browser.storage_state import get_storage_state
+from runtime.browser.storage_state import set_storage_state
+from runtime.context import IntunedContext
+from runtime.errors.run_api_errors import InvalidSessionError
+from runtime.errors.run_api_errors import RunApiError
+from runtime.types import RunAutomationSuccessResult
+from runtime.types.run_types import PayloadToAppend
+from runtime.types.run_types import RunApiParameters
+from ..errors import ApiNotFoundError
+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
+def import_function_from_api_dir(
+    *,
+    file_path: str,
+    base_dir: Optional[str] = None,
+    automation_function_name: str | None = None,
+) -> Callable[..., Coroutine[Any, Any, Any]]:
+    module_path = file_path.replace("/", ".")
+    def _import_module():
+        if base_dir is None:
+            return import_module(module_path)
+        else:
+            file_location = os.path.join(base_dir, f"{file_path}.py")
+            if not os.path.exists(file_location):
+                raise ApiNotFoundError(module_path)
+            spec = spec_from_file_location(os.path.basename(file_path), file_location)
+            if spec is None:
+                raise ApiNotFoundError(module_path)
+            module = module_from_spec(spec)
+            if spec.loader is None:
+                raise ApiNotFoundError(module_path)
+            spec.loader.exec_module(module)
+            return module
+    try:
+        module = _import_module()
+    except ModuleNotFoundError as e:
+        # if the top-level module does not exist, it is a 404
+        if e.name == module_path:
+            raise ApiNotFoundError(module_path) from e
+        # otherwise, it is an import error inside the user code
+        raise AutomationError(e) from e
+    except RunApiError:
+        raise
+    except BaseException as e:
+        raise AutomationError(e) from e
+    automation_functions_to_try: list[str] = []
+    if automation_function_name is not None:
+        automation_functions_to_try.append(automation_function_name)
+    else:
+        automation_functions_to_try.append("automation")
+        automation_functions_to_try.append("create")
+        automation_functions_to_try.append("check")
+    err: AttributeError | None = None
+    automation_coroutine = None
+    name = automation_functions_to_try[0]
+    for n in automation_functions_to_try:
+        name = n
+        try:
+            automation_coroutine = getattr(module, name)
+        except AttributeError as e:
+            err = e
+        else:
+            break
+    if automation_coroutine is None:
+        raise NoAutomationInApiError(module_path, automation_functions_to_try) from err
+    if not iscoroutinefunction(automation_coroutine):
+        raise AutomationNotCoroutineError(module_path)
+    return automation_coroutine
+class ImportFunction(Protocol):
+    def __call__(self, file_path: str, name: Optional[str] = None, /) -> Callable[..., Coroutine[Any, Any, Any]]: ...
+async def run_api(
+    parameters: RunApiParameters,
+    *,
+    import_function: ImportFunction | None = None,
+):
+    trace_started: bool = False
+    headless = False
+    proxy = None
+    cdp_address = None
+    if parameters.run_options.environment == "standalone":
+        headless = parameters.run_options.headless
+        proxy_config = parameters.run_options.proxy
+        if proxy_config is not None:
+            proxy = ProxySettings(
+                **proxy_config.model_dump(by_alias=True),
+            )
+    else:
+        cdp_address = parameters.run_options.cdp_address
+    async with get_production_playwright_constructs(
+        headless=headless,
+        proxy=proxy,
+        cdp_address=cdp_address,
+    ) as (context, page):
+        if parameters.tracing.enabled:
+            await context.tracing.start(screenshots=True, snapshots=True, sources=True)
+            trace_started = True
+        if parameters.auth is not None and parameters.auth.session.type == "state":
+            if parameters.auth.session.state is None:
+                raise InvalidSessionError()
+            state = parameters.auth.session.state
+            await set_storage_state(
+                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
+            )
+        )
+        async def _run_automation():
+            try:
+                automation_coroutine = import_function(parameters.automation_function.name)
+                if parameters.auth is not None and parameters.auth.run_check:
+                    retry_configs = retry(
+                        stop=stop_after_attempt(2),
+                        retry=retry_if_not_result(lambda result: result is True),
+                        reraise=True,
+                    )
+                    check_fn = import_function("auth-sessions/check")
+                    check_fn_with_retries = retry_configs(check_fn)
+                    try:
+                        check_result = await check_fn_with_retries(page)
+                    except RetryError:
+                        check_result = False
+                    if type(check_result) is not bool:
+                        raise AutomationError(TypeError("Check function must return a boolean"))
+                    if not check_result:
+                        raise InvalidSessionError()
+                automation_coroutine_with_page = functools.partial(automation_coroutine, page)
+                if parameters.automation_function.params is None:
+                    automation_result = await automation_coroutine_with_page()
+                else:
+                    automation_result = await automation_coroutine_with_page(parameters.automation_function.params)
+                try:
+                    json.dumps(automation_result)
+                except TypeError as e:
+                    raise AutomationError(TypeError("Result is not JSON serializable")) from e
+                response = RunAutomationSuccessResult(
+                    result=automation_result,
+                )
+                extended_payloads = IntunedContext.current().extended_payloads
+                if extended_payloads:
+                    response.payload_to_append = [
+                        PayloadToAppend(
+                            api_name=payload["api"],
+                            parameters=payload["parameters"],
+                        )
+                        for payload in extended_payloads
+                    ]
+                if parameters.retrieve_session:
+                    response.session = await get_storage_state(context)
+                return response
+            except RunApiError as e:
+                raise e
+            except Exception as e:
+                # Get all public attributes of the exception
+                raise AutomationError(e) from e
+        automation_task = None
+        try:
+            automation_task = asyncio.create_task(_run_automation())
+            # Shield will make the CancelledError get thrown directly here instead of inside `automation_task`
+            result = await asyncio.shield(automation_task)
+            return result
+        except asyncio.CancelledError:
+            # Manually cancel the automation task
+            if automation_task and not automation_task.done():
+                automation_task.cancel()
+                try:
+                    # Wait for the automation task to be cancelled for a brief moment
+                    await asyncio.wait_for(automation_task, timeout=0.1)
+                except (asyncio.CancelledError, asyncio.TimeoutError):
+                    pass
+            raise  # Re-raise the cancellation
+        finally:
+            if parameters.tracing.enabled is True and trace_started:
+                try:
+                    await context.tracing.stop(path=parameters.tracing.file_path)
+                except Exception as e:
+                    print("Error stopping tracing:", e)
+                    os.remove(parameters.tracing.file_path)
+            await context.close()