cowboy-actor-sdk 0.1.2__tar.gz

cowboy_actor_sdk-0.1.2/MANIFEST.in

@@ -0,0 +1,11 @@
+# Keep build-tooling out of the published sdist (COW-2496).
+#
+# `tests/` holds check_dist.py's own tests and `pytest.ini` roots them. Both
+# are for building/verifying the package, not for consuming it — and the
+# shipped test would be inert anyway, since it imports `../check_dist.py`,
+# which is not part of the distribution. setuptools picks up a top-level
+# `tests/` by default, so it has to be pruned explicitly.
+prune tests
+exclude pytest.ini
+exclude check_dist.py
+exclude sync_sdk.py

cowboy_actor_sdk-0.1.2/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: cowboy-actor-sdk
+Version: 0.1.2
+Summary: SDK for developing Cowboy Actors
+Author: Cowboy Labs
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cowboyinc/node
+Project-URL: Documentation, https://github.com/cowboyinc/node/blob/main/pvm/docs/cowboy_sdk_developer_manual.md
+Project-URL: Repository, https://github.com/cowboyinc/node.git
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: cbor2>=5.6.0
+
+# Cowboy SDK
+
+The official Python SDK for developing autonomous actors on the **Cowboy PVM (Python Virtual Machine)**.
+
+With this SDK, you can write fully deterministic on-chain Python code that interacts natively with LLMs, APIs, and the broader Cowboy ecosystem.
+
+## Features
+
+- **Decentralized AI Agents**: Write prompt chains, FSM-based LLM logic, and MCP integrations directly in Python.
+- **`@runner.continuation`**: Turn Python `async` functions into verified Finite State Machines (FSMs) capable of pausing execution, offloading heavy compute (LLM inference, HTTP requests) to Runners, and seamlessly resuming on the next block.
+- **Robust Determinism**: The SDK strips away standard Python non-determinism (`time`, `random`, `set`) and replaces it with consensus-safe primitives.
+- **CBOR-backed State**: The `CowboyModel` and `self.storage` dict provide automatic schema validation and canonical CBOR serialization for zero-boilerplate state management.
+- **Built-in Async Primitives**: Leverage `TaskGroup` for concurrent Runner tasks, `Retry` for robust backoff logic, and `bounded_loop` to ensure safety limits.
+
+## Quick Start
+
+```shell
+pip install cowboy-actor-sdk
+```
+
+```python
+from cowboy_sdk import actor, runner, capture
+
+@actor
+class MyAgent:
+    def init(self, payload):
+        self.storage["calls"] = 0
+        return b"ok"
+
+    @runner.continuation
+    async def chat(self, msg):
+        ctx = capture()
+        ctx.prompt = msg.get("message", "Hello")
+        
+        # Off-chain heavy compute (LLM) securely verified via consensus
+        result = await runner.llm(ctx.prompt, system_prompt="You are a helpful assistant")
+        
+        # Execution resumes here on the next block
+        chat_id = self.storage.get("calls", 0)
+        self.storage[f"reply:{chat_id}"] = result
+        self.storage["calls"] = chat_id + 1
+        
+        return b"ok"
+
+def _a(): return MyAgent()
+def init(p): return _a().init(p)
+def chat(p): return _a().chat(p)
+def chat__resume(p): return _a().chat__resume(p)
+def on_runner_result(p): return _a().on_runner_result(p)
+```
+
+## Documentation & Tools
+
+- **Developer Manual**: [View on GitHub](https://github.com/cowboylabs/cowboy/blob/main/refs/dev_support/cowboy_sdk_developer_manual.md)
+- **Vibe Coding Blueprint (Claude Code)**: Learn how to set up autonomous development without local chain dependencies. [View Guide](https://github.com/cowboylabs/cowboy/blob/main/refs/dev_support/remote_developer_guide.md).
+- **Cowboy CLI**: Pre-compiled binary required to deploy and send transactions. Download from the [GitHub Releases](https://github.com/cowboylabs/cowboy/releases).
+
+## License
+
+MIT License. See the repository for details.

cowboy_actor_sdk-0.1.2/cowboy_actor_sdk.egg-info/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: cowboy-actor-sdk
+Version: 0.1.2
+Summary: SDK for developing Cowboy Actors
+Author: Cowboy Labs
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/cowboyinc/node
+Project-URL: Documentation, https://github.com/cowboyinc/node/blob/main/pvm/docs/cowboy_sdk_developer_manual.md
+Project-URL: Repository, https://github.com/cowboyinc/node.git
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: cbor2>=5.6.0
+
+# Cowboy SDK
+
+The official Python SDK for developing autonomous actors on the **Cowboy PVM (Python Virtual Machine)**.
+
+With this SDK, you can write fully deterministic on-chain Python code that interacts natively with LLMs, APIs, and the broader Cowboy ecosystem.
+
+## Features
+
+- **Decentralized AI Agents**: Write prompt chains, FSM-based LLM logic, and MCP integrations directly in Python.
+- **`@runner.continuation`**: Turn Python `async` functions into verified Finite State Machines (FSMs) capable of pausing execution, offloading heavy compute (LLM inference, HTTP requests) to Runners, and seamlessly resuming on the next block.
+- **Robust Determinism**: The SDK strips away standard Python non-determinism (`time`, `random`, `set`) and replaces it with consensus-safe primitives.
+- **CBOR-backed State**: The `CowboyModel` and `self.storage` dict provide automatic schema validation and canonical CBOR serialization for zero-boilerplate state management.
+- **Built-in Async Primitives**: Leverage `TaskGroup` for concurrent Runner tasks, `Retry` for robust backoff logic, and `bounded_loop` to ensure safety limits.
+
+## Quick Start
+
+```shell
+pip install cowboy-actor-sdk
+```
+
+```python
+from cowboy_sdk import actor, runner, capture
+
+@actor
+class MyAgent:
+    def init(self, payload):
+        self.storage["calls"] = 0
+        return b"ok"
+
+    @runner.continuation
+    async def chat(self, msg):
+        ctx = capture()
+        ctx.prompt = msg.get("message", "Hello")
+        
+        # Off-chain heavy compute (LLM) securely verified via consensus
+        result = await runner.llm(ctx.prompt, system_prompt="You are a helpful assistant")
+        
+        # Execution resumes here on the next block
+        chat_id = self.storage.get("calls", 0)
+        self.storage[f"reply:{chat_id}"] = result
+        self.storage["calls"] = chat_id + 1
+        
+        return b"ok"
+
+def _a(): return MyAgent()
+def init(p): return _a().init(p)
+def chat(p): return _a().chat(p)
+def chat__resume(p): return _a().chat__resume(p)
+def on_runner_result(p): return _a().on_runner_result(p)
+```
+
+## Documentation & Tools
+
+- **Developer Manual**: [View on GitHub](https://github.com/cowboylabs/cowboy/blob/main/refs/dev_support/cowboy_sdk_developer_manual.md)
+- **Vibe Coding Blueprint (Claude Code)**: Learn how to set up autonomous development without local chain dependencies. [View Guide](https://github.com/cowboylabs/cowboy/blob/main/refs/dev_support/remote_developer_guide.md).
+- **Cowboy CLI**: Pre-compiled binary required to deploy and send transactions. Download from the [GitHub Releases](https://github.com/cowboylabs/cowboy/releases).
+
+## License
+
+MIT License. See the repository for details.

cowboy_actor_sdk-0.1.2/cowboy_actor_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,61 @@
+MANIFEST.in
+cowboy_sdk_readme.md
+pyproject.toml
+cowboy_actor_sdk.egg-info/PKG-INFO
+cowboy_actor_sdk.egg-info/SOURCES.txt
+cowboy_actor_sdk.egg-info/dependency_links.txt
+cowboy_actor_sdk.egg-info/requires.txt
+cowboy_actor_sdk.egg-info/top_level.txt
+cowboy_sdk/__init__.py
+cowboy_sdk/__init__.pyi
+cowboy_sdk/_compiler.py
+cowboy_sdk/_keccak.py
+cowboy_sdk/actor.py
+cowboy_sdk/actor.pyi
+cowboy_sdk/bounded_loop.py
+cowboy_sdk/call.py
+cowboy_sdk/call.pyi
+cowboy_sdk/codec.py
+cowboy_sdk/codec.pyi
+cowboy_sdk/continuation.py
+cowboy_sdk/delegation.py
+cowboy_sdk/errors.py
+cowboy_sdk/events.py
+cowboy_sdk/events_v0.py
+cowboy_sdk/fork.py
+cowboy_sdk/guards.py
+cowboy_sdk/handler_mode.py
+cowboy_sdk/json_codec.py
+cowboy_sdk/json_codec.pyi
+cowboy_sdk/mock_host.py
+cowboy_sdk/models.py
+cowboy_sdk/offchain.py
+cowboy_sdk/on_stream.py
+cowboy_sdk/payload_codec.py
+cowboy_sdk/payload_codec.pyi
+cowboy_sdk/permissions.py
+cowboy_sdk/permissions.pyi
+cowboy_sdk/pvm_random.py
+cowboy_sdk/pvm_sys.py
+cowboy_sdk/pvm_time.py
+cowboy_sdk/py.typed
+cowboy_sdk/recipes.py
+cowboy_sdk/retry.py
+cowboy_sdk/routes.py
+cowboy_sdk/runner.py
+cowboy_sdk/runner_routes.py
+cowboy_sdk/runtime.py
+cowboy_sdk/runtime.pyi
+cowboy_sdk/send.py
+cowboy_sdk/send.pyi
+cowboy_sdk/sorted_map.py
+cowboy_sdk/taskgroup.py
+cowboy_sdk/tee.py
+cowboy_sdk/testing.py
+cowboy_sdk/testing.pyi
+cowboy_sdk/timer.py
+cowboy_sdk/types.py
+cowboy_sdk/types.pyi
+cowboy_sdk/verify.py
+cowboy_sdk/watchtower.py
+cowboy_sdk/watchtower_codec.py

cowboy_actor_sdk-0.1.2/cowboy_actor_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

cowboy_actor_sdk-0.1.2/cowboy_actor_sdk.egg-info/requires.txt

@@ -0,0 +1 @@
+cbor2>=5.6.0

cowboy_actor_sdk-0.1.2/cowboy_actor_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+cowboy_sdk

cowboy_actor_sdk-0.1.2/cowboy_sdk/__init__.py

@@ -0,0 +1,337 @@
+"""
+cowboy_sdk — Cowboy Actor system Python SDK
+
+Version: 0.1.1
+Specification: CIP-6 SDK Specification
+
+Design principles (seven invariants):
+  I-1  All data crossing trust boundaries uses Canonical CBOR (RFC 8949)
+  I-2  SDK public API namespace is unified as cowboy_sdk
+  I-3  Continuation on-chain production mode is FSM; Checkpoint is for development/debugging only
+  I-4  All security mechanisms (Guard, Reentrancy, BoundedLoop, TypeCheck) are delivered together with features
+  I-5  Every new feature ships with deterministic tests; CI verifies cross-platform
+  I-6  Floating-point operations globally use SoftFloat (replaced at the PVM layer); SoftFloat = float
+  I-7  Version numbers follow SemVer; marked as 0.x before mainnet
+
+PVM compatibility golden rules (CIP-6 Appendix A):
+  Rule 1: import time is forbidden     → use cowboy_sdk.pvm_time
+  Rule 2: import random is forbidden   → use cowboy_sdk.pvm_random
+  Rule 3: hardware FPU float forbidden → SoftFloat = float (replaced at PVM layer)
+  Rule 4: set() is forbidden           → use ordered_set
+  Rule 5: pickle is forbidden          → use CBOR (cowboy_sdk.codec)
+  Rule 6: call() depth <= 32           → Host API internal counter
+  Rule 7: await points <= 8            → FSM compiler static check
+  Rule 8: loop await requires @bounded_loop
+  Rule 9: capture() must be declared explicitly
+  Rule 10: send() is irrevocable
+
+Address format (ADDRESS_MIGRATION scheme A):
+  All addresses are 20-byte Ethereum-style addresses (secp256k1 + keccak256).
+  Two distinct context identities, both 20 bytes: ctx["sender"] is the caller
+  (EVM msg.sender) and ctx["actor_addr"] is the actor's own address — do not
+  conflate "who called me" with "who I am". Typed accessors return an Address:
+  runtime.sender() / runtime.actor_address() (and self.sender on an @actor);
+  runtime.get_sender() / runtime.get_actor_address() remain the raw-bytes escape
+  hatch. Use the Address class for formatting and validation.
+"""
+
+__version__ = '0.1.1'
+__author__ = 'Cowboy Chain Team'
+__cip__ = 'CIP-6'
+
+# ─── Submodule imports ──────────────────────────────────────────────────────────────────
+
+from . import codec
+from . import errors
+from . import pvm_random
+from . import pvm_sys
+from . import pvm_time
+from . import runtime
+from . import events_v0
+from . import events as _events_module
+from . import on_stream as _on_stream_module
+
+from . import handler_mode as _handler_mode_module
+from . import continuation
+from . import call as _call_module
+from . import send as _send_module
+from . import fork as _fork_module
+from . import permissions as _permissions_module
+from . import payload_codec as _payload_codec_module
+from . import routes as _routes_module
+from . import actor as _actor_module
+from . import runner
+from . import tee
+from . import watchtower
+from . import sorted_map
+from . import guards
+from . import bounded_loop as _bounded_loop_module
+from . import verify as _verify_module
+from . import retry as _retry_module
+from . import taskgroup as _taskgroup_module
+from . import models as _models_module
+from . import types as _types_module
+
+# ─── Top-level public API ────────────────────────────────────────────────────────────────
+
+# Continuation
+capture = continuation.capture
+Capture = continuation.Capture
+save_cont = continuation.save_cont
+load_cont = continuation.load_cont
+delete_cont = continuation.delete_cont
+
+# Call primitives
+call = _call_module.call
+send = _send_module.send
+
+# fork() — self-clone primitive (Unix fork() analogue). See cowboy_sdk.fork.
+fork = _fork_module.fork
+
+# Actor system
+actor = _actor_module.actor
+ActorRef = _actor_module.ActorRef
+derive_actor_address = _actor_module.derive_actor_address
+
+# Timer-fire handler decorator (CIP-6 / COW-375)
+from .timer import timer
+
+# Handler mode decorators
+pure = _handler_mode_module.pure
+deferred = _handler_mode_module.deferred
+
+# Cross-actor call permission decorators (CIP-6 §5.6)
+public = _permissions_module.public
+callable_by = _permissions_module.callable_by
+OWNER = _permissions_module.OWNER
+SELF = _permissions_module.SELF
+# Payload codec helpers for handlers declaring an encoded decode=.
+decode_payload = _payload_codec_module.decode_payload
+ok = _payload_codec_module.ok
+
+# HTTP route declarations (CIP-15). The verb decorators are NOT exported at
+# the top level — `get`, `post`, etc. shadow common identifiers. Use
+# `from cowboy_sdk.routes import get, post, mount, Pays` directly.
+routes = _routes_module
+Pays = _routes_module.Pays
+mount = _routes_module.mount
+
+# Security mechanisms
+reentrancy_guard = guards.reentrancy_guard
+storage_guard = guards.storage_guard
+GuardedValue = guards.GuardedValue
+GuardSet = guards.GuardSet
+bounded_loop = _bounded_loop_module.bounded_loop
+BoundedRange = _bounded_loop_module.BoundedRange
+check_iteration = _bounded_loop_module.check_iteration
+
+# Verification
+Verify = _verify_module.Verify
+VerifyBuilder = _verify_module.VerifyBuilder
+
+# Error classes (exported at top level)
+from .errors import (
+    CowboyError,
+    DeterminismError,
+    StateConflictError,
+    ReentrancyError,
+    LoopBoundExceeded,
+    CaptureTypeError,
+    ContinuationLimitError,
+    ContinuationNotFoundError,
+    ContinuationCorruptedError,
+    ContinuationSizeLimitError,
+    ContinuationCountLimitError,
+    CycleLimitExceeded,
+    CallDepthExceeded,
+    RunnerTimeoutError,
+    RunnerValidationError,
+    DeterministicValidationError,
+    CodecError,
+    AddressError,
+    TokenIdError,
+    ActorNotFoundError,
+    ActorCallError,
+    PurityViolationError,
+    PermissionDeniedError,
+)
+
+# The off-chain boundary error, bound LAZILY (PEP 562).
+#
+# It lives in `cowboy_sdk.offchain` beside the rules it enforces, and an actor
+# that guards an off-chain await names it on the `cowboy_sdk` import it already
+# writes -- `from cowboy_sdk import actor, codec, public, OffchainError` -- as
+# the same object this package's `offchain` module defines.
+#
+# Binding it eagerly, and listing either name in `__all__`, would charge every
+# actor on the chain for a module almost none of them import. The FSM
+# compiler's per-continuation guard imports `cowboy_sdk` with a `("*",)`
+# fromlist (`pvm/crates/codegen/src/compile.rs`), and that import walks
+# `__all__` once per continuation, so a name added there costs gas in every
+# transaction of every continuation actor, off-chain or not. `__getattr__`
+# resolves the name on first use and caches it in the package namespace, so
+# the second lookup is an ordinary attribute read.
+#
+# Deliberately absent from `__all__` for that reason. Type checkers still see
+# both names, by two different routes: the `.pyi` stub re-exports the class as
+# `from .offchain import OffchainError as OffchainError`, while `offchain`
+# itself needs no stub entry at all -- a submodule of a `py.typed` package
+# resolves from the file system. Checked against the shipped wheel with
+# basedpyright 1.40.0 in strict mode: `from cowboy_sdk import offchain`,
+# `import cowboy_sdk.offchain` and `from cowboy_sdk import OffchainError` all
+# type-check clean. Adding `from . import offchain as offchain` to the stub
+# would be the third route and is the one to avoid: the authoring gate reads
+# an `x as x` form as a claim that `cowboy_sdk.offchain` is an eagerly bound
+# root attribute, which it is not.
+def __getattr__(name):
+    # `from .offchain import OffchainError`, NOT `from . import offchain`: the
+    # latter asks the import system for an attribute of THIS package, which
+    # calls this function again and recurses until the stack gives out. Naming
+    # the submodule directly imports it and reads an attribute off it instead,
+    # and the import system sets `cowboy_sdk.offchain` as a side effect.
+    #
+    # Every other name raises, including `offchain` itself, so the ordinary
+    # submodule-import fallback handles `from cowboy_sdk import offchain`.
+    if name == 'OffchainError':
+        # `global`, not `globals()`: the activated environment strips that
+        # builtin from actor-reachable code, and a plain global assignment
+        # needs no builtin at all.
+        global OffchainError
+        from .offchain import OffchainError as _boundary_error
+        OffchainError = _boundary_error
+        return _boundary_error
+    raise AttributeError("module 'cowboy_sdk' has no attribute " + repr(name))
+
+# Async utilities
+Retry = _retry_module.Retry
+TaskGroup = _taskgroup_module.TaskGroup
+
+# Type system
+CowboyModel = _models_module.CowboyModel
+SortedMap = sorted_map.SortedMap
+SoftFloat = _types_module.SoftFloat
+ordered_set = _types_module.ordered_set
+BlockHeight = _types_module.BlockHeight
+Address = _types_module.Address
+to_address_bytes = _types_module.to_address_bytes
+TokenId = _types_module.TokenId
+
+# CIP-29 Phase 3 decorators (events_v0 stays — Phase 0 / EventHub still available there)
+emit = _events_module.emit
+on_event = _events_module.on_event
+
+# COW-988: CIP-7 Watchtower consume-side decorator (publishing is off-chain).
+on_stream = _on_stream_module.on_stream
+
+# ─── __all__ ────────────────────────────────────────────────────────────────────
+
+__all__ = [
+    # Version
+    '__version__',
+
+    # Submodules
+    'sorted_map',
+    'SortedMap',
+    'codec',
+    'errors',
+    'continuation',
+    'runner',
+    'watchtower',
+    'pvm_random',
+    'pvm_sys',
+    'pvm_time',
+    'runtime',
+    'events_v0',
+    'events',
+
+    # Top-level functions
+    'capture',
+    'call',
+    'send',
+    'fork',
+
+    # Actor system
+    'actor',
+    'ActorRef',
+    'derive_actor_address',
+    'timer',
+
+    # Handler mode decorators
+    'pure',
+    'deferred',
+
+    # Permission decorators
+    'public',
+    'callable_by',
+    'OWNER',
+    'SELF',
+    'decode_payload',
+    'ok',
+
+    # HTTP routes (CIP-15) — module + Pays + mount only at top level;
+    # import @get/@post/@put/@patch/@delete/@route from cowboy_sdk.routes.
+    'routes',
+    'Pays',
+    'mount',
+
+    # Security mechanisms
+    'reentrancy_guard',
+    'storage_guard',
+    'GuardedValue',
+    'GuardSet',
+    'bounded_loop',
+    'BoundedRange',
+    'check_iteration',
+
+    # Verification
+    'Verify',
+
+    # Async utilities
+    'Retry',
+    'TaskGroup',
+
+    # Type system
+    'CowboyModel',
+    'SoftFloat',
+    'ordered_set',
+    'BlockHeight',
+    'Address',
+    'to_address_bytes',
+    'TokenId',
+
+    # CIP-29 Phase 3 decorators
+    'emit',
+    'on_event',
+
+    # CIP-7 Watchtower consume-side decorator (COW-988)
+    'on_stream',
+
+    # Continuation
+    'Capture',
+    'save_cont',
+    'load_cont',
+    'delete_cont',
+
+    # Error classes
+    'errors',
+    'CowboyError',
+    'DeterminismError',
+    'StateConflictError',
+    'ReentrancyError',
+    'LoopBoundExceeded',
+    'CaptureTypeError',
+    'ContinuationLimitError',
+    'ContinuationNotFoundError',
+    'ContinuationCorruptedError',
+    'ContinuationSizeLimitError',
+    'ContinuationCountLimitError',
+    'RunnerTimeoutError',
+    'RunnerValidationError',
+    'CodecError',
+    'AddressError',
+    'TokenIdError',
+    'ActorNotFoundError',
+    'ActorCallError',
+    'PurityViolationError',
+    'PermissionDeniedError',
+]