brawny 0.1.13__py3-none-any.whl

brawny/chain.py

@@ -0,0 +1,93 @@
+"""Chain information singleton.
+
+Usage:
+    from brawny import chain
+
+    chain.height             # Current block number
+    chain[-1]                # Most recent block
+    chain[0]                 # Genesis block
+    chain.id                 # Chain ID
+"""
+
+from __future__ import annotations
+
+from typing import Any, TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from brawny._rpc.manager import RPCManager
+
+
+_chain: "Chain | None" = None
+
+
+class Chain:
+    """Brownie-compatible chain interface.
+
+    Provides access to block information and chain state.
+    """
+
+    def __init__(self, rpc: "RPCManager", chain_id: int) -> None:
+        self._rpc = rpc
+        self._chain_id = chain_id
+
+    @property
+    def height(self) -> int:
+        """Current block number (same as brownie's chain.height)."""
+        return self._rpc.get_block_number()
+
+    @property
+    def id(self) -> int:
+        """Chain ID."""
+        return self._chain_id
+
+    def __getitem__(self, index: int) -> dict[str, Any]:
+        """Get block by number. Supports negative indexing like brownie.
+
+        Example:
+            >>> chain[-1]  # most recent block
+            >>> chain[0]   # genesis block
+        """
+        if index < 0:
+            index = self.height + index + 1
+        return self._rpc.get_block(index)
+
+    def __repr__(self) -> str:
+        return f"<Chain id={self._chain_id} height={self.height}>"
+
+
+def _init_chain(rpc: "RPCManager", chain_id: int) -> None:
+    """Initialize global chain singleton."""
+    global _chain
+    _chain = Chain(rpc, chain_id)
+
+
+def _get_chain() -> Chain:
+    """Get chain singleton."""
+    if _chain is None:
+        raise RuntimeError(
+            "Chain not initialized. Run within script context."
+        )
+    return _chain
+
+
+# Proxy for import-time access
+class _ChainProxy:
+    """Proxy that delegates to chain singleton."""
+
+    @property
+    def height(self) -> int:
+        return _get_chain().height
+
+    @property
+    def id(self) -> int:
+        return _get_chain().id
+
+    def __getitem__(self, index: int) -> dict[str, Any]:
+        return _get_chain()[index]
+
+    def __repr__(self) -> str:
+        return repr(_get_chain())
+
+
+# Global proxy instance
+chain = _ChainProxy()

brawny/cli/__init__.py

@@ -0,0 +1,16 @@
+"""CLI entrypoint for brawny."""
+
+from __future__ import annotations
+
+from brawny.cli.app import main
+from brawny.cli.commands import register_all
+
+
+register_all(main)
+
+
+__all__ = ["main"]
+
+
+if __name__ == "__main__":
+    main()

brawny/cli/app.py

@@ -0,0 +1,17 @@
+"""CLI entry group for brawny."""
+
+from __future__ import annotations
+
+import click
+
+from brawny.cli.bootstrap import configure_bytecode_cache, load_env
+
+load_env()
+configure_bytecode_cache()
+
+
+@click.group()
+@click.version_option(version="0.1.0", prog_name="brawny")
+def main() -> None:
+    """brawny: Block-driven Ethereum job/transaction execution framework."""
+    pass

brawny/cli/bootstrap.py

@@ -0,0 +1,37 @@
+"""CLI bootstrap utilities."""
+
+import os
+import sys
+from pathlib import Path
+
+from dotenv import load_dotenv
+
+
+def load_env() -> None:
+    """Load environment variables from .env in the current directory."""
+    dotenv_path = Path.cwd() / ".env"
+    if dotenv_path.exists():
+        load_dotenv(dotenv_path)
+    else:
+        load_dotenv()
+
+
+def configure_bytecode_cache() -> None:
+    """
+    Prevent __pycache__ from being created in the user's project by redirecting
+    pyc writes to a centralized cache directory.
+
+    Must run before importing/loading user job modules.
+    """
+    # Always disable bytecode writes to avoid __pycache__ in project jobs.
+    os.environ["PYTHONDONTWRITEBYTECODE"] = "1"
+    sys.dont_write_bytecode = True
+
+    # If user already set a prefix, respect it.
+    if os.environ.get("PYTHONPYCACHEPREFIX"):
+        return
+
+    cache_dir = Path.home() / ".cache" / "brawny" / "pycache"
+    cache_dir.mkdir(parents=True, exist_ok=True)
+    os.environ["PYTHONPYCACHEPREFIX"] = str(cache_dir)
+    sys.pycache_prefix = str(cache_dir)

brawny/cli/commands/__init__.py

