flopsindex-partner 0.2.0__tar.gz

flopsindex_partner-0.2.0/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: flopsindex-partner
+Version: 0.2.0
+Summary: Partner-tier write SDK for the FLOPS Compute Intelligence Platform — submit fleet / SMPI / CLRI data. Companion to the public-read SDK at https://pypi.org/project/flopsindex/.
+Author-email: Ash Chary <ash@flopsindex.com>
+License: Proprietary
+Project-URL: Homepage, https://flopsindex.com
+Project-URL: ReadSDK, https://pypi.org/project/flopsindex/
+Project-URL: MCPServer, https://pypi.org/project/flopsindex-mcp/
+Keywords: flops,compute,partner,submission,fleet,smpi,clri
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.26.0
+Provides-Extra: metrics
+Requires-Dist: prometheus-client>=0.20.0; extra == "metrics"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: respx>=0.21.0; extra == "dev"
+
+# flopsindex-partner — partner write SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/flopsindex-partner.svg)](https://pypi.org/project/flopsindex-partner/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/flopsindex-partner.svg)](https://pypi.org/project/flopsindex-partner/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/flopsindex-partner.svg)](https://pypi.org/project/flopsindex-partner/)
+
+```bash
+pip install flopsindex-partner
+```
+
+Authenticated **write-side** SDK for contributing partners (Modular, the
+lender-wave anchors, future fleet operators) submitting fleet / SMPI / CLRI
+data into the FLOPS Compute Intelligence Platform.
+
+For the **read-side** (price / verify / catalog / methodology / timeseries
+/ compute_margin / spread) install the companion package
+[`flopsindex`](https://pypi.org/project/flopsindex/) — different audience,
+different brand, no API key required for the public surface.
+
+## 30-second example
+
+```python
+from flopsindex_partner import FLOPSClient
+
+c = FLOPSClient(api_key="flops_xxxxxxxxx")
+
+# Weekly fleet snapshot
+c.submit_weekly({
+    "partner_id": "modular",
+    "as_of":      "2026-05-19T00:00:00Z",
+    "gpus":       [{"sku": "h100_sxm5", "region": "us_east", "count": 128}, ...],
+})
+
+# Single-machine pricing index event
+c.submit_smpi({
+    "partner_id": "modular",
+    "sku":        "h100_sxm5",
+    "region":     "us_east",
+    "price_usd":  2.42,
+    "tier":       "on_demand",
+    "ts":         "2026-05-19T22:00:00Z",
+})
+
+# CLRI lease-rate submission
+c.submit_clri({
+    "partner_id":      "modular",
+    "sku":             "h100_sxm5",
+    "tenor":           "P36M",
+    "implied_rate_pct": 11.4,
+    "as_of":           "2026-05-19T00:00:00Z",
+})
+```
+
+## Async surface
+
+Every method has an `a`-prefixed async sibling:
+
+```python
+import asyncio
+from flopsindex_partner import FLOPSClient
+
+async def main():
+    async with FLOPSClient(api_key="...") as c:
+        await c.asubmit_smpi({...})
+
+asyncio.run(main())
+```
+
+## Renamed from `flops-client` (2026-05-19)
+
+This package was previously published as `flops-client`. Old imports
+continue to work but emit `DeprecationWarning`:
+
+```python
+# OLD — deprecated, still works
+from flops_client import FLOPSClient
+
+# NEW — canonical
+from flopsindex_partner import FLOPSClient
+```
+
+The PyPI distribution name also changed (`flops-client` →
+`flopsindex-partner`). Update your `requirements.txt`:
+
+```diff
+- flops-client==0.1.0
++ flopsindex-partner>=0.2.0
+```
+
+The legacy `flops-client` distribution on PyPI will be marked deprecated
+in a follow-up release; it will continue to install but won't receive
+updates. The recommended deadline for migration is **2026-12-31**.
+
+## Authentication
+
+API keys are issued by FLOPS partner ops. Email `partners@flopsindex.com`
+to onboard. Once issued:
+
+```bash
+export FLOPS_API_KEY="flops_xxxxxxxxx"
+```
+
+```python
+import os
+from flopsindex_partner import FLOPSClient
+
+c = FLOPSClient(api_key=os.environ["FLOPS_API_KEY"])
+```
+
+## Submission contracts
+
+The schemas for `submit_weekly` / `submit_smpi` / `submit_clri` live in
+the Submission Guide (latest at
+`https://app.flopsindex.com/v1/methodology/submission-guide`).
+Each method returns the server's receipt envelope:
+
+```python
+result = c.submit_smpi({...})
+# {'receipt_id': '...', 'received_at': '...', 'methodology_version': '...',
+#  'k_anon_floor_met': True, 'inputs_hash': 'sha256:...'}
+```
+
+Hold onto `receipt_id` + `inputs_hash` — they're the audit trail.
+
+## Errors
+
+`FLOPSClientError` is raised on non-retryable 4xx + exhausted 5xx
+retries. The SDK retries 429/500/502/503/504 up to 3 times with
+exponential backoff before surfacing.
+
+```python
+from flopsindex_partner import FLOPSClient, FLOPSClientError
+
+try:
+    c.submit_smpi({...})
+except FLOPSClientError as e:
+    print(f"HTTP {e.status_code}: {e.detail}")
+```
+
+## Optional metrics
+
+If `prometheus-client` is installed (`pip install flopsindex-partner[metrics]`),
+the SDK emits:
+
+| Metric | Labels |
+|--------|--------|
+| `flops_sdk_submissions_total` | `endpoint`, `status` (`ok` / `error` / `exhausted`) |
+| `flops_sdk_request_seconds` | `endpoint` |
+
+Scrape via the standard Prometheus exporter.
+
+## Related
+
+- **Read SDK:** `pip install flopsindex` ([PyPI](https://pypi.org/project/flopsindex/))
+- **MCP server:** `pip install flopsindex-mcp` ([PyPI](https://pypi.org/project/flopsindex-mcp/))
+- **Schema (JSON-LD):** [`schema.flopsindex.com/compute-index-spec/v0.1/`](https://schema.flopsindex.com/compute-index-spec/v0.1/)
+- **Verify endpoint:** `GET /v1/verify?index_id=<ID>&value=<v>`
+- **Methodology library:** [`/v1/methodology`](https://app.flopsindex.com/v1/methodology)

flopsindex_partner-0.2.0/README.md

@@ -0,0 +1,158 @@
+# flopsindex-partner — partner write SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/flopsindex-partner.svg)](https://pypi.org/project/flopsindex-partner/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/flopsindex-partner.svg)](https://pypi.org/project/flopsindex-partner/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/flopsindex-partner.svg)](https://pypi.org/project/flopsindex-partner/)
+
+```bash
+pip install flopsindex-partner
+```
+
+Authenticated **write-side** SDK for contributing partners (Modular, the
+lender-wave anchors, future fleet operators) submitting fleet / SMPI / CLRI
+data into the FLOPS Compute Intelligence Platform.
+
+For the **read-side** (price / verify / catalog / methodology / timeseries
+/ compute_margin / spread) install the companion package
+[`flopsindex`](https://pypi.org/project/flopsindex/) — different audience,
+different brand, no API key required for the public surface.
+
+## 30-second example
+
+```python
+from flopsindex_partner import FLOPSClient
+
+c = FLOPSClient(api_key="flops_xxxxxxxxx")
+
+# Weekly fleet snapshot
+c.submit_weekly({
+    "partner_id": "modular",
+    "as_of":      "2026-05-19T00:00:00Z",
+    "gpus":       [{"sku": "h100_sxm5", "region": "us_east", "count": 128}, ...],
+})
+
+# Single-machine pricing index event
+c.submit_smpi({
+    "partner_id": "modular",
+    "sku":        "h100_sxm5",
+    "region":     "us_east",
+    "price_usd":  2.42,
+    "tier":       "on_demand",
+    "ts":         "2026-05-19T22:00:00Z",
+})
+
+# CLRI lease-rate submission
+c.submit_clri({
+    "partner_id":      "modular",
+    "sku":             "h100_sxm5",
+    "tenor":           "P36M",
+    "implied_rate_pct": 11.4,
+    "as_of":           "2026-05-19T00:00:00Z",
+})
+```
+
+## Async surface
+
+Every method has an `a`-prefixed async sibling:
+
+```python
+import asyncio
+from flopsindex_partner import FLOPSClient
+
+async def main():
+    async with FLOPSClient(api_key="...") as c:
+        await c.asubmit_smpi({...})
+
+asyncio.run(main())
+```
+
+## Renamed from `flops-client` (2026-05-19)
+
+This package was previously published as `flops-client`. Old imports
+continue to work but emit `DeprecationWarning`:
+
+```python
+# OLD — deprecated, still works
+from flops_client import FLOPSClient
+
+# NEW — canonical
+from flopsindex_partner import FLOPSClient
+```
+
+The PyPI distribution name also changed (`flops-client` →
+`flopsindex-partner`). Update your `requirements.txt`:
+
+```diff
+- flops-client==0.1.0
++ flopsindex-partner>=0.2.0
+```
+
+The legacy `flops-client` distribution on PyPI will be marked deprecated
+in a follow-up release; it will continue to install but won't receive
+updates. The recommended deadline for migration is **2026-12-31**.
+
+## Authentication
+
+API keys are issued by FLOPS partner ops. Email `partners@flopsindex.com`
+to onboard. Once issued:
+
+```bash
+export FLOPS_API_KEY="flops_xxxxxxxxx"
+```
+
+```python
+import os
+from flopsindex_partner import FLOPSClient
+
+c = FLOPSClient(api_key=os.environ["FLOPS_API_KEY"])
+```
+
+## Submission contracts
+
+The schemas for `submit_weekly` / `submit_smpi` / `submit_clri` live in
+the Submission Guide (latest at
+`https://app.flopsindex.com/v1/methodology/submission-guide`).
+Each method returns the server's receipt envelope:
+
+```python
+result = c.submit_smpi({...})
+# {'receipt_id': '...', 'received_at': '...', 'methodology_version': '...',
+#  'k_anon_floor_met': True, 'inputs_hash': 'sha256:...'}
+```
+
+Hold onto `receipt_id` + `inputs_hash` — they're the audit trail.
+
+## Errors
+
+`FLOPSClientError` is raised on non-retryable 4xx + exhausted 5xx
+retries. The SDK retries 429/500/502/503/504 up to 3 times with
+exponential backoff before surfacing.
+
+```python
+from flopsindex_partner import FLOPSClient, FLOPSClientError
+
+try:
+    c.submit_smpi({...})
+except FLOPSClientError as e:
+    print(f"HTTP {e.status_code}: {e.detail}")
+```
+
+## Optional metrics
+
+If `prometheus-client` is installed (`pip install flopsindex-partner[metrics]`),
+the SDK emits:
+
+| Metric | Labels |
+|--------|--------|
+| `flops_sdk_submissions_total` | `endpoint`, `status` (`ok` / `error` / `exhausted`) |
+| `flops_sdk_request_seconds` | `endpoint` |
+
+Scrape via the standard Prometheus exporter.
+
+## Related
+
+- **Read SDK:** `pip install flopsindex` ([PyPI](https://pypi.org/project/flopsindex/))
+- **MCP server:** `pip install flopsindex-mcp` ([PyPI](https://pypi.org/project/flopsindex-mcp/))
+- **Schema (JSON-LD):** [`schema.flopsindex.com/compute-index-spec/v0.1/`](https://schema.flopsindex.com/compute-index-spec/v0.1/)
+- **Verify endpoint:** `GET /v1/verify?index_id=<ID>&value=<v>`
+- **Methodology library:** [`/v1/methodology`](https://app.flopsindex.com/v1/methodology)

flopsindex_partner-0.2.0/flops_client/__init__.py

@@ -0,0 +1,21 @@
+"""DEPRECATED — renamed to ``flopsindex-partner`` 2026-05-19.
+
+Imports continue to work via this shim but emit DeprecationWarning. Move
+pinned imports to ``from flopsindex_partner import FLOPSClient`` for the
+long-term contract. The PyPI distribution name also changed
+(``flops-client`` → ``flopsindex-partner``); the legacy ``flops-client``
+package on PyPI will be marked deprecated in a follow-up release.
+"""
+import warnings as _warnings
+
+_warnings.warn(
+    "flops_client has been renamed to flopsindex_partner. "
+    "Use `from flopsindex_partner import FLOPSClient` instead. "
+    "The old import path will continue to work but is deprecated.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from flopsindex_partner import FLOPSClient, FLOPSClientError  # noqa: E402,F401
+
+__all__ = ["FLOPSClient", "FLOPSClientError"]

flopsindex_partner-0.2.0/flops_client/client.py

@@ -0,0 +1,24 @@
+"""DEPRECATED — see ``flopsindex_partner.client``.
+
+This module re-exports the canonical implementation so any caller pinned to
+``from flops_client.client import FLOPSClient`` (or
+``from sdk.flops_client.client import FLOPSClient``) keeps working. Single
+source of truth lives at ``flopsindex_partner/client.py``; this file is
+deliberately a thin shim to avoid drift between the two paths.
+"""
+import warnings as _warnings
+
+_warnings.warn(
+    "flops_client.client has been renamed to flopsindex_partner.client. "
+    "Use `from flopsindex_partner.client import FLOPSClient` instead. "
+    "The old import path will continue to work but is deprecated.",
+    DeprecationWarning,
+    stacklevel=2,
+)
+
+from flopsindex_partner.client import (  # noqa: E402,F401
+    FLOPSClient,
+    FLOPSClientError,
+)
+
+__all__ = ["FLOPSClient", "FLOPSClientError"]

flopsindex_partner-0.2.0/flopsindex_partner/__init__.py

@@ -0,0 +1,26 @@
+"""flopsindex-partner — partner-tier write SDK for the FLOPS Compute
+Intelligence Platform.
+
+```python
+from flopsindex_partner import FLOPSClient
+
+c = FLOPSClient(api_key="flops_xxx")
+c.submit_weekly({...})
+c.submit_smpi({...})
+c.submit_clri({...})
+```
+
+For the public read-side surface (price / verify / catalog / methodology /
+timeseries / spread / compute_margin) install the sibling ``flopsindex``
+package — different audience, different brand, same publisher.
+
+Renamed from ``flops-client`` 2026-05-19. The old import path
+``from flops_client import FLOPSClient`` continues to work via a
+deprecation shim — but emits ``DeprecationWarning``. Move pinned imports
+to ``flopsindex_partner`` for the long-term contract.
+"""
+
+from flopsindex_partner.client import FLOPSClient, FLOPSClientError
+
+__version__ = "0.2.0"
+__all__ = ["FLOPSClient", "FLOPSClientError", "__version__"]

flopsindex_partner-0.2.0/flopsindex_partner/client.py

@@ -0,0 +1,288 @@
+"""FLOPS partner submission SDK — write-side client.
+
+Canonical home for the partner-tier write surface. Use when ingesting
+fleet / SMPI / CLRI data into FLOPS as a contributing partner (Modular,
+and the wave that follows it). For the public read-side API see the
+sibling ``flopsindex`` package.
+
+Naming:
+  - PyPI package: ``flopsindex-partner``
+  - Python import: ``from flopsindex_partner import FLOPSClient``
+  - Legacy import (deprecated, kept for Modular's pinned imports):
+    ``from flops_client import FLOPSClient`` — emits DeprecationWarning
+"""
+
+from __future__ import annotations
+
+import logging
+import time
+from typing import Any, Optional
+
+import httpx
+
+logger = logging.getLogger(__name__)
+
+try:
+    from prometheus_client import Counter, Histogram
+
+    _prom_available = True
+except ImportError:
+    _prom_available = False
+
+_DEFAULT_BASE_URL = "https://api.flopsindex.com/v2"
+_DEFAULT_TIMEOUT = 30
+_MAX_RETRIES = 3
+_BACKOFF_BASE = 0.5
+_RETRYABLE_STATUS_CODES = {429, 500, 502, 503, 504}
+_USER_AGENT = "flopsindex-partner/0.2.0"
+
+
+def _init_metrics() -> tuple:
+    """Register Prometheus collectors idempotently.
+
+    Counter/Histogram raise ValueError on re-registration with the same name,
+    which crashes any caller that reloads this module (live-reload servers,
+    test suites that purge sys.modules). The double-registration only
+    happens when the registry already has the collectors — at which point
+    we can safely return (None, None); the original module instance still
+    owns the live counters and the reloaded copy doesn't need to re-emit.
+    """
+    if not _prom_available:
+        return None, None
+    try:
+        submissions = Counter(
+            "flops_sdk_submissions_total",
+            "Total SDK submissions",
+            ["endpoint", "status"],
+        )
+        latency = Histogram(
+            "flops_sdk_request_seconds",
+            "SDK request latency",
+            ["endpoint"],
+        )
+        return submissions, latency
+    except ValueError:
+        # Already registered — module is being reloaded.
+        return None, None
+
+
+_submissions_counter, _latency_histogram = _init_metrics()
+
+
+class FLOPSClientError(Exception):
+    def __init__(self, status_code: int, detail: Any):
+        self.status_code = status_code
+        self.detail = detail
+        super().__init__(f"HTTP {status_code}: {detail}")
+
+
+class FLOPSClient:
+    """Synchronous + async write-side client for partner submissions."""
+
+    def __init__(
+        self,
+        api_key: str,
+        base_url: str = _DEFAULT_BASE_URL,
+        timeout: int = _DEFAULT_TIMEOUT,
+    ):
+        self._api_key = api_key
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._client: Optional[httpx.Client] = None
+        self._async_client: Optional[httpx.AsyncClient] = None
+
+    def _get_headers(self) -> dict[str, str]:
+        return {
+            "X-API-Key": self._api_key,
+            "Content-Type": "application/json",
+            "User-Agent": _USER_AGENT,
+        }
+
+    def _ensure_sync_client(self) -> httpx.Client:
+        if self._client is None:
+            self._client = httpx.Client(
+                base_url=self._base_url,
+                headers=self._get_headers(),
+                timeout=self._timeout,
+            )
+        return self._client
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Optional[dict] = None,
+        params: Optional[dict] = None,
+    ) -> dict:
+        client = self._ensure_sync_client()
+        last_exc: Optional[Exception] = None
+
+        for attempt in range(_MAX_RETRIES):
+            start = time.monotonic()
+            try:
+                response = client.request(method, path, json=json, params=params)
+                elapsed = time.monotonic() - start
+
+                if _latency_histogram:
+                    _latency_histogram.labels(endpoint=path).observe(elapsed)
+
+                if response.status_code < 400:
+                    if _submissions_counter and method == "POST":
+                        _submissions_counter.labels(endpoint=path, status="ok").inc()
+                    return response.json()
+
+                if response.status_code not in _RETRYABLE_STATUS_CODES:
+                    if _submissions_counter and method == "POST":
+                        _submissions_counter.labels(endpoint=path, status="error").inc()
+                    raise FLOPSClientError(response.status_code, response.text)
+
+                last_exc = FLOPSClientError(response.status_code, response.text)
+
+            except httpx.TransportError as exc:
+                last_exc = exc
+
+            backoff = _BACKOFF_BASE * (2 ** attempt)
+            logger.warning("Retry %d/%d for %s %s (backoff %.1fs)",
+                            attempt + 1, _MAX_RETRIES, method, path, backoff)
+            time.sleep(backoff)
+
+        if _submissions_counter and method == "POST":
+            _submissions_counter.labels(endpoint=path, status="exhausted").inc()
+        raise last_exc  # type: ignore[misc]
+
+    def submit_weekly(self, submission: dict) -> dict:
+        return self._request("POST", "/submit/fleet", json=submission)
+
+    def submit_smpi(self, transaction: dict) -> dict:
+        return self._request("POST", "/submit/smpi", json=transaction)
+
+    def submit_clri(self, submission: dict) -> dict:
+        return self._request("POST", "/submit/clri", json=submission)
+
+    def get_index(
+        self,
+        index_id: str,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+    ) -> dict:
+        params: dict[str, str] = {}
+        if start:
+            params["start"] = start
+        if end:
+            params["end"] = end
+        return self._request("GET", f"/indices/{index_id}", params=params)
+
+    def get_health(self) -> dict:
+        return self._request("GET", "/health")
+
+    def close(self) -> None:
+        if self._client:
+            self._client.close()
+            self._client = None
+        if self._async_client:
+            pass  # must be closed with aclose()
+
+    def __enter__(self) -> "FLOPSClient":
+        self._ensure_sync_client()
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+    # --- async interface ---
+
+    def _ensure_async_client(self) -> httpx.AsyncClient:
+        if self._async_client is None:
+            self._async_client = httpx.AsyncClient(
+                base_url=self._base_url,
+                headers=self._get_headers(),
+                timeout=self._timeout,
+            )
+        return self._async_client
+
+    async def _arequest(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Optional[dict] = None,
+        params: Optional[dict] = None,
+    ) -> dict:
+        import asyncio
+
+        client = self._ensure_async_client()
+        last_exc: Optional[Exception] = None
+
+        for attempt in range(_MAX_RETRIES):
+            start = time.monotonic()
+            try:
+                response = await client.request(method, path, json=json, params=params)
+                elapsed = time.monotonic() - start
+
+                if _latency_histogram:
+                    _latency_histogram.labels(endpoint=path).observe(elapsed)
+
+                if response.status_code < 400:
+                    if _submissions_counter and method == "POST":
+                        _submissions_counter.labels(endpoint=path, status="ok").inc()
+                    return response.json()
+
+                if response.status_code not in _RETRYABLE_STATUS_CODES:
+                    if _submissions_counter and method == "POST":
+                        _submissions_counter.labels(endpoint=path, status="error").inc()
+                    raise FLOPSClientError(response.status_code, response.text)
+
+                last_exc = FLOPSClientError(response.status_code, response.text)
+
+            except httpx.TransportError as exc:
+                last_exc = exc
+
+            backoff = _BACKOFF_BASE * (2 ** attempt)
+            logger.warning("Retry %d/%d for %s %s (backoff %.1fs)",
+                            attempt + 1, _MAX_RETRIES, method, path, backoff)
+            await asyncio.sleep(backoff)
+
+        if _submissions_counter and method == "POST":
+            _submissions_counter.labels(endpoint=path, status="exhausted").inc()
+        raise last_exc  # type: ignore[misc]
+
+    async def asubmit_weekly(self, submission: dict) -> dict:
+        return await self._arequest("POST", "/submit/fleet", json=submission)
+
+    async def asubmit_smpi(self, transaction: dict) -> dict:
+        return await self._arequest("POST", "/submit/smpi", json=transaction)
+
+    async def asubmit_clri(self, submission: dict) -> dict:
+        return await self._arequest("POST", "/submit/clri", json=submission)
+
+    async def aget_index(
+        self,
+        index_id: str,
+        start: Optional[str] = None,
+        end: Optional[str] = None,
+    ) -> dict:
+        params: dict[str, str] = {}
+        if start:
+            params["start"] = start
+        if end:
+            params["end"] = end
+        return await self._arequest("GET", f"/indices/{index_id}", params=params)
+
+    async def aget_health(self) -> dict:
+        return await self._arequest("GET", "/health")
+
+    async def aclose(self) -> None:
+        if self._async_client:
+            await self._async_client.aclose()
+            self._async_client = None
+
+    async def __aenter__(self) -> "FLOPSClient":
+        self._ensure_async_client()
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.aclose()
+
+
+__all__ = ["FLOPSClient", "FLOPSClientError"]

flopsindex_partner-0.2.0/flopsindex_partner/tests/test_deprecation.py

@@ -0,0 +1,136 @@
+"""Deprecation-shim tests.
+
+Pins two halves of the rebrand contract:
+
+  1. `import flops_client` (the legacy distribution name) MUST emit a
+     DeprecationWarning at import time so partners discover the rename
+     when they re-pip from a clean environment.
+  2. The shim MUST still re-export every write method (submit_weekly,
+     submit_smpi, submit_clri) so Modular's already-deployed integration
+     keeps working through the deprecation window. Silently breaking
+     the WRITE surface is the failure mode this test exists to catch.
+
+Tests use importlib.reload + warnings.catch_warnings so the warning
+fires inside the test scope even if another test imported the modules
+earlier in the session.
+"""
+from __future__ import annotations
+
+import importlib
+import sys
+import warnings
+from pathlib import Path
+
+import pytest
+
+# Make the sibling packages importable without `pip install -e .`
+_SDK_ROOT = Path(__file__).resolve().parents[2]
+if str(_SDK_ROOT) not in sys.path:
+    sys.path.insert(0, str(_SDK_ROOT))
+
+
+def _purge(*module_prefixes: str) -> None:
+    """Drop cached modules so the next import re-fires the warning."""
+    for key in list(sys.modules):
+        for prefix in module_prefixes:
+            if key == prefix or key.startswith(prefix + "."):
+                del sys.modules[key]
+                break
+
+
+def test_flops_client_import_emits_deprecation_warning():
+    """`from flops_client import FLOPSClient` must warn."""
+    _purge("flops_client", "flopsindex_partner")
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        import flops_client  # noqa: F401
+    deprecation_warnings = [w for w in caught
+                            if issubclass(w.category, DeprecationWarning)
+                            and "flops_client" in str(w.message)]
+    assert deprecation_warnings, (
+        "Importing flops_client must emit a DeprecationWarning pointing at "
+        "flopsindex_partner; none found."
+    )
+
+
+def test_flops_client_client_module_import_emits_warning():
+    """`from flops_client.client import FLOPSClient` must also warn —
+    Modular may have pinned the deeper import path."""
+    _purge("flops_client", "flopsindex_partner")
+    with warnings.catch_warnings(record=True) as caught:
+        warnings.simplefilter("always")
+        import flops_client.client  # noqa: F401
+    deprecation_warnings = [w for w in caught
+                            if issubclass(w.category, DeprecationWarning)]
+    assert deprecation_warnings, (
+        "Importing flops_client.client must emit a DeprecationWarning; "
+        "none found."
+    )
+
+
+def test_shim_reexports_FLOPSClient_with_write_methods():
+    """The shim MUST re-export FLOPSClient with submit_weekly /
+    submit_smpi / submit_clri intact. Silently breaking the WRITE
+    surface is the failure mode this test pins."""
+    _purge("flops_client", "flopsindex_partner")
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        from flops_client import FLOPSClient  # noqa
+    # Class-level method discovery — no network call.
+    for method_name in ("submit_weekly", "submit_smpi", "submit_clri",
+                         "asubmit_weekly", "asubmit_smpi", "asubmit_clri",
+                         "get_index", "aget_index",
+                         "get_health", "aget_health"):
+        assert hasattr(FLOPSClient, method_name), (
+            f"FLOPSClient lost {method_name}() during rebrand — the shim "
+            "did not re-export the full write surface."
+        )
+
+
+def test_shim_FLOPSClient_is_canonical_class():
+    """The class re-exported through the shim MUST be the same identity
+    as the canonical class — no shadow class that drifts."""
+    _purge("flops_client", "flopsindex_partner")
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        from flops_client import FLOPSClient as ShimClass
+        from flopsindex_partner import FLOPSClient as CanonClass
+    assert ShimClass is CanonClass, (
+        "flops_client.FLOPSClient and flopsindex_partner.FLOPSClient must "
+        "be the SAME class object. If they diverge, partners pinning the "
+        "old import path will silently miss new methods + fixes."
+    )
+
+
+def test_canonical_user_agent_rebranded():
+    """The User-Agent string must reflect the rebrand so traffic auditing
+    can distinguish v0.2.0+ callers from legacy flops-client 0.1.0."""
+    _purge("flops_client", "flopsindex_partner")
+    from flopsindex_partner.client import _USER_AGENT
+    assert _USER_AGENT.startswith("flopsindex-partner/"), (
+        f"USER_AGENT not rebranded: {_USER_AGENT!r}"
+    )
+    assert "0.2" in _USER_AGENT  # tolerates patch bumps
+
+
+def test_version_pinned_to_0_2():
+    _purge("flopsindex_partner")
+    import flopsindex_partner
+    importlib.reload(flopsindex_partner)
+    assert flopsindex_partner.__version__.startswith("0.2"), (
+        f"flopsindex_partner.__version__ should start with 0.2, got "
+        f"{flopsindex_partner.__version__!r}"
+    )
+
+
+def test_flops_client_exports_FLOPSClientError():
+    """FLOPSClientError MUST be re-exported through both shim levels —
+    partners catch this exception by name."""
+    _purge("flops_client", "flopsindex_partner")
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore", DeprecationWarning)
+        from flops_client import FLOPSClientError as ShimErr
+        from flops_client.client import FLOPSClientError as DeepShimErr
+        from flopsindex_partner import FLOPSClientError as CanonErr
+    assert ShimErr is CanonErr
+    assert DeepShimErr is CanonErr

flopsindex_partner-0.2.0/flopsindex_partner.egg-info/PKG-INFO

@@ -0,0 +1,178 @@
+Metadata-Version: 2.4
+Name: flopsindex-partner
+Version: 0.2.0
+Summary: Partner-tier write SDK for the FLOPS Compute Intelligence Platform — submit fleet / SMPI / CLRI data. Companion to the public-read SDK at https://pypi.org/project/flopsindex/.
+Author-email: Ash Chary <ash@flopsindex.com>
+License: Proprietary
+Project-URL: Homepage, https://flopsindex.com
+Project-URL: ReadSDK, https://pypi.org/project/flopsindex/
+Project-URL: MCPServer, https://pypi.org/project/flopsindex-mcp/
+Keywords: flops,compute,partner,submission,fleet,smpi,clri
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.26.0
+Provides-Extra: metrics
+Requires-Dist: prometheus-client>=0.20.0; extra == "metrics"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: respx>=0.21.0; extra == "dev"
+
+# flopsindex-partner — partner write SDK
+
+[![PyPI version](https://img.shields.io/pypi/v/flopsindex-partner.svg)](https://pypi.org/project/flopsindex-partner/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/flopsindex-partner.svg)](https://pypi.org/project/flopsindex-partner/)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/flopsindex-partner.svg)](https://pypi.org/project/flopsindex-partner/)
+
+```bash
+pip install flopsindex-partner
+```
+
+Authenticated **write-side** SDK for contributing partners (Modular, the
+lender-wave anchors, future fleet operators) submitting fleet / SMPI / CLRI
+data into the FLOPS Compute Intelligence Platform.
+
+For the **read-side** (price / verify / catalog / methodology / timeseries
+/ compute_margin / spread) install the companion package
+[`flopsindex`](https://pypi.org/project/flopsindex/) — different audience,
+different brand, no API key required for the public surface.
+
+## 30-second example
+
+```python
+from flopsindex_partner import FLOPSClient
+
+c = FLOPSClient(api_key="flops_xxxxxxxxx")
+
+# Weekly fleet snapshot
+c.submit_weekly({
+    "partner_id": "modular",
+    "as_of":      "2026-05-19T00:00:00Z",
+    "gpus":       [{"sku": "h100_sxm5", "region": "us_east", "count": 128}, ...],
+})
+
+# Single-machine pricing index event
+c.submit_smpi({
+    "partner_id": "modular",
+    "sku":        "h100_sxm5",
+    "region":     "us_east",
+    "price_usd":  2.42,
+    "tier":       "on_demand",
+    "ts":         "2026-05-19T22:00:00Z",
+})
+
+# CLRI lease-rate submission
+c.submit_clri({
+    "partner_id":      "modular",
+    "sku":             "h100_sxm5",
+    "tenor":           "P36M",
+    "implied_rate_pct": 11.4,
+    "as_of":           "2026-05-19T00:00:00Z",
+})
+```
+
+## Async surface
+
+Every method has an `a`-prefixed async sibling:
+
+```python
+import asyncio
+from flopsindex_partner import FLOPSClient
+
+async def main():
+    async with FLOPSClient(api_key="...") as c:
+        await c.asubmit_smpi({...})
+
+asyncio.run(main())
+```
+
+## Renamed from `flops-client` (2026-05-19)
+
+This package was previously published as `flops-client`. Old imports
+continue to work but emit `DeprecationWarning`:
+
+```python
+# OLD — deprecated, still works
+from flops_client import FLOPSClient
+
+# NEW — canonical
+from flopsindex_partner import FLOPSClient
+```
+
+The PyPI distribution name also changed (`flops-client` →
+`flopsindex-partner`). Update your `requirements.txt`:
+
+```diff
+- flops-client==0.1.0
++ flopsindex-partner>=0.2.0
+```
+
+The legacy `flops-client` distribution on PyPI will be marked deprecated
+in a follow-up release; it will continue to install but won't receive
+updates. The recommended deadline for migration is **2026-12-31**.
+
+## Authentication
+
+API keys are issued by FLOPS partner ops. Email `partners@flopsindex.com`
+to onboard. Once issued:
+
+```bash
+export FLOPS_API_KEY="flops_xxxxxxxxx"
+```
+
+```python
+import os
+from flopsindex_partner import FLOPSClient
+
+c = FLOPSClient(api_key=os.environ["FLOPS_API_KEY"])
+```
+
+## Submission contracts
+
+The schemas for `submit_weekly` / `submit_smpi` / `submit_clri` live in
+the Submission Guide (latest at
+`https://app.flopsindex.com/v1/methodology/submission-guide`).
+Each method returns the server's receipt envelope:
+
+```python
+result = c.submit_smpi({...})
+# {'receipt_id': '...', 'received_at': '...', 'methodology_version': '...',
+#  'k_anon_floor_met': True, 'inputs_hash': 'sha256:...'}
+```
+
+Hold onto `receipt_id` + `inputs_hash` — they're the audit trail.
+
+## Errors
+
+`FLOPSClientError` is raised on non-retryable 4xx + exhausted 5xx
+retries. The SDK retries 429/500/502/503/504 up to 3 times with
+exponential backoff before surfacing.
+
+```python
+from flopsindex_partner import FLOPSClient, FLOPSClientError
+
+try:
+    c.submit_smpi({...})
+except FLOPSClientError as e:
+    print(f"HTTP {e.status_code}: {e.detail}")
+```
+
+## Optional metrics
+
+If `prometheus-client` is installed (`pip install flopsindex-partner[metrics]`),
+the SDK emits:
+
+| Metric | Labels |
+|--------|--------|
+| `flops_sdk_submissions_total` | `endpoint`, `status` (`ok` / `error` / `exhausted`) |
+| `flops_sdk_request_seconds` | `endpoint` |
+
+Scrape via the standard Prometheus exporter.
+
+## Related
+
+- **Read SDK:** `pip install flopsindex` ([PyPI](https://pypi.org/project/flopsindex/))
+- **MCP server:** `pip install flopsindex-mcp` ([PyPI](https://pypi.org/project/flopsindex-mcp/))
+- **Schema (JSON-LD):** [`schema.flopsindex.com/compute-index-spec/v0.1/`](https://schema.flopsindex.com/compute-index-spec/v0.1/)
+- **Verify endpoint:** `GET /v1/verify?index_id=<ID>&value=<v>`
+- **Methodology library:** [`/v1/methodology`](https://app.flopsindex.com/v1/methodology)

flopsindex_partner-0.2.0/flopsindex_partner.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+flops_client/__init__.py
+flops_client/client.py
+flopsindex_partner/__init__.py
+flopsindex_partner/client.py
+flopsindex_partner.egg-info/PKG-INFO
+flopsindex_partner.egg-info/SOURCES.txt
+flopsindex_partner.egg-info/dependency_links.txt
+flopsindex_partner.egg-info/requires.txt
+flopsindex_partner.egg-info/top_level.txt
+flopsindex_partner/tests/test_deprecation.py

flopsindex_partner-0.2.0/flopsindex_partner.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

flopsindex_partner-0.2.0/flopsindex_partner.egg-info/requires.txt

@@ -0,0 +1,9 @@
+httpx>=0.26.0
+
+[dev]
+pytest>=8.0.0
+pytest-asyncio>=0.23.0
+respx>=0.21.0
+
+[metrics]
+prometheus-client>=0.20.0

flopsindex_partner-0.2.0/flopsindex_partner.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+flops_client
+flopsindex_partner

flopsindex_partner-0.2.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flopsindex-partner"
+version = "0.2.0"
+description = "Partner-tier write SDK for the FLOPS Compute Intelligence Platform — submit fleet / SMPI / CLRI data. Companion to the public-read SDK at https://pypi.org/project/flopsindex/."
+readme = "README.md"
+requires-python = ">=3.11"
+license = {text = "Proprietary"}
+authors = [{name = "Ash Chary", email = "ash@flopsindex.com"}]
+keywords = ["flops", "compute", "partner", "submission", "fleet", "smpi", "clri"]
+
+dependencies = [
+    "httpx>=0.26.0",
+]
+
+[project.optional-dependencies]
+metrics = [
+    "prometheus-client>=0.20.0",
+]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.23.0",
+    "respx>=0.21.0",
+]
+
+[project.urls]
+Homepage  = "https://flopsindex.com"
+ReadSDK   = "https://pypi.org/project/flopsindex/"
+MCPServer = "https://pypi.org/project/flopsindex-mcp/"
+
+[tool.setuptools.packages.find]
+where = ["."]
+# Ship BOTH packages so legacy `from flops_client import ...` keeps working
+# via the deprecation shim alongside the canonical `flopsindex_partner`.
+include = ["flopsindex_partner*", "flops_client*"]

flopsindex_partner-0.2.0/setup.cfg

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