atp-protocol 1.0.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

atp/token_prices.py

@@ -1,97 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from typing import Dict
-
-import httpx
-from loguru import logger
-
-
-class TokenPriceFetcher:
-    """Fetches real-time token prices from CoinGecko API."""
-
-    COINGECKO_URL = "https://api.coingecko.com/api/v3/simple/price"
-    CACHE_TTL_SECONDS = 60  # Cache price for 60 seconds
-
-    def __init__(self):
-        self._cached_prices: Dict[str, float] = {}
-        self._cache_timestamps: Dict[str, float] = {}
-        self._lock = asyncio.Lock()
-
-    async def get_price_usd(self, token: str = "SOL") -> float:
-        import time
-
-        # USDC is pegged to USD
-        if token.upper() == "USDC":
-            return 1.0
-
-        async with self._lock:
-            current_time = time.time()
-            cache_key = token.upper()
-
-            cached_price = self._cached_prices.get(cache_key)
-            cached_timestamp = self._cache_timestamps.get(
-                cache_key, 0
-            )
-            if (
-                cached_price
-                and (current_time - cached_timestamp)
-                < self.CACHE_TTL_SECONDS
-            ):
-                return cached_price
-
-            coingecko_ids = {"SOL": "solana"}
-            coingecko_id = coingecko_ids.get(token.upper())
-            if not coingecko_id:
-                logger.warning(
-                    f"Unknown token: {token}, defaulting to $1.00"
-                )
-                return 1.0
-
-            try:
-                async with httpx.AsyncClient() as client:
-                    response = await client.get(
-                        self.COINGECKO_URL,
-                        params={
-                            "ids": coingecko_id,
-                            "vs_currencies": "usd",
-                        },
-                        timeout=10.0,
-                    )
-                    response.raise_for_status()
-                    data = response.json()
-
-                    price = data.get(coingecko_id, {}).get("usd")
-                    if price is None:
-                        raise ValueError(
-                            f"{token} price not found in response"
-                        )
-
-                    self._cached_prices[cache_key] = float(price)
-                    self._cache_timestamps[cache_key] = current_time
-                    return float(price)
-
-            except httpx.HTTPError as e:
-                logger.warning(
-                    f"Failed to fetch {token} price from CoinGecko: {e}"
-                )
-                if cached_price:
-                    return cached_price
-                return 150.0
-            except Exception as e:
-                logger.error(
-                    f"Unexpected error fetching {token} price: {e}"
-                )
-                if cached_price:
-                    return cached_price
-                return 150.0
-
-    async def get_sol_price_usd(self) -> float:
-        return await self.get_price_usd("SOL")
-
-
-token_price_fetcher = TokenPriceFetcher()
-
-
-# if __name__ == "__main__":
-#     print(asyncio.run(token_price_fetcher.get_price_usd("SOL")))

atp/utils.py

