attune-sdk 0.1.0__py3-none-any.whl

attune/__init__.py

@@ -0,0 +1,60 @@
+"""
+Attune Python SDK — helpers for building actions and sensors.
+
+Quick start for actions::
+
+    import attune
+
+    def main(name: str, count: int = 1):
+        return {"greeting": f"Hello, {name}!" * count}
+
+    attune.run_action(main)
+
+Quick start for sensors::
+
+    import attune
+
+    class MySensor(attune.PollingSensor):
+        def setup(self):
+            self.interval = 5.0
+
+        def poll(self, rule):
+            self.emit({"value": 42}, rule=rule)
+
+    attune.run_sensor(MySensor)
+
+Access execution context anywhere::
+
+    import attune
+    print(attune.context.execution_id)      # action context
+    print(attune.sensor_context.sensor_ref)  # sensor context
+"""
+
+from attune.action import run_action
+from attune.api_client import AuthenticatedClient, Client
+from attune.client import AttuneClient
+from attune.context import (
+    ActionContext,
+    SensorContext,
+    action_context as context,
+    sensor_context,
+)
+from attune.sensor import AsyncPollingSensor, PollingSensor, RuleState, Sensor, run_sensor
+
+__all__ = [
+    "run_action",
+    "run_sensor",
+    "context",
+    "sensor_context",
+    "ActionContext",
+    "AsyncPollingSensor",
+    "AttuneClient",
+    "AuthenticatedClient",
+    "Client",
+    "PollingSensor",
+    "RuleState",
+    "Sensor",
+    "SensorContext",
+]
+
+__version__ = "0.1.0"

attune/action.py

