tensorfeed 1.2.0__tar.gz

tensorfeed-1.2.0/PKG-INFO

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: tensorfeed
+Version: 1.2.0
+Summary: Python SDK for the TensorFeed.ai API: AI news, status, model pricing, and agent-payable premium routing (USDC on Base, optional auto-send via web3)
+Author-email: "TensorFeed.ai" <feedback@tensorfeed.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://tensorfeed.ai
+Project-URL: Documentation, https://tensorfeed.ai/developers/agent-payments
+Project-URL: Repository, https://github.com/RipperMercs/tensorfeed
+Project-URL: Bug Tracker, https://github.com/RipperMercs/tensorfeed/issues
+Project-URL: Changelog, https://tensorfeed.ai/changelog
+Keywords: tensorfeed,ai,agents,x402,usdc,base,model-routing,llm,api,stablecoin
+Classifier: Development Status :: 4 - Beta
+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
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: web3
+Requires-Dist: web3>=6.0; extra == "web3"
+Requires-Dist: eth-account>=0.10; extra == "web3"
+
+# tensorfeed
+
+Python SDK for the [TensorFeed.ai](https://tensorfeed.ai) API.
+
+Free endpoints (news, status, models, benchmarks, history, routing preview) need no auth. The premium tier (top-N routing, plus more endpoints landing later) is paid via USDC on Base. No accounts, no API keys, no traditional payment processors.
+
+## Install
+
+```bash
+pip install tensorfeed
+```
+
+Stdlib-only. No external dependencies.
+
+## Free Tier
+
+```python
+from tensorfeed import TensorFeed
+
+tf = TensorFeed()
+
+# News
+for article in tf.news(category="research", limit=10)["articles"]:
+    print(article["title"])
+
+# Live AI service status
+for svc in tf.status()["services"]:
+    print(f'{svc["name"]}: {svc["status"]}')
+
+# Is a service down?
+print(tf.is_down("claude"))
+
+# Model pricing and benchmarks
+print(tf.models())
+print(tf.benchmarks())
+
+# Daily history snapshots (the moat)
+print(tf.history())  # list of available dates
+print(tf.history_snapshot("2026-04-27", "pricing"))
+
+# Free routing preview (top-1 model, 5 calls/day per IP)
+preview = tf.routing_preview(task="code")
+print(preview["recommendation"])
+```
+
+## Premium Tier (paid, USDC on Base)
+
+```python
+from tensorfeed import TensorFeed, PaymentRequired
+
+tf = TensorFeed()
+
+# Step 1: get a 30-minute quote
+quote = tf.buy_credits(amount_usd=1.00)
+print(f"Send {quote['amount_usd']} USDC on Base to {quote['wallet']}")
+print(f"Memo: {quote['memo']} (expires in {quote['ttl_seconds']}s)")
+print(f"Will get: {quote['credits']} credits")
+
+# Step 2: send the USDC tx with your wallet
+# (auto-send via web3 is on the roadmap; for v1.1 you sign and send manually)
+
+# Step 3: confirm with the tx hash
+result = tf.confirm(tx_hash="0xYOUR_TX_HASH", nonce=quote["memo"])
+print(f"Got {result['credits']} credits, token: {result['token']}")
+# The token is also stored on `tf` automatically; routing() will use it.
+
+# Step 4: call premium endpoints
+rec = tf.routing(task="code", budget=5.0, top_n=5)
+for r in rec["recommendations"]:
+    print(f'#{r["rank"]}: {r["model"]["name"]} (score: {r["composite_score"]:.2f})')
+
+# Custom routing weights
+rec = tf.routing(
+    task="general",
+    weights={"quality": 0.6, "cost": 0.3, "availability": 0.1, "latency": 0.0},
+)
+
+# Check remaining credits
+print(tf.balance())
+```
+
+## Auto-Send (optional, web3 extra)
+
+The base SDK keeps you dependency-free, but if you want to skip the manual tx step, install with the `web3` extra:
+
+```bash
+pip install 'tensorfeed[web3]'
+```
+
+Then `tf.purchase_credits()` quotes, signs, broadcasts, and confirms in one call:
+
+```python
+import os
+from tensorfeed import TensorFeed
+
+tf = TensorFeed()
+
+result = tf.purchase_credits(
+    amount_usd=1.00,
+    private_key=os.environ["TENSORFEED_PRIVATE_KEY"],  # NEVER hardcode
+    # rpc_url="https://base-mainnet.g.alchemy.com/v2/<key>",  # optional
+)
+print(result["token"])      # auto-stored on tf
+print(result["tx_hash"])    # for your records
+print(result["credits"])    # how many credits were minted
+
+# Token already on tf, so:
+rec = tf.routing(task="code")
+```
+
+Security: read the key from a secret manager or env var. Never commit it. The raw key is held in memory only for the duration of one signing call.
+
+## Reusing a Token Across Sessions
+
+Save the token after `confirm()`. Reuse it next time:
+
+```python
+# Save once
+token = result["token"]
+
+# Reuse in another process / job
+tf = TensorFeed(token=token)
+print(tf.balance())
+rec = tf.routing(task="code")
+```
+
+## Error Handling
+
+```python
+from tensorfeed import TensorFeed, PaymentRequired, RateLimited, TensorFeedError
+
+tf = TensorFeed(token="bad_token")
+try:
+    tf.routing(task="code")
+except PaymentRequired as e:
+    # 402: token invalid, expired, or out of credits
+    # e.payload contains wallet, credits required, top_up_at, etc.
+    print("Need to top up:", e.payload)
+except RateLimited as e:
+    # 429: free preview tier hit its 5/day per-IP limit
+    print("Hit the rate limit:", e.payload)
+except TensorFeedError as e:
+    # Other API errors
+    print("API error", e.status_code, e.payload)
+```
+
+## API Reference
+
+### Free
+
+| Method | Description |
+|--------|-------------|
+| `tf.news(category=, limit=)` | Latest AI news articles |
+| `tf.status()` | Real-time AI service status |
+| `tf.status_summary()` | Lightweight status summary |
+| `tf.models()` | Model pricing and specs |
+| `tf.benchmarks()` | Benchmark scores |
+| `tf.is_down(service_name)` | Check if a specific service is down |
+| `tf.agent_activity()` | Agent traffic metrics |
+| `tf.history()` | List of available daily snapshot dates |
+| `tf.history_snapshot(date, type)` | Read a specific snapshot |
+| `tf.routing_preview(task=)` | Top-1 routing recommendation (5/day/IP) |
+| `tf.health()` | API health check |
+| `tf.payment_info()` | Wallet, pricing, supported payment flows |
+| `tf.buy_credits(amount_usd=)` | Generate a 30-min payment quote |
+| `tf.confirm(tx_hash=, nonce=)` | Verify USDC tx, mint credit token |
+
+### Token-required
+
+| Method | Cost | Description |
+|--------|------|-------------|
+| `tf.balance()` | Free | Check remaining credits |
+| `tf.routing(task=, budget=, top_n=, weights=)` | 1 credit | Top-N ranked routing with full detail |
+
+### Auto-send (requires `tensorfeed[web3]`)
+
+| Method | Description |
+|--------|-------------|
+| `tf.purchase_credits(amount_usd=, private_key=, rpc_url=)` | One-call quote + sign + broadcast + confirm. Returns token, credits, tx_hash, block_number. |
+
+## Wallet & Trust
+
+The TensorFeed payment wallet is `0x549c82e6bfc54bdae9a2073744cbc2af5d1fc6d1` on Base mainnet. USDC contract: `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`.
+
+Cross-check this address before sending funds at:
+
+- https://tensorfeed.ai/llms.txt
+- https://tensorfeed.ai/api/payment/info
+- https://github.com/RipperMercs/tensorfeed (README)
+- https://x.com/tensorfeed (bio)
+
+If any source disagrees, do not send.
+
+## Premium Data Terms
+
+Premium API responses are licensed for inference use only. Use of TensorFeed premium data for training, fine-tuning, evaluation, or distillation of ML models is prohibited.
+
+## Refunds
+
+Email `evan@tensorfeed.ai` with the tx hash within 24 hours of the charge for a manual USDC refund.
+
+## Links
+
+- [API Docs](https://tensorfeed.ai/developers)
+- [TensorFeed.ai](https://tensorfeed.ai)
+- [GitHub](https://github.com/RipperMercs/tensorfeed)
+- [Changelog](https://tensorfeed.ai/changelog)
+
+## License
+
+MIT

tensorfeed-1.2.0/README.md

@@ -0,0 +1,211 @@
+# tensorfeed
+
+Python SDK for the [TensorFeed.ai](https://tensorfeed.ai) API.
+
+Free endpoints (news, status, models, benchmarks, history, routing preview) need no auth. The premium tier (top-N routing, plus more endpoints landing later) is paid via USDC on Base. No accounts, no API keys, no traditional payment processors.
+
+## Install
+
+```bash
+pip install tensorfeed
+```
+
+Stdlib-only. No external dependencies.
+
+## Free Tier
+
+```python
+from tensorfeed import TensorFeed
+
+tf = TensorFeed()
+
+# News
+for article in tf.news(category="research", limit=10)["articles"]:
+    print(article["title"])
+
+# Live AI service status
+for svc in tf.status()["services"]:
+    print(f'{svc["name"]}: {svc["status"]}')
+
+# Is a service down?
+print(tf.is_down("claude"))
+
+# Model pricing and benchmarks
+print(tf.models())
+print(tf.benchmarks())
+
+# Daily history snapshots (the moat)
+print(tf.history())  # list of available dates
+print(tf.history_snapshot("2026-04-27", "pricing"))
+
+# Free routing preview (top-1 model, 5 calls/day per IP)
+preview = tf.routing_preview(task="code")
+print(preview["recommendation"])
+```
+
+## Premium Tier (paid, USDC on Base)
+
+```python
+from tensorfeed import TensorFeed, PaymentRequired
+
+tf = TensorFeed()
+
+# Step 1: get a 30-minute quote
+quote = tf.buy_credits(amount_usd=1.00)
+print(f"Send {quote['amount_usd']} USDC on Base to {quote['wallet']}")
+print(f"Memo: {quote['memo']} (expires in {quote['ttl_seconds']}s)")
+print(f"Will get: {quote['credits']} credits")
+
+# Step 2: send the USDC tx with your wallet
+# (auto-send via web3 is on the roadmap; for v1.1 you sign and send manually)
+
+# Step 3: confirm with the tx hash
+result = tf.confirm(tx_hash="0xYOUR_TX_HASH", nonce=quote["memo"])
+print(f"Got {result['credits']} credits, token: {result['token']}")
+# The token is also stored on `tf` automatically; routing() will use it.
+
+# Step 4: call premium endpoints
+rec = tf.routing(task="code", budget=5.0, top_n=5)
+for r in rec["recommendations"]:
+    print(f'#{r["rank"]}: {r["model"]["name"]} (score: {r["composite_score"]:.2f})')
+
+# Custom routing weights
+rec = tf.routing(
+    task="general",
+    weights={"quality": 0.6, "cost": 0.3, "availability": 0.1, "latency": 0.0},
+)
+
+# Check remaining credits
+print(tf.balance())
+```
+
+## Auto-Send (optional, web3 extra)
+
+The base SDK keeps you dependency-free, but if you want to skip the manual tx step, install with the `web3` extra:
+
+```bash
+pip install 'tensorfeed[web3]'
+```
+
+Then `tf.purchase_credits()` quotes, signs, broadcasts, and confirms in one call:
+
+```python
+import os
+from tensorfeed import TensorFeed
+
+tf = TensorFeed()
+
+result = tf.purchase_credits(
+    amount_usd=1.00,
+    private_key=os.environ["TENSORFEED_PRIVATE_KEY"],  # NEVER hardcode
+    # rpc_url="https://base-mainnet.g.alchemy.com/v2/<key>",  # optional
+)
+print(result["token"])      # auto-stored on tf
+print(result["tx_hash"])    # for your records
+print(result["credits"])    # how many credits were minted
+
+# Token already on tf, so:
+rec = tf.routing(task="code")
+```
+
+Security: read the key from a secret manager or env var. Never commit it. The raw key is held in memory only for the duration of one signing call.
+
+## Reusing a Token Across Sessions
+
+Save the token after `confirm()`. Reuse it next time:
+
+```python
+# Save once
+token = result["token"]
+
+# Reuse in another process / job
+tf = TensorFeed(token=token)
+print(tf.balance())
+rec = tf.routing(task="code")
+```
+
+## Error Handling
+
+```python
+from tensorfeed import TensorFeed, PaymentRequired, RateLimited, TensorFeedError
+
+tf = TensorFeed(token="bad_token")
+try:
+    tf.routing(task="code")
+except PaymentRequired as e:
+    # 402: token invalid, expired, or out of credits
+    # e.payload contains wallet, credits required, top_up_at, etc.
+    print("Need to top up:", e.payload)
+except RateLimited as e:
+    # 429: free preview tier hit its 5/day per-IP limit
+    print("Hit the rate limit:", e.payload)
+except TensorFeedError as e:
+    # Other API errors
+    print("API error", e.status_code, e.payload)
+```
+
+## API Reference
+
+### Free
+
+| Method | Description |
+|--------|-------------|
+| `tf.news(category=, limit=)` | Latest AI news articles |
+| `tf.status()` | Real-time AI service status |
+| `tf.status_summary()` | Lightweight status summary |
+| `tf.models()` | Model pricing and specs |
+| `tf.benchmarks()` | Benchmark scores |
+| `tf.is_down(service_name)` | Check if a specific service is down |
+| `tf.agent_activity()` | Agent traffic metrics |
+| `tf.history()` | List of available daily snapshot dates |
+| `tf.history_snapshot(date, type)` | Read a specific snapshot |
+| `tf.routing_preview(task=)` | Top-1 routing recommendation (5/day/IP) |
+| `tf.health()` | API health check |
+| `tf.payment_info()` | Wallet, pricing, supported payment flows |
+| `tf.buy_credits(amount_usd=)` | Generate a 30-min payment quote |
+| `tf.confirm(tx_hash=, nonce=)` | Verify USDC tx, mint credit token |
+
+### Token-required
+
+| Method | Cost | Description |
+|--------|------|-------------|
+| `tf.balance()` | Free | Check remaining credits |
+| `tf.routing(task=, budget=, top_n=, weights=)` | 1 credit | Top-N ranked routing with full detail |
+
+### Auto-send (requires `tensorfeed[web3]`)
+
+| Method | Description |
+|--------|-------------|
+| `tf.purchase_credits(amount_usd=, private_key=, rpc_url=)` | One-call quote + sign + broadcast + confirm. Returns token, credits, tx_hash, block_number. |
+
+## Wallet & Trust
+
+The TensorFeed payment wallet is `0x549c82e6bfc54bdae9a2073744cbc2af5d1fc6d1` on Base mainnet. USDC contract: `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`.
+
+Cross-check this address before sending funds at:
+
+- https://tensorfeed.ai/llms.txt
+- https://tensorfeed.ai/api/payment/info
+- https://github.com/RipperMercs/tensorfeed (README)
+- https://x.com/tensorfeed (bio)
+
+If any source disagrees, do not send.
+
+## Premium Data Terms
+
+Premium API responses are licensed for inference use only. Use of TensorFeed premium data for training, fine-tuning, evaluation, or distillation of ML models is prohibited.
+
+## Refunds
+
+Email `evan@tensorfeed.ai` with the tx hash within 24 hours of the charge for a manual USDC refund.
+
+## Links
+
+- [API Docs](https://tensorfeed.ai/developers)
+- [TensorFeed.ai](https://tensorfeed.ai)
+- [GitHub](https://github.com/RipperMercs/tensorfeed)
+- [Changelog](https://tensorfeed.ai/changelog)
+
+## License
+
+MIT

tensorfeed-1.2.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=68.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tensorfeed"
+version = "1.2.0"
+description = "Python SDK for the TensorFeed.ai API: AI news, status, model pricing, and agent-payable premium routing (USDC on Base, optional auto-send via web3)"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [{ name = "TensorFeed.ai", email = "feedback@tensorfeed.ai" }]
+keywords = [
+    "tensorfeed",
+    "ai",
+    "agents",
+    "x402",
+    "usdc",
+    "base",
+    "model-routing",
+    "llm",
+    "api",
+    "stablecoin",
+]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.optional-dependencies]
+# pip install 'tensorfeed[web3]' to enable TensorFeed.purchase_credits()
+# (one-shot signed USDC transfer on Base + automatic confirm).
+web3 = [
+    "web3>=6.0",
+    "eth-account>=0.10",
+]
+
+[project.urls]
+Homepage = "https://tensorfeed.ai"
+Documentation = "https://tensorfeed.ai/developers/agent-payments"
+Repository = "https://github.com/RipperMercs/tensorfeed"
+"Bug Tracker" = "https://github.com/RipperMercs/tensorfeed/issues"
+Changelog = "https://tensorfeed.ai/changelog"

tensorfeed-1.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tensorfeed-1.2.0/tensorfeed/__init__.py

@@ -0,0 +1,24 @@
+"""
+TensorFeed.ai Python SDK
+
+Free, no-auth API client for AI news, service status, and model data.
+Plus a paid premium tier (USDC on Base) for ranked model routing
+recommendations and other intelligence endpoints.
+
+https://tensorfeed.ai/developers
+"""
+
+from .client import (
+    TensorFeed,
+    TensorFeedError,
+    PaymentRequired,
+    RateLimited,
+)
+
+__all__ = [
+    "TensorFeed",
+    "TensorFeedError",
+    "PaymentRequired",
+    "RateLimited",
+]
+__version__ = "1.2.0"

tensorfeed-1.2.0/tensorfeed/client.py

@@ -0,0 +1,407 @@
+"""TensorFeed API client.
+
+Stdlib-only HTTP client for the TensorFeed.ai API. Covers all free
+endpoints (news, status, models, benchmarks, history, routing preview,
+agent activity) plus the paid premium tier (routing, payment flow).
+
+Premium endpoints are paid via USDC on Base. No accounts, no API keys,
+no traditional payment processors. See ``buy_credits()`` and ``confirm()``.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any  # noqa: F401  (re-exported by purchase_credits return type)
+
+
+DEFAULT_BASE_URL = "https://tensorfeed.ai/api"
+DEFAULT_USER_AGENT = "TensorFeed-SDK-Python/1.1"
+
+
+class TensorFeedError(Exception):
+    """Base class for all TensorFeed SDK errors."""
+
+    def __init__(self, status_code: int, payload: dict[str, Any]) -> None:
+        self.status_code = status_code
+        self.payload = payload
+        msg = payload.get("error") or payload.get("message") or str(payload)
+        super().__init__(f"TensorFeed API error {status_code}: {msg}")
+
+
+class PaymentRequired(TensorFeedError):
+    """Raised on HTTP 402.
+
+    Inspect ``e.payload`` for wallet, credits required, and pricing
+    metadata. Premium endpoints return 402 when no token is provided
+    or the token has insufficient credits.
+    """
+
+
+class RateLimited(TensorFeedError):
+    """Raised on HTTP 429 (free preview tier rate limit, 5/day per IP)."""
+
+
+class TensorFeed:
+    """Client for the TensorFeed.ai API.
+
+    Free endpoints work without auth. Paid endpoints require a bearer
+    token obtained via ``buy_credits()`` and ``confirm()``.
+
+    Usage::
+
+        from tensorfeed import TensorFeed
+
+        # Free
+        tf = TensorFeed()
+        news = tf.news(limit=10)
+        preview = tf.routing_preview(task="code")
+
+        # Paid: buy credits, then call routing
+        quote = tf.buy_credits(amount_usd=1.00)
+        # ... send USDC tx ...
+        result = tf.confirm(tx_hash="0x...", nonce=quote["memo"])
+        # token is auto-stored on the client
+        rec = tf.routing(task="code", top_n=5)
+    """
+
+    def __init__(
+        self,
+        token: str | None = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 15.0,
+        user_agent: str = DEFAULT_USER_AGENT,
+    ) -> None:
+        self.token = token
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+        self.user_agent = user_agent
+
+    # ── HTTP plumbing ──────────────────────────────────────────────
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        body: dict[str, Any] | None = None,
+        require_token: bool = False,
+    ) -> dict[str, Any]:
+        url = f"{self.base_url}{path}"
+        if params:
+            cleaned = {k: v for k, v in params.items() if v is not None}
+            if cleaned:
+                url = f"{url}?{urllib.parse.urlencode(cleaned)}"
+
+        headers: dict[str, str] = {"User-Agent": self.user_agent}
+        data: bytes | None = None
+        if body is not None:
+            headers["Content-Type"] = "application/json"
+            data = json.dumps(body).encode("utf-8")
+
+        # Premium endpoints, balance, and explicit-require-token paths get
+        # the Authorization header. Free endpoints do not advertise a token
+        # (avoids accidentally leaking it to public-data endpoints).
+        needs_auth = (
+            require_token
+            or "/api/premium/" in path
+            or path == "/api/payment/balance"
+        )
+        if needs_auth and self.token:
+            headers["Authorization"] = f"Bearer {self.token}"
+
+        req = urllib.request.Request(url, data=data, headers=headers, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=self.timeout) as resp:
+                return json.loads(resp.read().decode())
+        except urllib.error.HTTPError as e:
+            try:
+                payload = json.loads(e.read().decode())
+            except Exception:
+                payload = {"error": "non_json_response", "status": e.code}
+            if e.code == 402:
+                raise PaymentRequired(402, payload) from e
+            if e.code == 429:
+                raise RateLimited(429, payload) from e
+            raise TensorFeedError(e.code, payload) from e
+
+    def _get(self, path: str, **params: Any) -> dict[str, Any]:
+        return self._request("GET", path, params=params)
+
+    def _post(self, path: str, body: dict[str, Any]) -> dict[str, Any]:
+        return self._request("POST", path, body=body)
+
+    # ── Free: news, status, models ─────────────────────────────────
+
+    def news(
+        self, *, category: str | None = None, limit: int | None = None
+    ) -> dict[str, Any]:
+        """Get latest AI news articles. Free.
+
+        Args:
+            category: Filter by category (e.g. "research", "tools")
+            limit: Number of articles (default 50, max 200)
+        """
+        return self._get("/news", category=category, limit=limit)
+
+    def status(self) -> dict[str, Any]:
+        """Get real-time AI service status. Free."""
+        return self._get("/status")
+
+    def status_summary(self) -> dict[str, Any]:
+        """Get lightweight status summary. Free."""
+        return self._get("/status/summary")
+
+    def models(self) -> dict[str, Any]:
+        """Get AI model pricing and specs. Free."""
+        return self._get("/models")
+
+    def benchmarks(self) -> dict[str, Any]:
+        """Get AI model benchmark scores. Free."""
+        return self._get("/benchmarks")
+
+    def agent_activity(self) -> dict[str, Any]:
+        """Get agent traffic metrics. Free."""
+        return self._get("/agents/activity")
+
+    def health(self) -> dict[str, Any]:
+        """API health check. Free."""
+        return self._get("/health")
+
+    def is_down(self, service_name: str) -> dict[str, Any]:
+        """Check if a specific AI service is down.
+
+        Args:
+            service_name: Service to check (e.g. "claude", "openai", "gemini")
+        """
+        data = self.status()
+        needle = service_name.lower()
+        for svc in data.get("services", []):
+            if needle in svc["name"].lower() or needle in svc["provider"].lower():
+                return {
+                    "name": svc["name"],
+                    "status": svc["status"],
+                    "is_down": svc["status"] == "down",
+                }
+        names = ", ".join(s["name"] for s in data.get("services", []))
+        raise ValueError(
+            f'Service "{service_name}" not found. Available: {names}'
+        )
+
+    # ── Free: history snapshots ────────────────────────────────────
+
+    def history(self) -> dict[str, Any]:
+        """List available daily history snapshot dates. Free."""
+        return self._get("/history")
+
+    def history_snapshot(self, date: str, snapshot_type: str) -> dict[str, Any]:
+        """Read a specific historical snapshot. Free.
+
+        Args:
+            date: YYYY-MM-DD UTC
+            snapshot_type: pricing, models, benchmarks, status, or agent-activity
+        """
+        return self._get(f"/history/{date}/{snapshot_type}")
+
+    # ── Free: routing preview (rate-limited) ───────────────────────
+
+    def routing_preview(
+        self,
+        *,
+        task: str = "general",
+        budget: float | None = None,
+        min_quality: float | None = None,
+    ) -> dict[str, Any]:
+        """Top-1 model recommendation. Free, 5 calls/day per IP.
+
+        For full top-5 with score breakdown and no rate limit, use
+        ``routing()`` with credits.
+
+        Args:
+            task: code, reasoning, creative, or general (default general)
+            budget: optional max blended USD per 1M tokens
+            min_quality: optional minimum quality score in [0, 1]
+
+        Raises:
+            RateLimited: after 5 free preview calls per UTC day from an IP
+        """
+        return self._get(
+            "/preview/routing",
+            task=task,
+            budget=budget,
+            min_quality=min_quality,
+        )
+
+    # ── Payment flow ───────────────────────────────────────────────
+
+    def payment_info(self) -> dict[str, Any]:
+        """Get wallet address, pricing, and supported flows. Free.
+
+        Use this to verify the wallet address before sending USDC.
+        Cross-check against ``llms.txt``, the GitHub README, and the
+        @tensorfeed X bio.
+        """
+        return self._get("/payment/info")
+
+    def buy_credits(self, *, amount_usd: float) -> dict[str, Any]:
+        """Generate a 30-min payment quote.
+
+        Returns a dict with ``wallet``, ``memo``, ``amount_usd``, ``credits``,
+        ``expires_at``, ``ttl_seconds``, ``next_step``.
+
+        Send the USDC on Base to ``wallet`` (memo is optional but recommended),
+        then call ``confirm()`` with the tx hash and the ``memo`` as nonce.
+
+        Args:
+            amount_usd: USD value of credits to buy. Must be 0.5 to 10000.
+                Volume discounts apply at $5 (10%), $30 (25%), $200 (40%).
+        """
+        return self._post("/payment/buy-credits", {"amount_usd": amount_usd})
+
+    def confirm(
+        self,
+        *,
+        tx_hash: str,
+        nonce: str | None = None,
+    ) -> dict[str, Any]:
+        """Verify a USDC tx on-chain and mint a credit token.
+
+        On success, the returned token is also stored on this client
+        instance, so subsequent calls to ``routing()``, ``balance()``,
+        etc. work immediately.
+
+        Returns a dict with ``token``, ``credits``, ``balance``,
+        ``tx_amount_usd``, ``rate``.
+
+        Args:
+            tx_hash: 0x-prefixed Base mainnet transaction hash
+            nonce: optional memo from ``buy_credits()``. If provided and
+                the tx amount matches the quote within $0.01, the quoted
+                credits (with volume discount) are applied. Otherwise
+                credits are calculated from the actual tx amount.
+        """
+        body: dict[str, Any] = {"tx_hash": tx_hash}
+        if nonce is not None:
+            body["nonce"] = nonce
+        result = self._post("/payment/confirm", body)
+        if isinstance(result, dict) and result.get("ok") and result.get("token"):
+            self.token = str(result["token"])
+        return result
+
+    def balance(self) -> dict[str, Any]:
+        """Check remaining credits for the current token.
+
+        Raises:
+            ValueError: if no token is set on the client
+        """
+        if not self.token:
+            raise ValueError(
+                "balance() requires a token. Set it via TensorFeed(token=...) "
+                "or call confirm() first."
+            )
+        return self._request("GET", "/payment/balance", require_token=True)
+
+    # ── Auto-purchase via web3 (optional dependency) ───────────────
+
+    def purchase_credits(
+        self,
+        *,
+        amount_usd: float,
+        private_key: str,
+        rpc_url: str | None = None,
+        wait_seconds: int = 90,
+    ) -> dict[str, Any]:
+        """Buy credits end-to-end: quote, sign USDC tx, broadcast, confirm.
+
+        Convenience wrapper around buy_credits() + raw signing + confirm()
+        that handles the whole flow in one call. The token is auto-stored
+        on this client on success, so subsequent ``routing()`` calls work
+        immediately.
+
+        Requires the optional ``web3`` extra:
+            pip install 'tensorfeed[web3]'
+
+        Args:
+            amount_usd: USD value of credits to buy (0.5 to 10000)
+            private_key: 0x-prefixed Ethereum private key. DO NOT
+                hardcode; read from an env var or secret manager.
+            rpc_url: Base mainnet RPC. Defaults to public Base RPC,
+                which is fine for occasional use. For production use
+                Alchemy or QuickNode.
+            wait_seconds: Max seconds to wait for tx confirmation
+                (default 90)
+
+        Returns:
+            Dict with token, credits, balance, tx_hash, tx_amount_usd,
+            rate, block_number.
+
+        Raises:
+            Web3NotInstalled: if pip install 'tensorfeed[web3]' was not run
+            TimeoutError: if the tx doesn't confirm in wait_seconds
+            RuntimeError: on RPC failure, on-chain revert, or
+                TensorFeed-side rejection
+        """
+        from .web3_signer import auto_purchase_credits  # lazy import
+        return auto_purchase_credits(
+            self,
+            amount_usd=amount_usd,
+            private_key=private_key,
+            rpc_url=rpc_url,
+            wait_seconds=wait_seconds,
+        )
+
+    # ── Paid: routing (Tier 2, 1 credit/call) ──────────────────────
+
+    def routing(
+        self,
+        *,
+        task: str = "general",
+        budget: float | None = None,
+        min_quality: float | None = None,
+        top_n: int = 5,
+        weights: dict[str, float] | None = None,
+    ) -> dict[str, Any]:
+        """Tier 2 routing: top-N ranked models with full score breakdown.
+
+        Costs 1 credit per call. Requires a token from ``confirm()`` or
+        passed to the constructor.
+
+        Args:
+            task: code, reasoning, creative, or general
+            budget: optional max blended USD per 1M tokens
+            min_quality: optional minimum quality score in [0, 1]
+            top_n: how many models to return (1 to 10, default 5)
+            weights: optional dict of {quality, availability, cost, latency}
+                weights to override the defaults (0.4, 0.3, 0.2, 0.1).
+                Will be normalized server-side to sum to 1.
+
+        Raises:
+            ValueError: if no token is set on the client
+            PaymentRequired: if the token has insufficient credits
+
+        Example::
+
+            rec = tf.routing(task="code", budget=5.0, top_n=3)
+            for r in rec["recommendations"]:
+                print(r["model"]["name"], r["composite_score"])
+        """
+        if not self.token:
+            raise ValueError(
+                "routing() requires a token. Buy credits via buy_credits() and "
+                "confirm(), or pass an existing token to TensorFeed(token=...)."
+            )
+        params: dict[str, Any] = {"task": task, "top_n": top_n}
+        if budget is not None:
+            params["budget"] = budget
+        if min_quality is not None:
+            params["min_quality"] = min_quality
+        if weights:
+            for key in ("quality", "availability", "cost", "latency"):
+                if key in weights:
+                    params[f"w_{key}"] = weights[key]
+        return self._request(
+            "GET", "/premium/routing", params=params, require_token=True
+        )

tensorfeed-1.2.0/tensorfeed/web3_signer.py

@@ -0,0 +1,175 @@
+"""
+Optional web3 integration for one-shot credit purchases.
+
+This module is loaded lazily and is only imported when the user calls
+``TensorFeed.purchase_credits()``. The base SDK has zero external
+dependencies; web3.py is only required when you want auto-send.
+
+Install with: pip install tensorfeed[web3]
+
+Security:
+    The auto-send flow takes a raw private key as a Python string. This
+    is convenient but easy to leak. Prefer reading the key from an
+    environment variable, never hardcode it in source, and never log it.
+    Cloudflare Workers and similar environments should keep the key in
+    a secret manager.
+
+    For higher security, sign transactions externally (e.g., via a
+    hardware wallet or remote signer) and call ``TensorFeed.confirm()``
+    with the resulting tx hash directly. The auto-send path here is for
+    server-side agents that hold their own keys.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from .client import TensorFeed
+
+USDC_BASE_CONTRACT = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
+DEFAULT_BASE_RPC = "https://mainnet.base.org"
+BASE_CHAIN_ID = 8453
+USDC_DECIMALS = 6
+
+# Minimal ERC-20 transfer ABI; we do not need the full standard
+USDC_TRANSFER_ABI = [
+    {
+        "name": "transfer",
+        "type": "function",
+        "stateMutability": "nonpayable",
+        "inputs": [
+            {"name": "to", "type": "address"},
+            {"name": "amount", "type": "uint256"},
+        ],
+        "outputs": [{"name": "", "type": "bool"}],
+    },
+]
+
+
+class Web3NotInstalled(ImportError):
+    """Raised when web3.py is not installed but auto-send was requested."""
+
+
+def auto_purchase_credits(
+    tf: "TensorFeed",
+    *,
+    amount_usd: float,
+    private_key: str,
+    rpc_url: str | None = None,
+    wait_seconds: int = 90,
+    poll_interval: float = 2.0,
+) -> dict[str, Any]:
+    """Buy credits end-to-end: quote, sign USDC tx, broadcast, confirm.
+
+    Args:
+        tf: The TensorFeed client. Token is auto-stored on success so
+            subsequent calls to ``tf.routing()`` etc. work immediately.
+        amount_usd: USD value of credits to buy. Must be 0.5 to 10000.
+        private_key: 0x-prefixed Ethereum private key for signing the
+            USDC transfer. NEVER hardcode this; read from a secure env
+            var. The key is held in memory only for the duration of
+            this call.
+        rpc_url: Base mainnet RPC endpoint. Defaults to the free public
+            Base RPC, which is fine for occasional use. For production
+            use Alchemy or QuickNode.
+        wait_seconds: Max wall-clock seconds to wait for tx confirmation
+            before raising TimeoutError. Default 90.
+        poll_interval: Seconds between receipt polls.
+
+    Returns:
+        Dict with ``token``, ``credits``, ``balance``, ``tx_hash``,
+        ``tx_amount_usd``, ``rate``.
+
+    Raises:
+        Web3NotInstalled: if web3.py is not installed
+        TimeoutError: if the tx does not confirm within wait_seconds
+        RuntimeError: on RPC connection failure, on-chain tx revert, or
+            TensorFeed-side rejection of the confirmed tx
+    """
+    try:
+        from web3 import Web3
+        from eth_account import Account
+    except ImportError as e:
+        raise Web3NotInstalled(
+            "web3 is not installed. Run: pip install 'tensorfeed[web3]'\n"
+            "Then retry, or use the manual flow: tf.buy_credits() + sign "
+            "the USDC tx yourself + tf.confirm(tx_hash=..., nonce=...)."
+        ) from e
+
+    rpc = rpc_url or DEFAULT_BASE_RPC
+    w3 = Web3(Web3.HTTPProvider(rpc, request_kwargs={"timeout": 15}))
+    if not w3.is_connected():
+        raise RuntimeError(f"Cannot reach Base RPC at {rpc}")
+
+    account = Account.from_key(private_key)
+    sender = account.address
+
+    # Step 1: TensorFeed-side quote
+    quote = tf.buy_credits(amount_usd=amount_usd)
+    receiving_wallet = quote["wallet"]
+    memo = quote["memo"]
+
+    # Step 2: build USDC transfer tx on Base
+    usdc = w3.eth.contract(
+        address=Web3.to_checksum_address(USDC_BASE_CONTRACT),
+        abi=USDC_TRANSFER_ABI,
+    )
+    amount_units = int(round(amount_usd * (10 ** USDC_DECIMALS)))
+
+    tx_nonce = w3.eth.get_transaction_count(sender)
+    tx = usdc.functions.transfer(
+        Web3.to_checksum_address(receiving_wallet), amount_units
+    ).build_transaction(
+        {
+            "from": sender,
+            "nonce": tx_nonce,
+            "chainId": BASE_CHAIN_ID,
+        }
+    )
+    if "gas" not in tx:
+        tx["gas"] = w3.eth.estimate_gas(tx)
+
+    # Step 3: sign + broadcast
+    signed = Account.sign_transaction(tx, private_key=private_key)
+    raw_tx = getattr(signed, "raw_transaction", None) or getattr(signed, "rawTransaction")
+    tx_hash_bytes = w3.eth.send_raw_transaction(raw_tx)
+    tx_hash = "0x" + tx_hash_bytes.hex().lstrip("0x")
+
+    # Step 4: wait for confirmation
+    deadline = time.time() + wait_seconds
+    receipt = None
+    while time.time() < deadline:
+        try:
+            receipt = w3.eth.get_transaction_receipt(tx_hash_bytes)
+            if receipt is not None:
+                break
+        except Exception:
+            pass  # tx may not be mined yet; keep polling
+        time.sleep(poll_interval)
+
+    if receipt is None:
+        raise TimeoutError(
+            f"Tx {tx_hash} did not confirm within {wait_seconds}s. "
+            f"You can complete the purchase manually once it confirms by "
+            f"calling tf.confirm(tx_hash={tx_hash!r}, nonce={memo!r})."
+        )
+    if int(getattr(receipt, "status", 0)) != 1:
+        raise RuntimeError(
+            f"Tx {tx_hash} reverted on-chain (status=0). No credits were minted."
+        )
+
+    # Step 5: TensorFeed-side confirm
+    result = tf.confirm(tx_hash=tx_hash, nonce=memo)
+    if not result.get("ok"):
+        raise RuntimeError(
+            f"Tx {tx_hash} mined but TensorFeed rejected confirm: {result}. "
+            f"Email evan@tensorfeed.ai with the tx hash for a manual reconciliation."
+        )
+
+    return {
+        **result,
+        "tx_hash": tx_hash,
+        "block_number": getattr(receipt, "blockNumber", None),
+    }

tensorfeed-1.2.0/tensorfeed.egg-info/PKG-INFO

@@ -0,0 +1,238 @@
+Metadata-Version: 2.4
+Name: tensorfeed
+Version: 1.2.0
+Summary: Python SDK for the TensorFeed.ai API: AI news, status, model pricing, and agent-payable premium routing (USDC on Base, optional auto-send via web3)
+Author-email: "TensorFeed.ai" <feedback@tensorfeed.ai>
+License-Expression: MIT
+Project-URL: Homepage, https://tensorfeed.ai
+Project-URL: Documentation, https://tensorfeed.ai/developers/agent-payments
+Project-URL: Repository, https://github.com/RipperMercs/tensorfeed
+Project-URL: Bug Tracker, https://github.com/RipperMercs/tensorfeed/issues
+Project-URL: Changelog, https://tensorfeed.ai/changelog
+Keywords: tensorfeed,ai,agents,x402,usdc,base,model-routing,llm,api,stablecoin
+Classifier: Development Status :: 4 - Beta
+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
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: web3
+Requires-Dist: web3>=6.0; extra == "web3"
+Requires-Dist: eth-account>=0.10; extra == "web3"
+
+# tensorfeed
+
+Python SDK for the [TensorFeed.ai](https://tensorfeed.ai) API.
+
+Free endpoints (news, status, models, benchmarks, history, routing preview) need no auth. The premium tier (top-N routing, plus more endpoints landing later) is paid via USDC on Base. No accounts, no API keys, no traditional payment processors.
+
+## Install
+
+```bash
+pip install tensorfeed
+```
+
+Stdlib-only. No external dependencies.
+
+## Free Tier
+
+```python
+from tensorfeed import TensorFeed
+
+tf = TensorFeed()
+
+# News
+for article in tf.news(category="research", limit=10)["articles"]:
+    print(article["title"])
+
+# Live AI service status
+for svc in tf.status()["services"]:
+    print(f'{svc["name"]}: {svc["status"]}')
+
+# Is a service down?
+print(tf.is_down("claude"))
+
+# Model pricing and benchmarks
+print(tf.models())
+print(tf.benchmarks())
+
+# Daily history snapshots (the moat)
+print(tf.history())  # list of available dates
+print(tf.history_snapshot("2026-04-27", "pricing"))
+
+# Free routing preview (top-1 model, 5 calls/day per IP)
+preview = tf.routing_preview(task="code")
+print(preview["recommendation"])
+```
+
+## Premium Tier (paid, USDC on Base)
+
+```python
+from tensorfeed import TensorFeed, PaymentRequired
+
+tf = TensorFeed()
+
+# Step 1: get a 30-minute quote
+quote = tf.buy_credits(amount_usd=1.00)
+print(f"Send {quote['amount_usd']} USDC on Base to {quote['wallet']}")
+print(f"Memo: {quote['memo']} (expires in {quote['ttl_seconds']}s)")
+print(f"Will get: {quote['credits']} credits")
+
+# Step 2: send the USDC tx with your wallet
+# (auto-send via web3 is on the roadmap; for v1.1 you sign and send manually)
+
+# Step 3: confirm with the tx hash
+result = tf.confirm(tx_hash="0xYOUR_TX_HASH", nonce=quote["memo"])
+print(f"Got {result['credits']} credits, token: {result['token']}")
+# The token is also stored on `tf` automatically; routing() will use it.
+
+# Step 4: call premium endpoints
+rec = tf.routing(task="code", budget=5.0, top_n=5)
+for r in rec["recommendations"]:
+    print(f'#{r["rank"]}: {r["model"]["name"]} (score: {r["composite_score"]:.2f})')
+
+# Custom routing weights
+rec = tf.routing(
+    task="general",
+    weights={"quality": 0.6, "cost": 0.3, "availability": 0.1, "latency": 0.0},
+)
+
+# Check remaining credits
+print(tf.balance())
+```
+
+## Auto-Send (optional, web3 extra)
+
+The base SDK keeps you dependency-free, but if you want to skip the manual tx step, install with the `web3` extra:
+
+```bash
+pip install 'tensorfeed[web3]'
+```
+
+Then `tf.purchase_credits()` quotes, signs, broadcasts, and confirms in one call:
+
+```python
+import os
+from tensorfeed import TensorFeed
+
+tf = TensorFeed()
+
+result = tf.purchase_credits(
+    amount_usd=1.00,
+    private_key=os.environ["TENSORFEED_PRIVATE_KEY"],  # NEVER hardcode
+    # rpc_url="https://base-mainnet.g.alchemy.com/v2/<key>",  # optional
+)
+print(result["token"])      # auto-stored on tf
+print(result["tx_hash"])    # for your records
+print(result["credits"])    # how many credits were minted
+
+# Token already on tf, so:
+rec = tf.routing(task="code")
+```
+
+Security: read the key from a secret manager or env var. Never commit it. The raw key is held in memory only for the duration of one signing call.
+
+## Reusing a Token Across Sessions
+
+Save the token after `confirm()`. Reuse it next time:
+
+```python
+# Save once
+token = result["token"]
+
+# Reuse in another process / job
+tf = TensorFeed(token=token)
+print(tf.balance())
+rec = tf.routing(task="code")
+```
+
+## Error Handling
+
+```python
+from tensorfeed import TensorFeed, PaymentRequired, RateLimited, TensorFeedError
+
+tf = TensorFeed(token="bad_token")
+try:
+    tf.routing(task="code")
+except PaymentRequired as e:
+    # 402: token invalid, expired, or out of credits
+    # e.payload contains wallet, credits required, top_up_at, etc.
+    print("Need to top up:", e.payload)
+except RateLimited as e:
+    # 429: free preview tier hit its 5/day per-IP limit
+    print("Hit the rate limit:", e.payload)
+except TensorFeedError as e:
+    # Other API errors
+    print("API error", e.status_code, e.payload)
+```
+
+## API Reference
+
+### Free
+
+| Method | Description |
+|--------|-------------|
+| `tf.news(category=, limit=)` | Latest AI news articles |
+| `tf.status()` | Real-time AI service status |
+| `tf.status_summary()` | Lightweight status summary |
+| `tf.models()` | Model pricing and specs |
+| `tf.benchmarks()` | Benchmark scores |
+| `tf.is_down(service_name)` | Check if a specific service is down |
+| `tf.agent_activity()` | Agent traffic metrics |
+| `tf.history()` | List of available daily snapshot dates |
+| `tf.history_snapshot(date, type)` | Read a specific snapshot |
+| `tf.routing_preview(task=)` | Top-1 routing recommendation (5/day/IP) |
+| `tf.health()` | API health check |
+| `tf.payment_info()` | Wallet, pricing, supported payment flows |
+| `tf.buy_credits(amount_usd=)` | Generate a 30-min payment quote |
+| `tf.confirm(tx_hash=, nonce=)` | Verify USDC tx, mint credit token |
+
+### Token-required
+
+| Method | Cost | Description |
+|--------|------|-------------|
+| `tf.balance()` | Free | Check remaining credits |
+| `tf.routing(task=, budget=, top_n=, weights=)` | 1 credit | Top-N ranked routing with full detail |
+
+### Auto-send (requires `tensorfeed[web3]`)
+
+| Method | Description |
+|--------|-------------|
+| `tf.purchase_credits(amount_usd=, private_key=, rpc_url=)` | One-call quote + sign + broadcast + confirm. Returns token, credits, tx_hash, block_number. |
+
+## Wallet & Trust
+
+The TensorFeed payment wallet is `0x549c82e6bfc54bdae9a2073744cbc2af5d1fc6d1` on Base mainnet. USDC contract: `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913`.
+
+Cross-check this address before sending funds at:
+
+- https://tensorfeed.ai/llms.txt
+- https://tensorfeed.ai/api/payment/info
+- https://github.com/RipperMercs/tensorfeed (README)
+- https://x.com/tensorfeed (bio)
+
+If any source disagrees, do not send.
+
+## Premium Data Terms
+
+Premium API responses are licensed for inference use only. Use of TensorFeed premium data for training, fine-tuning, evaluation, or distillation of ML models is prohibited.
+
+## Refunds
+
+Email `evan@tensorfeed.ai` with the tx hash within 24 hours of the charge for a manual USDC refund.
+
+## Links
+
+- [API Docs](https://tensorfeed.ai/developers)
+- [TensorFeed.ai](https://tensorfeed.ai)
+- [GitHub](https://github.com/RipperMercs/tensorfeed)
+- [Changelog](https://tensorfeed.ai/changelog)
+
+## License
+
+MIT

tensorfeed-1.2.0/tensorfeed.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+tensorfeed/__init__.py
+tensorfeed/client.py
+tensorfeed/web3_signer.py
+tensorfeed.egg-info/PKG-INFO
+tensorfeed.egg-info/SOURCES.txt
+tensorfeed.egg-info/dependency_links.txt
+tensorfeed.egg-info/requires.txt
+tensorfeed.egg-info/top_level.txt

tensorfeed-1.2.0/tensorfeed.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tensorfeed-1.2.0/tensorfeed.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[web3]
+web3>=6.0
+eth-account>=0.10

tensorfeed-1.2.0/tensorfeed.egg-info/top_level.txt

@@ -0,0 +1 @@
+tensorfeed