@@ -1,174 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Dict, Optional
-
-from atp import config
-from atp.schemas import PaymentToken
-
-
-def calculate_payment_amounts(
-    usd_cost: float,
-    token_price_usd: float,
-    payment_token: PaymentToken,
-) -> Dict[str, Any]:
-    """
-    Calculate payment amounts with settlement fee taken from the total.
-
-    Returns amounts in the smallest unit (lamports for SOL, micro-units for USDC).
-    """
-    total_amount_token = usd_cost / token_price_usd
-    fee_amount_token = (
-        total_amount_token * config.SETTLEMENT_FEE_PERCENT
-    )
-    agent_amount_token = total_amount_token - fee_amount_token
-
-    decimals = (
-        9
-        if payment_token == PaymentToken.SOL
-        else config.USDC_DECIMALS
-    )
-
-    total_amount_units = int(total_amount_token * 10**decimals)
-    fee_amount_units = int(fee_amount_token * 10**decimals)
-    agent_amount_units = total_amount_units - fee_amount_units
-
-    return {
-        "total_amount_units": total_amount_units,
-        "agent_amount_units": agent_amount_units,
-        "fee_amount_units": fee_amount_units,
-        "total_amount_token": total_amount_token,
-        "agent_amount_token": agent_amount_token,
-        "fee_amount_token": fee_amount_token,
-        "decimals": decimals,
-        "fee_percent": config.SETTLEMENT_FEE_PERCENT * 100,
-    }
-
-
-def _safe_int(v: Any) -> Optional[int]:
-    if v is None:
-        return None
-    if isinstance(v, bool):
-        return None
-    if isinstance(v, int):
-        return v
-    if isinstance(v, float):
-        return int(v)
-    if isinstance(v, str):
-        s = v.strip()
-        if not s:
-            return None
-        try:
-            return int(float(s))
-        except Exception:
-            return None
-    return None
-
-
-def extract_usage_token_counts(
-    usage: Any,
-) -> Dict[str, Optional[int]]:
-    """
-    Normalize token counts from various possible upstream shapes.
-    Common keys:
-    - prompt_tokens / completion_tokens / total_tokens (OpenAI-like)
-    - input_tokens / output_tokens / total_tokens
-    """
-    if not isinstance(usage, dict):
-        return {
-            "input_tokens": None,
-            "output_tokens": None,
-            "total_tokens": None,
-        }
-
-    input_tokens = _safe_int(usage.get("input_tokens"))
-    if input_tokens is None:
-        input_tokens = _safe_int(usage.get("prompt_tokens"))
-
-    output_tokens = _safe_int(usage.get("output_tokens"))
-    if output_tokens is None:
-        output_tokens = _safe_int(usage.get("completion_tokens"))
-
-    total_tokens = _safe_int(usage.get("total_tokens"))
-    if (
-        total_tokens is None
-        and input_tokens is not None
-        and output_tokens is not None
-    ):
-        total_tokens = input_tokens + output_tokens
-
-    return {
-        "input_tokens": input_tokens,
-        "output_tokens": output_tokens,
-        "total_tokens": total_tokens,
-    }
-
-
-def compute_usd_cost_from_usage(usage: Any) -> Dict[str, Any]:
-    """
-    Returns a pricing breakdown dict containing:
-    - usd_cost (float)
-    - source: per_million_rates | upstream_total_cost | fallback_default
-    - token counts and configured rates
-    """
-    usage = usage if isinstance(usage, dict) else {}
-    counts = extract_usage_token_counts(usage)
-
-    can_compute_input = (
-        config.INPUT_COST_PER_MILLION_USD is not None
-        and counts["input_tokens"] is not None
-    )
-    can_compute_output = (
-        config.OUTPUT_COST_PER_MILLION_USD is not None
-        and counts["output_tokens"] is not None
-    )
-
-    if can_compute_input or can_compute_output:
-        input_cost = (
-            (counts["input_tokens"] or 0)
-            / 1_000_000.0
-            * (config.INPUT_COST_PER_MILLION_USD or 0.0)
-        )
-        output_cost = (
-            (counts["output_tokens"] or 0)
-            / 1_000_000.0
-            * (config.OUTPUT_COST_PER_MILLION_USD or 0.0)
-        )
-        usd_cost = float(input_cost + output_cost)
-        return {
-            "usd_cost": usd_cost,
-            "source": "per_million_rates",
-            "input_tokens": counts["input_tokens"],
-            "output_tokens": counts["output_tokens"],
-            "total_tokens": counts["total_tokens"],
-            "input_cost_per_million_usd": config.INPUT_COST_PER_MILLION_USD,
-            "output_cost_per_million_usd": config.OUTPUT_COST_PER_MILLION_USD,
-            "input_cost_usd": input_cost,
-            "output_cost_usd": output_cost,
-        }
-
-    upstream_total_cost = usage.get("total_cost")
-    try:
-        if upstream_total_cost is not None:
-            usd_cost = float(upstream_total_cost)
-            return {
-                "usd_cost": usd_cost,
-                "source": "upstream_total_cost",
-                "input_tokens": counts["input_tokens"],
-                "output_tokens": counts["output_tokens"],
-                "total_tokens": counts["total_tokens"],
-                "input_cost_per_million_usd": config.INPUT_COST_PER_MILLION_USD,
-                "output_cost_per_million_usd": config.OUTPUT_COST_PER_MILLION_USD,
-            }
-    except Exception:
-        pass
-
-    usd_cost = 0.01
-    return {
-        "usd_cost": usd_cost,
-        "source": "fallback_default",
-        "input_tokens": counts["input_tokens"],
-        "output_tokens": counts["output_tokens"],
-        "total_tokens": counts["total_tokens"],
-        "input_cost_per_million_usd": config.INPUT_COST_PER_MILLION_USD,
-        "output_cost_per_million_usd": config.OUTPUT_COST_PER_MILLION_USD,
-    }