@@ -0,0 +1,112 @@
+"""
+Action runner — handles stdin parameter parsing, output formatting, and error handling.
+
+Usage::
+
+    import attune
+
+    def main(name: str, count: int = 1):
+        return {"message": f"Hello, {name}!" * count}
+
+    attune.run_action(main)
+
+The entrypoint function declares whatever parameters it needs — they are
+passed as keyword arguments from the parsed stdin JSON. Parameters not
+declared by the function are silently ignored (via ``**kwargs`` or filtering).
+
+Exit codes:
+- 0: success (result is written to stdout as JSON)
+- 1: failure (error details written to stdout as JSON with ``success: false``)
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+import traceback
+from typing import Any, Callable
+
+
+def read_params() -> dict[str, Any]:
+    """Read action parameters from stdin (JSON format).
+
+    The Attune worker delivers parameters as a single JSON object on stdin.
+    """
+    raw = sys.stdin.read().strip()
+    if not raw:
+        return {}
+    return json.loads(raw)
+
+
+def emit_result(payload: Any) -> None:
+    """Write a JSON result to stdout."""
+    print(json.dumps(payload, default=str))
+
+
+def emit_error(message: str, *, details: Any | None = None) -> None:
+    """Write a JSON error to stdout."""
+    payload: dict[str, Any] = {"success": False, "error": message}
+    if details is not None:
+        payload["details"] = details
+    print(json.dumps(payload, default=str))
+
+
+def run_action(
+    entrypoint: Callable[..., Any],
+    *,
+    catch_exceptions: bool = True,
+) -> None:
+    """Run an action entrypoint with automatic parameter parsing and output handling.
+
+    The ``entrypoint`` is called with ``**params`` — each key in the JSON
+    input becomes a keyword argument. Authors write functions that declare
+    exactly the parameters they need::
+
+        def main(url: str, method: str = "GET", timeout: int = 30):
+            ...
+
+    If the function accepts ``**kwargs``, all parameters are passed through.
+    Otherwise, only parameters matching declared argument names are passed
+    (extras are silently dropped).
+
+    Args:
+        entrypoint: The action function to execute.
+        catch_exceptions: If True (default), uncaught exceptions are caught and
+            reported as JSON errors on stdout with exit code 1. Set to False for
+            development/debugging to let exceptions propagate.
+    """
+    try:
+        params = read_params()
+
+        # Filter params to only those the function accepts, unless it has **kwargs
+        import inspect
+
+        sig = inspect.signature(entrypoint)
+        has_var_keyword = any(
+            p.kind == p.VAR_KEYWORD for p in sig.parameters.values()
+        )
+
+        if has_var_keyword:
+            call_params = params
+        else:
+            accepted = set(sig.parameters.keys())
+            call_params = {k: v for k, v in params.items() if k in accepted}
+
+        result = entrypoint(**call_params)
+
+        # Emit result
+        if result is None:
+            result = {}
+        emit_result(result)
+        sys.exit(0)
+
+    except SystemExit:
+        raise
+    except Exception as exc:
+        if not catch_exceptions:
+            raise
+        emit_error(
+            str(exc),
+            details=traceback.format_exc() if sys.stderr.isatty() else None,
+        )
+        sys.exit(1)

attune/api_client/__init__.py

@@ -0,0 +1,8 @@
+"""A client library for accessing Attune API"""
+
+from .client import AuthenticatedClient, Client
+
+__all__ = (
+    "AuthenticatedClient",
+    "Client",
+)

attune/api_client/api/__init__.py

@@ -0,0 +1 @@
+"""Contains methods for accessing the API"""

attune/api_client/api/actions/__init__.py

@@ -0,0 +1 @@
+"""Contains endpoint functions for accessing the API"""

attune/api_client/api/actions/delete_action.py

@@ -0,0 +1,159 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.success_response import SuccessResponse
+from ...types import Response
+
+
+def _get_kwargs(
+    ref: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "delete",
+        "url": "/api/v1/actions/{ref}".format(
+            ref=quote(str(ref), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Any | SuccessResponse | None:
+    if response.status_code == 200:
+        response_200 = SuccessResponse.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Any | SuccessResponse]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | SuccessResponse]:
+    """Delete an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+    """
+
+    kwargs = _get_kwargs(
+        ref=ref,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Any | SuccessResponse | None:
+    """Delete an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+    """
+
+    return sync_detailed(
+        ref=ref,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | SuccessResponse]:
+    """Delete an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | SuccessResponse]
+    """
+
+    kwargs = _get_kwargs(
+        ref=ref,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Any | SuccessResponse | None:
+    """Delete an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | SuccessResponse
+    """
+
+    return (
+        await asyncio_detailed(
+            ref=ref,
+            client=client,
+        )
+    ).parsed

attune/api_client/api/actions/get_action.py

@@ -0,0 +1,159 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.get_action_response_200 import GetActionResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    ref: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/actions/{ref}".format(
+            ref=quote(str(ref), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Any | GetActionResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetActionResponse200.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Any | GetActionResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | GetActionResponse200]:
+    """Get a single action by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetActionResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        ref=ref,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Any | GetActionResponse200 | None:
+    """Get a single action by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetActionResponse200
+    """
+
+    return sync_detailed(
+        ref=ref,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | GetActionResponse200]:
+    """Get a single action by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetActionResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        ref=ref,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Any | GetActionResponse200 | None:
+    """Get a single action by reference
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetActionResponse200
+    """
+
+    return (
+        await asyncio_detailed(
+            ref=ref,
+            client=client,
+        )
+    ).parsed

attune/api_client/api/actions/get_queue_stats.py

@@ -0,0 +1,159 @@
+from http import HTTPStatus
+from typing import Any, cast
+from urllib.parse import quote
+
+import httpx
+
+from ... import errors
+from ...client import AuthenticatedClient, Client
+from ...models.get_queue_stats_response_200 import GetQueueStatsResponse200
+from ...types import Response
+
+
+def _get_kwargs(
+    ref: str,
+) -> dict[str, Any]:
+
+    _kwargs: dict[str, Any] = {
+        "method": "get",
+        "url": "/api/v1/actions/{ref}/queue-stats".format(
+            ref=quote(str(ref), safe=""),
+        ),
+    }
+
+    return _kwargs
+
+
+def _parse_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Any | GetQueueStatsResponse200 | None:
+    if response.status_code == 200:
+        response_200 = GetQueueStatsResponse200.from_dict(response.json())
+
+        return response_200
+
+    if response.status_code == 404:
+        response_404 = cast(Any, None)
+        return response_404
+
+    if client.raise_on_unexpected_status:
+        raise errors.UnexpectedStatus(response.status_code, response.content)
+    else:
+        return None
+
+
+def _build_response(
+    *, client: AuthenticatedClient | Client, response: httpx.Response
+) -> Response[Any | GetQueueStatsResponse200]:
+    return Response(
+        status_code=HTTPStatus(response.status_code),
+        content=response.content,
+        headers=response.headers,
+        parsed=_parse_response(client=client, response=response),
+    )
+
+
+def sync_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | GetQueueStatsResponse200]:
+    """Get queue statistics for an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetQueueStatsResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        ref=ref,
+    )
+
+    response = client.get_httpx_client().request(
+        **kwargs,
+    )
+
+    return _build_response(client=client, response=response)
+
+
+def sync(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Any | GetQueueStatsResponse200 | None:
+    """Get queue statistics for an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetQueueStatsResponse200
+    """
+
+    return sync_detailed(
+        ref=ref,
+        client=client,
+    ).parsed
+
+
+async def asyncio_detailed(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Response[Any | GetQueueStatsResponse200]:
+    """Get queue statistics for an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Response[Any | GetQueueStatsResponse200]
+    """
+
+    kwargs = _get_kwargs(
+        ref=ref,
+    )
+
+    response = await client.get_async_httpx_client().request(**kwargs)
+
+    return _build_response(client=client, response=response)
+
+
+async def asyncio(
+    ref: str,
+    *,
+    client: AuthenticatedClient,
+) -> Any | GetQueueStatsResponse200 | None:
+    """Get queue statistics for an action
+
+    Args:
+        ref (str):
+
+    Raises:
+        errors.UnexpectedStatus: If the server returns an undocumented status code and Client.raise_on_unexpected_status is True.
+        httpx.TimeoutException: If the request takes longer than Client.timeout.
+
+    Returns:
+        Any | GetQueueStatsResponse200
+    """
+
+    return (
+        await asyncio_detailed(
+            ref=ref,
+            client=client,
+        )
+    ).parsed