@@ -0,0 +1,41 @@
+"""CLI command registration."""
+
+from __future__ import annotations
+
+from brawny.cli.commands.abi import register as register_abi
+from brawny.cli.commands.contract import register as register_contract
+from brawny.cli.commands.health import register as register_health
+from brawny.cli.commands.init_project import register as register_init
+from brawny.cli.commands.intents import register as register_intents
+from brawny.cli.commands.jobs import register as register_jobs
+from brawny.cli.commands.logs import register as register_logs
+from brawny.cli.commands.maintenance import register as register_maintenance
+from brawny.cli.commands.migrate import register as register_migrate
+from brawny.cli.commands.networks import register as register_networks
+from brawny.cli.commands.run import register as register_start
+from brawny.cli.commands.script import register as register_run
+from brawny.cli.commands.accounts import register as register_accounts
+from brawny.cli.commands.signer import register as register_signer
+
+
+def register_all(main) -> None:
+    register_migrate(main)
+    register_start(main)  # brawny start (daemon)
+    register_run(main)    # brawny run (scripts, brownie-compatible)
+    register_init(main)
+    register_jobs(main)   # includes jobs run
+    register_intents(main)
+    register_logs(main)   # brawny logs list/cleanup
+    register_maintenance(main)
+    register_health(main)
+    register_abi(main)
+    register_contract(main)
+    register_accounts(main)
+    register_networks(main)
+    register_signer(main)  # brawny signer force-reset, status
+    # Console has optional dependency (prompt_toolkit) - import lazily
+    try:
+        from brawny.cli.commands.console import register as register_console
+        register_console(main)
+    except ImportError:
+        pass  # prompt_toolkit not installed

brawny/cli/commands/abi.py

@@ -0,0 +1,93 @@
+"""ABI cache commands.
+
+Uses global ABI cache at ~/.brawny/abi_cache.db.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import click
+
+from brawny.db.global_cache import GlobalABICache
+
+
+@click.group()
+def abi() -> None:
+    """Manage ABI cache (stored in ~/.brawny/abi_cache.db)."""
+    pass
+
+
+@abi.command("show")
+@click.argument("address")
+@click.option("--chain-id", type=int, default=1, help="Chain ID (default: 1)")
+def abi_show(address: str, chain_id: int) -> None:
+    """Show cached ABI for address."""
+    cache = GlobalABICache()
+    cached = cache.get_cached_abi(chain_id, address)
+    if not cached:
+        click.echo(f"No cached ABI for {address} on chain {chain_id}.")
+        return
+
+    click.echo(f"\nCached ABI for {address}")
+    click.echo("-" * 60)
+    click.echo(f"  Chain ID: {cached.chain_id}")
+    click.echo(f"  Source: {cached.source}")
+    click.echo(f"  Resolved: {cached.resolved_at}")
+    click.echo("\n  ABI Preview:")
+
+    try:
+        abi_data = json.loads(cached.abi_json)
+        for item in abi_data[:10]:
+            if item.get("type") == "function":
+                name = item.get("name", "?")
+                inputs = ", ".join(i.get("type", "?") for i in item.get("inputs", []))
+                click.echo(f"    - {name}({inputs})")
+        if len(abi_data) > 10:
+            click.echo(f"    ... and {len(abi_data) - 10} more")
+    except json.JSONDecodeError:
+        click.echo("    (Invalid JSON)")
+    click.echo()
+
+
+@abi.command("set")
+@click.argument("address")
+@click.option("--file", "abi_file", required=True, help="ABI JSON file")
+@click.option("--chain-id", type=int, default=1, help="Chain ID (default: 1)")
+def abi_set(address: str, abi_file: str, chain_id: int) -> None:
+    """Set cached ABI from file."""
+    from pathlib import Path
+
+    path = Path(abi_file)
+    if not path.exists():
+        click.echo(f"File not found: {abi_file}", err=True)
+        sys.exit(1)
+
+    abi_json = path.read_text()
+
+    try:
+        json.loads(abi_json)
+    except json.JSONDecodeError as e:
+        click.echo(f"Invalid JSON: {e}", err=True)
+        sys.exit(1)
+
+    cache = GlobalABICache()
+    cache.set_cached_abi(chain_id, address, abi_json, "manual")
+    click.echo(f"ABI cached for {address} on chain {chain_id}.")
+
+
+@abi.command("clear")
+@click.argument("address")
+@click.option("--chain-id", type=int, default=1, help="Chain ID (default: 1)")
+def abi_clear(address: str, chain_id: int) -> None:
+    """Clear cached ABI for address."""
+    cache = GlobalABICache()
+    if cache.clear_cached_abi(chain_id, address):
+        click.echo(f"ABI cache cleared for {address}.")
+    else:
+        click.echo(f"No cached ABI found for {address}.")
+
+
+def register(main) -> None:
+    main.add_command(abi)