arete-sdk 0.11.0__tar.gz

arete_sdk-0.11.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Arete
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

arete_sdk-0.11.0/PKG-INFO

@@ -0,0 +1,157 @@
+Metadata-Version: 2.4
+Name: arete-sdk
+Version: 0.11.0
+Summary: Python SDK for Arete
+Author: Arete Team
+License-Expression: MIT
+Project-URL: Homepage, https://arete.run
+Project-URL: Repository, https://github.com/AreteA4/arete
+Project-URL: Documentation, https://docs.arete.run
+Project-URL: Issues, https://github.com/AreteA4/arete/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: websockets>=12.0
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Dynamic: license-file
+
+# arete-sdk
+
+> **Work in Progress:** This SDK is under active development and has not yet been published to PyPI.
+
+Python SDK for Arete — real-time Solana program data streaming. The Python SDK is an
+idiomatic projection of the same core API exposed by `@usearete/sdk` (TypeScript),
+`@usearete/react`, and the `arete-sdk` Rust crate: same nouns, same semantics, native
+Python idiom. See `docs/internal/sdk-core-api.md` for the canonical surface.
+
+## Installation
+
+```bash
+# Not yet published - install from source for development
+pip install -e .
+```
+
+Requires Python 3.9+. Runtime dependencies: `websockets`, `httpx`.
+
+## Quick start
+
+```python
+import arete
+from my_generated_stack import ORE_STREAM_STACK  # generated by `a4 sdk create --python`
+
+async def main():
+    async with await arete.Arete.connect(
+        ORE_STREAM_STACK,
+        auth=arete.AuthConfig(publishable_key="a4_pk_..."),
+    ) as a4:
+        # Live stream of merged entities (patches applied, removals filtered)
+        async for round in a4.views.ore_round.latest.use(take=10):
+            print(round)
+            break
+
+        # Keyed state view, one-shot read
+        round = await a4.views.ore_round.state.get(round_id=42)
+
+        # Raw update stream with the full taxonomy (upsert | patch | remove | delete)
+        async for update in a4.views.ore_round.latest.watch(filters={"state.status": "open"}):
+            print(update.op, update.key)
+            break
+```
+
+## Program SDKs
+
+Raw builders are pure and work offline — no connection required. Instruction
+parameters use the IDL wire names, and unknown parameters fail closed.
+
+```python
+from my_generated_stack import programs
+
+async def build_and_send(a4, wallet_address):
+    # Pure, offline instruction building (also on the connected client:
+    # a4.programs.ore.raw.deploy.build(...))
+    ix = programs.ore_deploy(
+        amount=1_000_000,
+        squares=3,
+        signer=wallet_address,
+        authority=wallet_address,
+        round="11111111111111111111111111111111",
+        entropyVar="11111111111111111111111111111111",
+        entropyProgram=programs.ENTROPY_PROGRAM_ID,
+    )
+
+    # Typed PDA derivation
+    miner, bump = programs.OrePdas.miner.derive(authority=wallet_address)
+
+    # Release-addressed account reads over HTTP
+    miner_account = await a4.programs.ore.accounts.miner.fetch(miner)
+
+    # Execute built instructions through your wallet
+    receipt = await a4.transaction([ix])
+    return receipt
+```
+
+Stacks that ship semantic operations (via SDK extensions) also expose
+`instructions` / `transactions` / `flows`, which prepare portable operations:
+
+```python
+async def execute_semantic(a4):
+    prepared = await a4.programs.ore.instructions.deploy.prepare(amount=1_000_000)
+    receipt = await a4.execute(prepared)
+    if receipt.transaction.slot is not None:
+        await a4.wait_for_processed_slot(receipt.transaction.slot)
+```
+
+Wallets implement the `arete.WalletAdapter` protocol (`async sign_and_send(...)`).
+Execution outcomes follow the shared four-state model
+(`confirmed | not-submitted | submitted-unknown | chain-failed`), and
+`wait_for_processed_slot` bridges writes back to view state.
+
+## Chain and transaction relay
+
+```python
+async def read_chain(a4, address):
+    clock = await a4.chain.clock()
+    lamports = await a4.chain.lamports(address)
+    # One request per batch, up to 100 addresses; items align with the input.
+    accounts = await a4.chain.accounts([address])
+    blockhash = await a4.transactions.get_latest_blockhash()
+    return clock, lamports, accounts, blockhash
+```
+
+## Sessions (multi-stack)
+
+```python
+async def stream_session(auth):
+    session = await arete.create_session(stacks={"ore": ORE_STREAM_STACK}, auth=auth)
+    async for round in session.stacks.ore.views.ore_round.latest.use():
+        print(round)
+        break
+    await session.close()
+```
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+python -m pytest tests/ -q
+```
+
+## License
+
+MIT
+
+## Links
+
+- [Repository](https://github.com/AreteA4/arete)
+- [Documentation](https://docs.arete.run)
+- [Issues](https://github.com/AreteA4/arete/issues)

arete_sdk-0.11.0/README.md

@@ -0,0 +1,130 @@
+# arete-sdk
+
+> **Work in Progress:** This SDK is under active development and has not yet been published to PyPI.
+
+Python SDK for Arete — real-time Solana program data streaming. The Python SDK is an
+idiomatic projection of the same core API exposed by `@usearete/sdk` (TypeScript),
+`@usearete/react`, and the `arete-sdk` Rust crate: same nouns, same semantics, native
+Python idiom. See `docs/internal/sdk-core-api.md` for the canonical surface.
+
+## Installation
+
+```bash
+# Not yet published - install from source for development
+pip install -e .
+```
+
+Requires Python 3.9+. Runtime dependencies: `websockets`, `httpx`.
+
+## Quick start
+
+```python
+import arete
+from my_generated_stack import ORE_STREAM_STACK  # generated by `a4 sdk create --python`
+
+async def main():
+    async with await arete.Arete.connect(
+        ORE_STREAM_STACK,
+        auth=arete.AuthConfig(publishable_key="a4_pk_..."),
+    ) as a4:
+        # Live stream of merged entities (patches applied, removals filtered)
+        async for round in a4.views.ore_round.latest.use(take=10):
+            print(round)
+            break
+
+        # Keyed state view, one-shot read
+        round = await a4.views.ore_round.state.get(round_id=42)
+
+        # Raw update stream with the full taxonomy (upsert | patch | remove | delete)
+        async for update in a4.views.ore_round.latest.watch(filters={"state.status": "open"}):
+            print(update.op, update.key)
+            break
+```
+
+## Program SDKs
+
+Raw builders are pure and work offline — no connection required. Instruction
+parameters use the IDL wire names, and unknown parameters fail closed.
+
+```python
+from my_generated_stack import programs
+
+async def build_and_send(a4, wallet_address):
+    # Pure, offline instruction building (also on the connected client:
+    # a4.programs.ore.raw.deploy.build(...))
+    ix = programs.ore_deploy(
+        amount=1_000_000,
+        squares=3,
+        signer=wallet_address,
+        authority=wallet_address,
+        round="11111111111111111111111111111111",
+        entropyVar="11111111111111111111111111111111",
+        entropyProgram=programs.ENTROPY_PROGRAM_ID,
+    )
+
+    # Typed PDA derivation
+    miner, bump = programs.OrePdas.miner.derive(authority=wallet_address)
+
+    # Release-addressed account reads over HTTP
+    miner_account = await a4.programs.ore.accounts.miner.fetch(miner)
+
+    # Execute built instructions through your wallet
+    receipt = await a4.transaction([ix])
+    return receipt
+```
+
+Stacks that ship semantic operations (via SDK extensions) also expose
+`instructions` / `transactions` / `flows`, which prepare portable operations:
+
+```python
+async def execute_semantic(a4):
+    prepared = await a4.programs.ore.instructions.deploy.prepare(amount=1_000_000)
+    receipt = await a4.execute(prepared)
+    if receipt.transaction.slot is not None:
+        await a4.wait_for_processed_slot(receipt.transaction.slot)
+```
+
+Wallets implement the `arete.WalletAdapter` protocol (`async sign_and_send(...)`).
+Execution outcomes follow the shared four-state model
+(`confirmed | not-submitted | submitted-unknown | chain-failed`), and
+`wait_for_processed_slot` bridges writes back to view state.
+
+## Chain and transaction relay
+
+```python
+async def read_chain(a4, address):
+    clock = await a4.chain.clock()
+    lamports = await a4.chain.lamports(address)
+    # One request per batch, up to 100 addresses; items align with the input.
+    accounts = await a4.chain.accounts([address])
+    blockhash = await a4.transactions.get_latest_blockhash()
+    return clock, lamports, accounts, blockhash
+```
+
+## Sessions (multi-stack)
+
+```python
+async def stream_session(auth):
+    session = await arete.create_session(stacks={"ore": ORE_STREAM_STACK}, auth=auth)
+    async for round in session.stacks.ore.views.ore_round.latest.use():
+        print(round)
+        break
+    await session.close()
+```
+
+## Development
+
+```bash
+pip install -e '.[dev]'
+python -m pytest tests/ -q
+```
+
+## License
+
+MIT
+
+## Links
+
+- [Repository](https://github.com/AreteA4/arete)
+- [Documentation](https://docs.arete.run)
+- [Issues](https://github.com/AreteA4/arete/issues)

arete_sdk-0.11.0/arete/__init__.py

@@ -0,0 +1,310 @@
+"""Arete Python SDK — idiomatic Python projection of the Arete core SDK API.
+
+See docs/internal/sdk-core-api.md (canonical surface) and
+docs/internal/sdk-python-alignment.md (Python projection).
+
+    import arete
+    a4 = await arete.Arete.connect(STACK, wallet=wallet)
+    async for round in a4.views.ore_round.latest.use(take=10):
+        ...
+"""
+
+from __future__ import annotations
+
+__version__ = "0.4.0"
+
+
+class _Unset:
+    """Sentinel distinguishing "no active subscription" from an empty result."""
+
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __repr__(self) -> str:
+        return "arete.UNSET"
+
+    def __bool__(self) -> bool:
+        return False
+
+
+UNSET = _Unset()
+
+# NOTE: UNSET must exist before the submodule imports below (arete.views
+# imports it at module load).
+
+from arete.errors import (  # noqa: E402
+    AreteConnectionError,
+    AreteError,
+    AuthError,
+    HttpRequestError,
+    ProcessedSlotTimeoutError,
+    SubscriptionError,
+)
+from arete.auth import AuthConfig  # noqa: E402
+from arete.wire import RichUpdate, Update  # noqa: E402
+from arete.views import (  # noqa: E402
+    DEFAULT_INITIAL_DATA_TIMEOUT,
+    InitialDataTimeoutError,
+    ListViewHandle,
+    StateViewHandle,
+    ViewDef,
+    ViewsNamespace,
+)
+from arete.chain import (  # noqa: E402
+    ChainClient,
+    ChainClock,
+    ChainError,
+    HttpChainClient,
+    MintAccountInfo,
+    NativeBalanceInfo,
+    RawAccountInfo,
+    TokenAccountInfo,
+    TokenBalanceInfo,
+)
+from arete.transactions import (  # noqa: E402
+    HttpTransactionTransport,
+    TransactionTransport,
+    TransactionTransportError,
+)
+from arete.gateway import (  # noqa: E402
+    HostedSolanaGatewayBindings,
+    create_hosted_solana_gateway_transports,
+)
+from arete.amounts import (  # noqa: E402
+    format_raw_to_ui,
+    get_mint_decimals,
+    parse_ui_amount_to_raw,
+    resolve_amount,
+    resolve_amount_to_raw,
+    resolve_amounts_to_raw,
+    to_raw_amount,
+)
+from arete.spl import (  # noqa: E402
+    ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    SPL_TOKEN_PROGRAM_ADDRESS,
+    SYSTEM_PROGRAM_ADDRESS,
+    TOKEN_2022_PROGRAM_ADDRESS,
+    derive_associated_token_account,
+    resolve_token_program_address,
+)
+from arete.instructions import (  # noqa: E402
+    BuiltAccountMeta,
+    BuiltInstruction,
+    ErrorMetadata,
+    InstructionError,
+    InstructionHandler,
+    PdaConfig,
+    derive_pda,
+    find_program_address,
+    format_program_error,
+    parse_program_error,
+)
+from arete.read import (  # noqa: E402
+    AccountBatchItem,
+    AccountBatchResult,
+    AccountReader,
+    ProgramAccountReadDef,
+    ProgramQueryDef,
+    ReadRequestError,
+    StackQueryDef,
+)
+from arete.program_read_transport import (  # noqa: E402
+    ProgramReadDescriptor,
+    ProgramReleaseReference,
+    validate_program_read_descriptor,
+)
+from arete.wallet import (  # noqa: E402
+    ConfirmedTransactionOutcome,
+    SendOptions,
+    SendResult,
+    TransactionFailureOutcome,
+    TransactionInspectionResult,
+    WalletAdapter,
+    WalletError,
+    WalletExecutionContext,
+)
+from arete.operations import (  # noqa: E402
+    OperationCallbackError,
+    OperationExecutionError,
+    OperationReceipt,
+    OperationTransactionReceipt,
+    PreparedFlow,
+    PreparedInstruction,
+    PreparedOperation,
+    PreparedTransaction,
+    PreparedTransactionBody,
+    SignerRegistry,
+    TransactionExecutionError,
+    append_flow_transactions,
+    append_transaction_instructions,
+    create_prepared_flow,
+    create_prepared_instruction,
+    create_prepared_transaction,
+    create_prepared_transaction_body,
+    create_signer_registry,
+    describe_prepared_operation,
+    execute_prepared_operation,
+    format_prepared_operation,
+    get_transaction_failure_outcome,
+    inspect_prepared_operation,
+    prepend_flow_transaction_instructions,
+    prepend_transaction_instructions,
+    unwrap_operation_execution_error,
+)
+from arete.stack import (  # noqa: E402
+    ConnectedProgram,
+    Operation,
+    ProgramDef,
+    ProgramOperationContext,
+    ProgramOperations,
+    StackDef,
+    StackEndpoints,
+    flow_operation,
+    instruction_operation,
+    transaction_operation,
+    with_programs,
+)
+from arete.extensions import (  # noqa: E402
+    apply_connected_stack_extensions,
+    extend_program,
+    extend_programs,
+    extend_stack,
+)
+from arete.client import Arete  # noqa: E402
+from arete.session import Session, SessionError, create_session  # noqa: E402
+
+__all__ = [
+    "UNSET",
+    "__version__",
+    # client & session
+    "Arete",
+    "Session",
+    "SessionError",
+    "create_session",
+    # errors
+    "AreteError",
+    "AreteConnectionError",
+    "AuthError",
+    "ChainError",
+    "HttpRequestError",
+    "InitialDataTimeoutError",
+    "InstructionError",
+    "OperationCallbackError",
+    "OperationExecutionError",
+    "ProcessedSlotTimeoutError",
+    "ReadRequestError",
+    "SubscriptionError",
+    "TransactionExecutionError",
+    "TransactionTransportError",
+    "WalletError",
+    # auth
+    "AuthConfig",
+    # views & updates
+    "Update",
+    "RichUpdate",
+    "ViewDef",
+    "ViewsNamespace",
+    "DEFAULT_INITIAL_DATA_TIMEOUT",
+    "ListViewHandle",
+    "StateViewHandle",
+    # stack binding model
+    "StackDef",
+    "StackEndpoints",
+    "ProgramDef",
+    "ProgramOperations",
+    "ProgramOperationContext",
+    "ConnectedProgram",
+    "with_programs",
+    # extensions
+    "extend_stack",
+    "extend_program",
+    "extend_programs",
+    "apply_connected_stack_extensions",
+    "Operation",
+    "instruction_operation",
+    "transaction_operation",
+    "flow_operation",
+    # wallet & outcomes
+    "WalletAdapter",
+    "WalletExecutionContext",
+    "SendOptions",
+    "SendResult",
+    "TransactionInspectionResult",
+    "ConfirmedTransactionOutcome",
+    "TransactionFailureOutcome",
+    "get_transaction_failure_outcome",
+    # prepared operations
+    "PreparedInstruction",
+    "PreparedTransaction",
+    "PreparedFlow",
+    "PreparedOperation",
+    "PreparedTransactionBody",
+    "create_prepared_instruction",
+    "create_prepared_transaction",
+    "create_prepared_flow",
+    "create_prepared_transaction_body",
+    "prepend_transaction_instructions",
+    "append_transaction_instructions",
+    "append_flow_transactions",
+    "prepend_flow_transaction_instructions",
+    "execute_prepared_operation",
+    "inspect_prepared_operation",
+    "describe_prepared_operation",
+    "format_prepared_operation",
+    "unwrap_operation_execution_error",
+    "OperationReceipt",
+    "OperationTransactionReceipt",
+    "SignerRegistry",
+    "create_signer_registry",
+    # chain & transactions
+    "ChainClient",
+    "HttpChainClient",
+    "ChainClock",
+    "RawAccountInfo",
+    "MintAccountInfo",
+    "TokenAccountInfo",
+    "TokenBalanceInfo",
+    "NativeBalanceInfo",
+    "TransactionTransport",
+    "HttpTransactionTransport",
+    "HostedSolanaGatewayBindings",
+    "create_hosted_solana_gateway_transports",
+    # amounts & SPL
+    "parse_ui_amount_to_raw",
+    "format_raw_to_ui",
+    "to_raw_amount",
+    "get_mint_decimals",
+    "resolve_amount",
+    "resolve_amount_to_raw",
+    "resolve_amounts_to_raw",
+    "SPL_TOKEN_PROGRAM_ADDRESS",
+    "TOKEN_2022_PROGRAM_ADDRESS",
+    "ASSOCIATED_TOKEN_PROGRAM_ADDRESS",
+    "SYSTEM_PROGRAM_ADDRESS",
+    "derive_associated_token_account",
+    "resolve_token_program_address",
+    # instruction runtime
+    "InstructionHandler",
+    "BuiltInstruction",
+    "BuiltAccountMeta",
+    "ErrorMetadata",
+    "PdaConfig",
+    "derive_pda",
+    "find_program_address",
+    "parse_program_error",
+    "format_program_error",
+    # program reads
+    "AccountReader",
+    "AccountBatchItem",
+    "AccountBatchResult",
+    "ProgramAccountReadDef",
+    "ProgramQueryDef",
+    "StackQueryDef",
+    "ProgramReadDescriptor",
+    "ProgramReleaseReference",
+    "validate_program_read_descriptor",
+]