algokit-utils 5.0.0a3__py3-none-any.whl

algokit_indexer_client/config.py

@@ -0,0 +1,36 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+
+@dataclass(slots=True)
+class ClientConfig:
+    """Runtime configuration for IndexerClient.
+
+    Attributes:
+        base_url: Base URL for the API endpoint.
+        token: Optional authentication token.
+        token_header: Header name for the authentication token.
+        timeout: Request timeout in seconds. Set to None for no timeout.
+        verify: SSL certificate verification. Can be a boolean or path to CA bundle.
+        extra_headers: Additional headers to include in all requests.
+        max_retries: Maximum number of retry attempts for transient failures.
+            Set to 0 to disable retries. Default is 4 (5 total attempts).
+            Note: Retries are automatically disabled when a custom http_client
+            is provided to avoid conflicts with the client's own retry mechanism.
+    """
+
+    base_url: str = "http://localhost:8980"
+    token: str | None = None
+    token_header: str = "X-Indexer-API-Token"
+    timeout: float | None = 30.0
+    verify: bool | str = True
+    extra_headers: dict[str, str] = field(default_factory=dict)
+    max_retries: int = 4
+
+    def resolve_headers(self) -> dict[str, str]:
+        headers = dict(self.extra_headers)
+        if self.token:
+            headers[self.token_header] = self.token
+        return headers

algokit_indexer_client/exceptions.py

@@ -0,0 +1,59 @@
+# AUTO-GENERATED: oas_generator
+
+from http import HTTPStatus
+from json import JSONDecodeError, loads
+
+
+class ApiError(RuntimeError):
+    """Base exception for errors raised by generated clients."""
+
+
+def _format_payload(payload: object) -> str | None:  # noqa: C901, PLR0912
+    """Extract a human-friendly message from a payload."""
+    if payload is None:
+        return None
+
+    text: str | None = None
+    if isinstance(payload, (bytes | bytearray | memoryview)):
+        try:
+            text = bytes(payload).decode("utf-8", errors="ignore")
+        except Exception:
+            text = None
+    if text is None:
+        text = str(payload)
+
+    result = text.strip()
+    if not result:
+        return None
+
+    try:
+        decoded = loads(result)
+    except (JSONDecodeError, TypeError):
+        return result
+
+    if isinstance(decoded, dict):
+        for key in ("message", "msg", "error", "detail", "description", "data"):
+            value = decoded.get(key)
+            if isinstance(value, str):
+                candidate = value.strip()
+                if candidate:
+                    result = candidate
+                    break
+
+    if isinstance(decoded, list) and decoded:
+        first = decoded[0]
+        if isinstance(first, str):
+            candidate = first.strip()
+            if candidate:
+                result = candidate
+
+    return result
+
+
+class UnexpectedStatusError(ApiError):
+    def __init__(self, status_code: int, payload: object) -> None:
+        message = _format_payload(payload)
+        description = f" {message}" if message else ""
+        super().__init__(f"Unexpected status code {status_code}{description}")
+        self.status_code = HTTPStatus(status_code)
+        self.payload = payload

algokit_indexer_client/models/__init__.py