atp/vault.py

@@ -1,75 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from typing import Any, Dict, Optional
-
-from loguru import logger
-
-
-class InMemoryVault:
-    """In-process job vault with TTL expiration (for local dev/testing).
-
-    Note: data is not shared across processes and is lost on restart.
-    """
-
-    def __init__(self, default_ttl: int = 600):
-        self.default_ttl = default_ttl
-        self._lock = asyncio.Lock()
-        # key: job_id -> {"data": dict, "expires_at": float}
-        self._store: Dict[str, Dict[str, Any]] = {}
-
-    async def connect(self) -> None:
-        logger.warning(
-            "Using in-memory job vault. Jobs will be lost on restart."
-        )
-
-    async def disconnect(self) -> None:
-        return None
-
-    def _is_expired(self, expires_at: float) -> bool:
-        import time
-
-        return time.time() >= expires_at
-
-    async def store(
-        self,
-        job_id: str,
-        data: Dict[str, Any],
-        ttl: Optional[int] = None,
-    ) -> None:
-        import time
-
-        ttl = ttl or self.default_ttl
-        expires_at = time.time() + ttl
-        async with self._lock:
-            self._store[job_id] = {
-                "data": data,
-                "expires_at": expires_at,
-            }
-
-    async def retrieve(self, job_id: str) -> Optional[Dict[str, Any]]:
-        async with self._lock:
-            entry = self._store.get(job_id)
-            if not entry:
-                return None
-            if self._is_expired(entry["expires_at"]):
-                self._store.pop(job_id, None)
-                return None
-            return entry["data"]
-
-    async def delete(self, job_id: str) -> bool:
-        async with self._lock:
-            existed = job_id in self._store
-            self._store.pop(job_id, None)
-            return existed
-
-    async def pop(self, job_id: str) -> Optional[Dict[str, Any]]:
-        async with self._lock:
-            entry = self._store.get(job_id)
-            if not entry:
-                return None
-            if self._is_expired(entry["expires_at"]):
-                self._store.pop(job_id, None)
-                return None
-            self._store.pop(job_id, None)
-            return entry["data"]

atp_protocol-1.0.0.dist-info/RECORD

@@ -1,13 +0,0 @@
-atp/__init__.py,sha256=lv9yAwpBiySYw2ECZagHUmZHtKXrbkCxF1XoF0IuYeI,205
-atp/config.py,sha256=m5hsDeMgbtqMUu9uO4G_ht6WBD8T5FNm-ga2tE5oRmU,2030
-atp/middleware.py,sha256=lR0PX2O3ka3u_Wj1T8T5dSm56DxEzduXHkNyk-230Nc,13891
-atp/schemas.py,sha256=iASVBPpAhrO-LDXs2UC9ABtfV1oDYsu4kZcz3dVeJNA,6220
-atp/settlement_client.py,sha256=jfvhxDqp2kDISWG7tjX5s88goAPxp-lMXvuJtpMyOys,6742
-atp/solana_utils.py,sha256=T4KtMZkXVmUENsV5u0V3Yxd9Cp11YkVEpYt9lvMfZJI,36767
-atp/token_prices.py,sha256=A5EeNXkLfePktzQieGUVP5SGE5_KsClFVuL6B0vTr5k,3077
-atp/utils.py,sha256=VnYg6vmggUtrugwFc9Ecr8y45cxrFWv598WPK0w9y-0,5516
-atp/vault.py,sha256=ZMcrjCulI9j36nZtBw0kfL4k0Ul7LgUKyEedtN7o2ks,2193
-atp_protocol-1.0.0.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-atp_protocol-1.0.0.dist-info/METADATA,sha256=gIHO-KWejBOhVkvHFstqCBcqgZMZ6El3WNqGA7GLoO8,18442
-atp_protocol-1.0.0.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-atp_protocol-1.0.0.dist-info/RECORD,,