tensorfeed 2.2.1__tar.gz → 3.0.0__tar.gz

{tensorfeed-2.2.1 → tensorfeed-3.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfeed
-Version: 2.2.1
+Version: 3.0.0
 Summary: Python SDK for the TensorFeed.ai API: AI news, status, model pricing, premium routing + history series + webhook watches, LangChain/CrewAI tool factories, agent payments via USDC on Base (optional web3 auto-send)
 Author-email: "TensorFeed.ai" <feedback@tensorfeed.ai>
 License-Expression: MIT

{tensorfeed-2.2.1 → tensorfeed-3.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tensorfeed"
-version = "2.2.1"
+version = "3.0.0"
 description = "Python SDK for the TensorFeed.ai API: AI news, status, model pricing, premium routing + history series + webhook watches, LangChain/CrewAI tool factories, agent payments via USDC on Base (optional web3 auto-send)"
 readme = "README.md"
 license = "MIT"

{tensorfeed-2.2.1 → tensorfeed-3.0.0}/tensorfeed/__init__.py

@@ -21,4 +21,4 @@ __all__ = [
     "PaymentRequired",
     "RateLimited",
 ]
-__version__ = "2.2.0"
+__version__ = "3.0.0"

{tensorfeed-2.2.1 → tensorfeed-3.0.0}/tensorfeed/client.py

@@ -18,7 +18,7 @@ from typing import Any  # noqa: F401  (re-exported by purchase_credits return ty
 
 
 DEFAULT_BASE_URL = "https://tensorfeed.ai/api"
-DEFAULT_USER_AGENT = "TensorFeed-SDK-Python/2.2"
+DEFAULT_USER_AGENT = "TensorFeed-SDK-Python/3.0"
 
 
 class TensorFeedError(Exception):
@@ -105,10 +105,18 @@ class TensorFeed:
         # 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).
+        # Paths handed to _request are RELATIVE: base_url already ends in /api,
+        # and url is built as f"{base_url}{path}". The old fallback tested for
+        # "/api/premium/" and "/api/payment/balance" in that relative path, so
+        # neither could ever match and the whole fallback was dead code. Every
+        # premium method happened to pass require_token=True explicitly, except
+        # attention_series, which therefore called a paid endpoint with no
+        # Authorization header at all and 402'd for customers holding credits.
+        # Matching the relative form makes the safety net real.
         needs_auth = (
             require_token
-            or "/api/premium/" in path
-            or path == "/api/payment/balance"
+            or path.startswith("/premium/")
+            or path == "/payment/balance"
         )
         if needs_auth and self.token:
             headers["Authorization"] = f"Bearer {self.token}"
@@ -380,7 +388,9 @@ class TensorFeed:
             kwargs["from"] = from_date
         if to_date is not None:
             kwargs["to"] = to_date
-        return self._get("/premium/attention/series", **kwargs)
+        return self._request(
+            "GET", "/premium/attention/series", params=kwargs, require_token=True
+        )
 
     def agent_activity(self) -> dict[str, Any]:
         """Get agent traffic metrics. Free."""
@@ -510,7 +520,7 @@ class TensorFeed:
 
         For windows up to 90 days plus ``incident_count`` and
         ``mttr_minutes`` per provider, use ``status_leaderboard()``
-        (premium, 1 credit).
+        (premium, 5 credits).
 
         Args:
             days: 1 to 7 (default 7).
@@ -1338,8 +1348,8 @@ class TensorFeed:
 
         Free, no auth. Single edge-cached endpoint that fans out across
         every daily TensorFeed feed (news, 3 paper feeds, HF
-        models/datasets/Spaces, hot GitHub issues, Reddit threads,
-        OpenRouter catalog summary, provider status) and returns a
+        models/datasets/Spaces, hot GitHub issues, OpenRouter catalog
+        summary, provider status) and returns a
         structured response. Saves an agent from orchestrating 9
         separate calls.
 
@@ -1455,31 +1465,6 @@ class TensorFeed:
         """
         return self._request("GET", "/openrouter/models")
 
-    def get_reddit_trending(self) -> dict[str, Any]:
-        """Currently-hot Reddit threads in 7 AI-relevant subreddits.
-
-        Free, no auth. Subreddits queried: LocalLLaMA, MachineLearning,
-        ClaudeAI, OpenAI, singularity, artificial, AI_Agents. Pulls each
-        subreddit's "hot" listing, dedups by post id, drops stickied and
-        NSFW posts, ranks by score, top 30. Refreshed daily at 13:00 UTC.
-        Companion to ``get_hot_issues()``: that surfaces developer-side
-        conversation on GitHub, this surfaces community-side conversation
-        on Reddit.
-
-        Titles pass through TensorFeed's prompt-injection sanitization at
-        capture time, so role-confusion tokens and bidi/zero-width
-        spoofing characters in Reddit posts cannot reach an agent.
-
-        Returns:
-            Dict with ``ok`` and ``snapshot`` keys. Snapshot includes
-            ``date``, ``capturedAt``, ``total_posts``, ``subreddits_queried``,
-            ``posts`` (each with id, subreddit, title, author, score,
-            upvote_ratio, num_comments, permalink, url, created_utc,
-            flair, is_self, is_video), and ``summary`` (by_subreddit,
-            top_authors).
-        """
-        return self._request("GET", "/reddit/trending")
-
     def get_hot_issues(self) -> dict[str, Any]:
         """Currently-hot GitHub issues across the AI ecosystem.
 

{tensorfeed-2.2.1 → tensorfeed-3.0.0}/tensorfeed.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensorfeed
-Version: 2.2.1
+Version: 3.0.0
 Summary: Python SDK for the TensorFeed.ai API: AI news, status, model pricing, premium routing + history series + webhook watches, LangChain/CrewAI tool factories, agent payments via USDC on Base (optional web3 auto-send)
 Author-email: "TensorFeed.ai" <feedback@tensorfeed.ai>
 License-Expression: MIT

{tensorfeed-2.2.1 → tensorfeed-3.0.0}/tensorfeed.egg-info/SOURCES.txt

@@ -12,5 +12,6 @@ tensorfeed.egg-info/SOURCES.txt
 tensorfeed.egg-info/dependency_links.txt
 tensorfeed.egg-info/requires.txt
 tensorfeed.egg-info/top_level.txt
+tests/test_premium_auth_header.py
 tests/test_premium_tools.py
 tests/test_route_verdict.py

tensorfeed-3.0.0/tests/test_premium_auth_header.py

@@ -0,0 +1,148 @@
+"""Every premium method must send the Authorization header.
+
+A customer buys credits, calls a documented premium method, and gets a 402
+because the SDK never attached their token. That shipped in 2.2.1:
+``attention_series`` was the only premium method of twenty that omitted
+``require_token=True``, and the fallback meant to catch exactly that mistake
+was dead code.
+
+The fallback tested ``"/api/premium/" in path``. Paths handed to ``_request``
+are relative, because ``base_url`` already ends in ``/api`` and the URL is
+built as ``f"{base_url}{path}"``. So the substring could never match and the
+safety net never fired for anything.
+
+Two guards here, because either one alone is escapable:
+
+1. Behavioral. Drive every premium method through a stub transport and assert
+   the header is actually present on the wire. Catches a missing flag no
+   matter how the method is written.
+2. Static. Assert the fallback still matches the relative path form, so the
+   net cannot silently go dead again while every method happens to pass the
+   flag explicitly.
+
+Network-free. Run from sdk/python::
+
+    python -m unittest discover -s tests -t .
+"""
+
+from __future__ import annotations
+
+import inspect
+import json
+import unittest
+from unittest import mock
+
+from tensorfeed import TensorFeed
+from tensorfeed import client as client_mod
+
+TOKEN = "tf_live_testtoken0000000000"
+
+
+class _StubResponse:
+    """Minimal stand-in for the urlopen context manager."""
+
+    status = 200
+    headers: dict[str, str] = {}
+
+    def read(self) -> bytes:
+        return json.dumps({"ok": True}).encode()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        return False
+
+
+def _premium_methods():
+    """Public methods whose source calls a /premium/ path."""
+    for name, fn in inspect.getmembers(TensorFeed, predicate=inspect.isfunction):
+        if name.startswith("_"):
+            continue
+        try:
+            src = inspect.getsource(fn)
+        except OSError:  # pragma: no cover
+            continue
+        if '"/premium/' in src or "'/premium/" in src:
+            yield name, fn
+
+
+class PremiumMethodsSendTheToken(unittest.TestCase):
+    def test_at_least_a_dozen_premium_methods_are_discovered(self):
+        found = list(_premium_methods())
+        self.assertGreater(
+            len(found), 12, f"expected to discover many premium methods, got {len(found)}"
+        )
+
+    def test_every_premium_method_attaches_authorization(self):
+        tf = TensorFeed(token=TOKEN)
+        offenders: list[str] = []
+
+        for name, fn in _premium_methods():
+            sig = inspect.signature(fn)
+            # Supply a placeholder for every required positional parameter so the
+            # method reaches the transport. Values are irrelevant: the stub
+            # answers everything with 200 and we only inspect the request.
+            args: list[object] = []
+            kwargs: dict[str, object] = {}
+            for pname, p in list(sig.parameters.items())[1:]:
+                if p.default is not inspect.Parameter.empty:
+                    continue
+                if p.kind in (p.VAR_POSITIONAL, p.VAR_KEYWORD):
+                    continue
+                # Numeric-sounding params need a number; everything else takes a
+                # plausible string. The value never reaches a real service.
+                filler: object = 1000 if "tokens" in pname or pname.endswith("_per_day") else "anthropic"
+                if p.kind is p.KEYWORD_ONLY:
+                    kwargs[pname] = filler
+                else:
+                    args.append(filler)
+
+            captured: dict[str, object] = {}
+
+            def _fake_urlopen(req, *a, **kw):
+                captured["headers"] = {k.lower(): v for k, v in req.headers.items()}
+                captured["url"] = req.full_url
+                return _StubResponse()
+
+            with mock.patch.object(client_mod.urllib.request, "urlopen", _fake_urlopen):
+                try:
+                    getattr(tf, name)(*args, **kwargs)
+                except Exception as exc:  # noqa: BLE001
+                    offenders.append(f"{name}: raised before transport ({exc!r})")
+                    continue
+
+            headers = captured.get("headers") or {}
+            if headers.get("authorization") != f"Bearer {TOKEN}":
+                offenders.append(
+                    f"{name}: no Authorization header on {captured.get('url')}"
+                )
+
+        self.assertEqual(
+            offenders,
+            [],
+            "These premium methods call a paid endpoint without the customer's token, so a "
+            "customer holding credits gets a 402 instead of data:\n  " + "\n  ".join(offenders),
+        )
+
+
+class TheAuthFallbackIsNotDeadCode(unittest.TestCase):
+    def test_fallback_matches_the_relative_path_form(self):
+        src = inspect.getsource(client_mod.TensorFeed._request)
+        self.assertIn(
+            'path.startswith("/premium/")',
+            src,
+            "The premium auth fallback must match the RELATIVE path form. base_url already "
+            "ends in /api, so a check for '/api/premium/' in path can never be true and the "
+            "safety net is dead code.",
+        )
+        self.assertNotIn(
+            '"/api/premium/" in path',
+            src,
+            "This is the dead check that let attention_series ship without a token.",
+        )
+
+    def test_base_url_still_ends_in_api(self):
+        # The premise of the test above. If this ever changes, the relative-path
+        # assumption changes with it.
+        self.assertTrue(client_mod.DEFAULT_BASE_URL.endswith("/api"))