@@ -0,0 +1,148 @@
+# AUTO-GENERATED: oas_generator
+
+
+from ._account import Account
+from ._account_participation import AccountParticipation
+from ._account_response import AccountResponse
+from ._account_state_delta import AccountStateDelta
+from ._accounts_response import AccountsResponse
+from ._application import Application
+from ._application_local_state import ApplicationLocalState
+from ._application_local_states_response import ApplicationLocalStatesResponse
+from ._application_log_data import ApplicationLogData
+from ._application_logs_response import ApplicationLogsResponse
+from ._application_params import ApplicationParams
+from ._application_response import ApplicationResponse
+from ._application_state_schema import ApplicationStateSchema
+from ._applications_response import ApplicationsResponse
+from ._asset import Asset
+from ._asset_balances_response import AssetBalancesResponse
+from ._asset_holding import AssetHolding
+from ._asset_holdings_response import AssetHoldingsResponse
+from ._asset_params import AssetParams
+from ._asset_response import AssetResponse
+from ._assets_response import AssetsResponse
+from ._block import Block
+from ._block_headers_response import BlockHeadersResponse
+from ._block_rewards import BlockRewards
+from ._block_upgrade_state import BlockUpgradeState
+from ._block_upgrade_vote import BlockUpgradeVote
+from ._box import Box
+from ._box_descriptor import BoxDescriptor
+from ._box_reference import BoxReference
+from ._boxes_response import BoxesResponse
+from ._error_response import ErrorResponse
+from ._eval_delta import EvalDelta
+from ._eval_delta_key_value import EvalDeltaKeyValue
+from ._hash_factory import HashFactory
+from ._hb_proof_fields import HbProofFields
+from ._health_check import HealthCheck
+from ._holding_ref import HoldingRef
+from ._indexer_state_proof_message import IndexerStateProofMessage
+from ._locals_ref import LocalsRef
+from ._merkle_array_proof import MerkleArrayProof
+from ._mini_asset_holding import MiniAssetHolding
+from ._on_completion import OnCompletion
+from ._participation_updates import ParticipationUpdates
+from ._resource_ref import ResourceRef
+from ._state_delta import StateDelta
+from ._state_proof_fields import StateProofFields
+from ._state_proof_participant import StateProofParticipant
+from ._state_proof_reveal import StateProofReveal
+from ._state_proof_sig_slot import StateProofSigSlot
+from ._state_proof_signature import StateProofSignature
+from ._state_proof_tracking import StateProofTracking
+from ._state_proof_verifier import StateProofVerifier
+from ._state_schema import StateSchema
+from ._teal_key_value import TealKeyValue
+from ._teal_key_value_store import TealKeyValueStore
+from ._teal_value import TealValue
+from ._transaction import Transaction
+from ._transaction_application import TransactionApplication
+from ._transaction_asset_config import TransactionAssetConfig
+from ._transaction_asset_freeze import TransactionAssetFreeze
+from ._transaction_asset_transfer import TransactionAssetTransfer
+from ._transaction_heartbeat import TransactionHeartbeat
+from ._transaction_keyreg import TransactionKeyreg
+from ._transaction_payment import TransactionPayment
+from ._transaction_response import TransactionResponse
+from ._transaction_signature import TransactionSignature
+from ._transaction_signature_logicsig import TransactionSignatureLogicsig
+from ._transaction_signature_multisig import TransactionSignatureMultisig
+from ._transaction_signature_multisig_subsignature import TransactionSignatureMultisigSubsignature
+from ._transaction_state_proof import TransactionStateProof
+from ._transactions_response import TransactionsResponse
+
+__all__ = [
+    "Account",
+    "AccountParticipation",
+    "AccountResponse",
+    "AccountStateDelta",
+    "AccountsResponse",
+    "Application",
+    "ApplicationLocalState",
+    "ApplicationLocalStatesResponse",
+    "ApplicationLogData",
+    "ApplicationLogsResponse",
+    "ApplicationParams",
+    "ApplicationResponse",
+    "ApplicationStateSchema",
+    "ApplicationsResponse",
+    "Asset",
+    "AssetBalancesResponse",
+    "AssetHolding",
+    "AssetHoldingsResponse",
+    "AssetParams",
+    "AssetResponse",
+    "AssetsResponse",
+    "Block",
+    "BlockHeadersResponse",
+    "BlockRewards",
+    "BlockUpgradeState",
+    "BlockUpgradeVote",
+    "Box",
+    "BoxDescriptor",
+    "BoxReference",
+    "BoxesResponse",
+    "ErrorResponse",
+    "EvalDelta",
+    "EvalDeltaKeyValue",
+    "HashFactory",
+    "HbProofFields",
+    "HealthCheck",
+    "HoldingRef",
+    "IndexerStateProofMessage",
+    "LocalsRef",
+    "MerkleArrayProof",
+    "MiniAssetHolding",
+    "OnCompletion",
+    "ParticipationUpdates",
+    "ResourceRef",
+    "StateDelta",
+    "StateProofFields",
+    "StateProofParticipant",
+    "StateProofReveal",
+    "StateProofSigSlot",
+    "StateProofSignature",
+    "StateProofTracking",
+    "StateProofVerifier",
+    "StateSchema",
+    "TealKeyValue",
+    "TealKeyValueStore",
+    "TealValue",
+    "Transaction",
+    "TransactionApplication",
+    "TransactionAssetConfig",
+    "TransactionAssetFreeze",
+    "TransactionAssetTransfer",
+    "TransactionHeartbeat",
+    "TransactionKeyreg",
+    "TransactionPayment",
+    "TransactionResponse",
+    "TransactionSignature",
+    "TransactionSignatureLogicsig",
+    "TransactionSignatureMultisig",
+    "TransactionSignatureMultisigSubsignature",
+    "TransactionStateProof",
+    "TransactionsResponse",
+]

algokit_indexer_client/models/_account.py

@@ -0,0 +1,161 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._account_participation import AccountParticipation
+from ._application import Application
+from ._application_local_state import ApplicationLocalState
+from ._application_state_schema import ApplicationStateSchema
+from ._asset import Asset
+from ._asset_holding import AssetHolding
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class Account:
+    """
+    Account information at a given round.
+
+    Definition:
+    data/basics/userBalance.go : AccountData
+    """
+
+    address: str = field(
+        default="",
+        metadata=wire("address"),
+    )
+    amount: int = field(
+        default=0,
+        metadata=wire("amount"),
+    )
+    amount_without_pending_rewards: int = field(
+        default=0,
+        metadata=wire("amount-without-pending-rewards"),
+    )
+    min_balance: int = field(
+        default=0,
+        metadata=wire("min-balance"),
+    )
+    pending_rewards: int = field(
+        default=0,
+        metadata=wire("pending-rewards"),
+    )
+    rewards: int = field(
+        default=0,
+        metadata=wire("rewards"),
+    )
+    round_: int = field(
+        default=0,
+        metadata=wire("round"),
+    )
+    status: str = field(
+        default="",
+        metadata=wire("status"),
+    )
+    total_apps_opted_in: int = field(
+        default=0,
+        metadata=wire("total-apps-opted-in"),
+    )
+    total_assets_opted_in: int = field(
+        default=0,
+        metadata=wire("total-assets-opted-in"),
+    )
+    total_box_bytes: int = field(
+        default=0,
+        metadata=wire("total-box-bytes"),
+    )
+    total_boxes: int = field(
+        default=0,
+        metadata=wire("total-boxes"),
+    )
+    total_created_apps: int = field(
+        default=0,
+        metadata=wire("total-created-apps"),
+    )
+    total_created_assets: int = field(
+        default=0,
+        metadata=wire("total-created-assets"),
+    )
+    apps_local_state: list[ApplicationLocalState] | None = field(
+        default=None,
+        metadata=wire(
+            "apps-local-state",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: ApplicationLocalState, raw),
+        ),
+    )
+    apps_total_extra_pages: int | None = field(
+        default=None,
+        metadata=wire("apps-total-extra-pages"),
+    )
+    apps_total_schema: ApplicationStateSchema | None = field(
+        default=None,
+        metadata=nested("apps-total-schema", lambda: ApplicationStateSchema),
+    )
+    assets: list[AssetHolding] | None = field(
+        default=None,
+        metadata=wire(
+            "assets",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: AssetHolding, raw),
+        ),
+    )
+    auth_addr: str | None = field(
+        default=None,
+        metadata=wire("auth-addr"),
+    )
+    closed_at_round: int | None = field(
+        default=None,
+        metadata=wire("closed-at-round"),
+    )
+    created_apps: list[Application] | None = field(
+        default=None,
+        metadata=wire(
+            "created-apps",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: Application, raw),
+        ),
+    )
+    created_assets: list[Asset] | None = field(
+        default=None,
+        metadata=wire(
+            "created-assets",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: Asset, raw),
+        ),
+    )
+    created_at_round: int | None = field(
+        default=None,
+        metadata=wire("created-at-round"),
+    )
+    deleted: bool | None = field(
+        default=None,
+        metadata=wire("deleted"),
+    )
+    incentive_eligible: bool | None = field(
+        default=None,
+        metadata=wire("incentive-eligible"),
+    )
+    last_heartbeat: int | None = field(
+        default=None,
+        metadata=wire("last-heartbeat"),
+    )
+    last_proposed: int | None = field(
+        default=None,
+        metadata=wire("last-proposed"),
+    )
+    participation: AccountParticipation | None = field(
+        default=None,
+        metadata=nested("participation", lambda: AccountParticipation),
+    )
+    reward_base: int | None = field(
+        default=None,
+        metadata=wire("reward-base"),
+    )
+    sig_type: str | None = field(
+        default=None,
+        metadata=wire("sig-type"),
+    )

algokit_indexer_client/models/_account_participation.py

@@ -0,0 +1,53 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._serde_helpers import decode_fixed_bytes_base64, encode_fixed_bytes_base64
+
+
+@dataclass(slots=True)
+class AccountParticipation:
+    """
+    AccountParticipation describes the parameters used by this account in consensus
+    protocol.
+    """
+
+    selection_participation_key: bytes = field(
+        default=b"",
+        metadata=wire(
+            "selection-participation-key",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    vote_first_valid: int = field(
+        default=0,
+        metadata=wire("vote-first-valid"),
+    )
+    vote_key_dilution: int = field(
+        default=0,
+        metadata=wire("vote-key-dilution"),
+    )
+    vote_last_valid: int = field(
+        default=0,
+        metadata=wire("vote-last-valid"),
+    )
+    vote_participation_key: bytes = field(
+        default=b"",
+        metadata=wire(
+            "vote-participation-key",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    state_proof_key: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "state-proof-key",
+            encode=lambda v: encode_fixed_bytes_base64(v, 64),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 64),
+        ),
+    )

algokit_indexer_client/models/_account_response.py

@@ -0,0 +1,19 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._account import Account
+
+
+@dataclass(slots=True)
+class AccountResponse:
+    account: Account = field(
+        metadata=nested("account", lambda: Account, required=True),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )

algokit_indexer_client/models/_account_state_delta.py

@@ -0,0 +1,29 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._eval_delta_key_value import EvalDeltaKeyValue
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class AccountStateDelta:
+    """
+    Application state delta.
+    """
+
+    address: str = field(
+        default="",
+        metadata=wire("address"),
+    )
+    delta: list[EvalDeltaKeyValue] = field(
+        default_factory=list,
+        metadata=wire(
+            "delta",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: EvalDeltaKeyValue, raw),
+        ),
+    )

algokit_indexer_client/models/_accounts_response.py

@@ -0,0 +1,29 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._account import Account
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class AccountsResponse:
+    accounts: list[Account] = field(
+        default_factory=list,
+        metadata=wire(
+            "accounts",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: Account, raw),
+        ),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )
+    next_token: str | None = field(
+        default=None,
+        metadata=wire("next-token"),
+    )

algokit_indexer_client/models/_application.py

@@ -0,0 +1,35 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._application_params import ApplicationParams
+
+
+@dataclass(slots=True)
+class Application:
+    """
+    Application index and its parameters
+    """
+
+    params: ApplicationParams = field(
+        metadata=nested("params", lambda: ApplicationParams, required=True),
+    )
+    id_: int = field(
+        default=0,
+        metadata=wire("id"),
+    )
+    created_at_round: int | None = field(
+        default=None,
+        metadata=wire("created-at-round"),
+    )
+    deleted: bool | None = field(
+        default=None,
+        metadata=wire("deleted"),
+    )
+    deleted_at_round: int | None = field(
+        default=None,
+        metadata=wire("deleted-at-round"),
+    )

algokit_indexer_client/models/_application_local_state.py

@@ -0,0 +1,45 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._application_state_schema import ApplicationStateSchema
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+from ._teal_key_value import TealKeyValue
+
+
+@dataclass(slots=True)
+class ApplicationLocalState:
+    """
+    Stores local state associated with an application.
+    """
+
+    schema: ApplicationStateSchema = field(
+        metadata=nested("schema", lambda: ApplicationStateSchema, required=True),
+    )
+    id_: int = field(
+        default=0,
+        metadata=wire("id"),
+    )
+    closed_out_at_round: int | None = field(
+        default=None,
+        metadata=wire("closed-out-at-round"),
+    )
+    deleted: bool | None = field(
+        default=None,
+        metadata=wire("deleted"),
+    )
+    key_value: list[TealKeyValue] | None = field(
+        default=None,
+        metadata=wire(
+            "key-value",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: TealKeyValue, raw),
+        ),
+    )
+    opted_in_at_round: int | None = field(
+        default=None,
+        metadata=wire("opted-in-at-round"),
+    )

algokit_indexer_client/models/_application_local_states_response.py

@@ -0,0 +1,29 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._application_local_state import ApplicationLocalState
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class ApplicationLocalStatesResponse:
+    apps_local_states: list[ApplicationLocalState] = field(
+        default_factory=list,
+        metadata=wire(
+            "apps-local-states",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: ApplicationLocalState, raw),
+        ),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )
+    next_token: str | None = field(
+        default=None,
+        metadata=wire("next-token"),
+    )

algokit_indexer_client/models/_application_log_data.py

@@ -0,0 +1,28 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._serde_helpers import decode_bytes_sequence, encode_bytes_sequence
+
+
+@dataclass(slots=True)
+class ApplicationLogData:
+    """
+    Stores the global information associated with an application.
+    """
+
+    logs: list[bytes] = field(
+        default_factory=list,
+        metadata=wire(
+            "logs",
+            encode=encode_bytes_sequence,
+            decode=decode_bytes_sequence,
+        ),
+    )
+    tx_id: str = field(
+        default="",
+        metadata=wire("txid"),
+    )