mcp-data-core 0.1.0__tar.gz

mcp_data_core-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,120 @@
+name: Publish to PyPI
+
+# Tag-triggered release pipeline. Tagging `vX.Y.Z` on main builds the wheel
+# + sdist, verifies the tag matches the pyproject version, runs the test
+# suite one more time, and publishes to PyPI via OIDC trusted publishing
+# (no long-lived API token stored anywhere).
+#
+# To ship a new release:
+#   1. Bump `version` in pyproject.toml on main.
+#   2. `git tag v0.2.0 && git push origin v0.2.0` (version must match).
+#   3. Watch this workflow run.
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+permissions:
+  contents: read
+
+jobs:
+  verify:
+    name: Verify tag matches pyproject version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Extract versions and compare
+        id: version
+        run: |
+          TAG="${GITHUB_REF_NAME#v}"
+          PY_VERSION=$(grep -E '^version\s*=' pyproject.toml | sed -E 's/.*"([^"]+)".*/\1/' | head -n1)
+          echo "Tag version:       $TAG"
+          echo "pyproject version: $PY_VERSION"
+          if [ "$TAG" != "$PY_VERSION" ]; then
+            echo "::error::Tag $GITHUB_REF_NAME (parsed version $TAG) does not match pyproject version $PY_VERSION. Bump pyproject first, commit, then retag."
+            exit 1
+          fi
+          echo "version=$PY_VERSION" >> "$GITHUB_OUTPUT"
+
+  test:
+    name: Test on Python ${{ matrix.python-version }}
+    needs: verify
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.11", "3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies (library + MCP extra + dev group)
+        run: uv sync --all-extras --group dev
+
+      - name: Run test suite
+        run: uv run pytest -q
+
+  build:
+    name: Build wheel + sdist
+    needs: test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Set up Python
+        run: uv python install 3.11
+
+      - name: Build distributions
+        run: uv build
+
+      - name: List artifacts
+        run: ls -la dist/
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+          retention-days: 7
+
+  publish:
+    name: Publish ${{ needs.verify.outputs.version }} to PyPI
+    needs: [verify, build]
+    runs-on: ubuntu-latest
+    # The `pypi` environment matches the one configured on PyPI's trusted-
+    # publisher page. GitHub enforces any protection rules on it (approval,
+    # required reviewers, etc.) before this job runs.
+    environment:
+      name: pypi
+      url: https://pypi.org/project/mcp-data-core/${{ needs.verify.outputs.version }}/
+    permissions:
+      # Required for OIDC trusted publishing. No PyPI token needed.
+      id-token: write
+    steps:
+      - name: Download built distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          # Skip re-publishing if the version already exists (makes the
+          # workflow idempotent for retries).
+          skip-existing: true

mcp_data_core-0.1.0/.gitignore

@@ -0,0 +1,43 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+dist/
+*.egg-info/
+*.egg
+.eggs/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+coverage.xml
+
+# Type checkers
+.mypy_cache/
+.pyright/
+.ty/
+
+# uv / venvs
+.venv/
+venv/
+env/
+.python-version
+
+# Editors
+.vscode/
+.idea/
+*.swp
+*.swo
+.DS_Store
+
+# Caches that may be produced by the package itself during local runs
+.cache/
+
+# Hatch
+.hatch/

mcp_data_core-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Parker Hancock
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mcp_data_core-0.1.0/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: mcp-data-core
+Version: 0.1.0
+Summary: Shared async HTTP scaffolding, response envelopes, corpus storage, and MCP server plumbing for data-fetching research toolkits.
+Project-URL: Homepage, https://github.com/parkerhancock/mcp-data-core
+Project-URL: Repository, https://github.com/parkerhancock/mcp-data-core
+Author-email: Parker Hancock <633163+parkerhancock@users.noreply.github.com>
+License: MIT
+License-File: LICENSE
+Keywords: async,cache,httpx,mcp,research,retry,scaffolding
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: anyio>=4.4
+Requires-Dist: h2>=4.1
+Requires-Dist: hishel[async]>=1.1.3
+Requires-Dist: httpx>=0.27
+Requires-Dist: pydantic>=2.7
+Requires-Dist: python-dateutil>=2.9
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tenacity>=8.4
+Requires-Dist: zstandard>=0.22
+Provides-Extra: gcs
+Requires-Dist: google-cloud-storage>=2.18; extra == 'gcs'
+Provides-Extra: mcp
+Requires-Dist: fastmcp>=3.2.3; extra == 'mcp'
+Requires-Dist: griffe<2; extra == 'mcp'
+Requires-Dist: starlette>=0.37; extra == 'mcp'
+Description-Content-Type: text/markdown
+
+# mcp-data-core
+
+**Batteries-included async HTTP scaffolding and MCP server plumbing for Python data-fetching libraries.**
+
+If you're writing a Python library that pulls structured data from an API — patents, court filings, FDA records, financial filings, anything — you end up rebuilding the same eight things: an `httpx` client with retry, an HTTP cache, a tenacity policy, an OAuth helper, response envelopes, a typed exception hierarchy, per-app logging, and (if you ship an MCP server) tool registration, auth, and signed downloads. `mcp-data-core` is those eight things, packaged.
+
+## Quick Start
+
+```bash
+uv add mcp-data-core           # core scaffolding
+uv add "mcp-data-core[mcp]"    # + FastMCP server helpers
+```
+
+```python
+from mcp_data_core import BaseAsyncClient
+
+class MyApiClient(BaseAsyncClient):
+    DEFAULT_BASE_URL = "https://api.example.com"
+    CACHE_NAME = "my_api"
+
+    async def get_thing(self, id: str) -> dict:
+        return await self._request_json("GET", f"/things/{id}")
+
+async with MyApiClient() as client:
+    result = await client.get_thing("42")
+    stats = await client.cache_stats()
+    print(f"Cache hit rate: {stats.hit_rate:.1f}%")
+```
+
+That's the full surface. Retry, caching, error mapping, and connection pooling are already wired up.
+
+## Features
+
+| Feature | What you get |
+|---|---|
+| **`BaseAsyncClient`** | `httpx.AsyncClient` subclass with retry, caching, error mapping, and cache-management methods. Override `DEFAULT_BASE_URL` + `CACHE_NAME`; the rest is inherited. |
+| **HTTP caching** | `hishel`-backed cache with a custom SQLite/WAL storage layer. Respects HTTP cache headers by default, with TTL override. Inspection (`cache_stats`), eviction (`cache_clear_expired`), and pattern-based invalidation (`cache_invalidate`) built in. |
+| **Retry policy** | `tenacity`-based exponential-jitter retry (4 attempts default). Retryable status set covers 408, 429, 500-504. Honors `Retry-After` headers. |
+| **OAuth2 client credentials** | `OAuth2ClientCredentialsAuth` — drop-in `httpx.Auth` that handles token refresh, retries on 401, and works behind the cache layer. |
+| **Response envelopes** | `ResponseEnvelope`, `ListEnvelope`, `Provenance`. Cursor-based pagination helpers (`encode_cursor` / `decode_cursor`). Every response carries source provenance so downstream consumers can cite. |
+| **Typed exceptions** | `McpDataCoreError` base + `ApiError`, `RateLimitError`, `NotFoundError`, `AuthenticationError`, `ServerError`, `ConfigurationError`, `ValidationError`, `ParseError`. Log-first error formatting: `str(err)` appends the log path so agents can inspect without keeping stacktraces in context. |
+| **Per-app file logging** | `logging.configure("my_app")` attaches a file handler under the `my_app` logger tree, writing to `~/.cache/my_app/my_app.log`. Idempotent; each consumer library logs to its own file. |
+| **Bundled corpora** | `corpus_db` (SQLite/FTS5 reader) and `corpus_compression` (zstd) for libraries that ship statutes, manuals, or other reference text alongside their API client. |
+| **MCP server scaffolding** *(opt-in)* | FastMCP server factory, bearer-token auth, domain gating middleware, conditional tool registration, signed HMAC download URLs with on-disk cache, and OAuth 2.1 + PKCE + DCR helpers. |
+
+## Real-world usage
+
+A trimmed-down version of how [patent-client-agents](https://github.com/parkerhancock/patent-client-agents) wires up a USPTO connector:
+
+```python
+import os
+from mcp_data_core import (
+    BaseAsyncClient,
+    ConfigurationError,
+    ListEnvelope,
+    make_provenance,
+)
+
+BASE_URL = "https://api.uspto.gov"
+
+
+class UsptoOdpClient(BaseAsyncClient):
+    DEFAULT_BASE_URL = BASE_URL
+    CACHE_NAME = "uspto_odp"
+
+    def __init__(self, *, api_key: str | None = None, **kwargs) -> None:
+        api_key = api_key or os.environ.get("USPTO_ODP_API_KEY")
+        if not api_key:
+            raise ConfigurationError("USPTO_ODP_API_KEY required")
+        super().__init__(headers={"X-API-KEY": api_key}, **kwargs)
+
+    async def search_applications(
+        self, query: str, *, limit: int = 25
+    ) -> ListEnvelope[dict]:
+        payload = await self._request_json(
+            "POST",
+            "/api/v1/patent/applications/search",
+            json={"q": query, "pagination": {"limit": limit}},
+        )
+        return ListEnvelope(
+            summary=f"{payload['count']} applications matching {query!r}",
+            items=payload["patentFileWrapperDataBag"],
+            provenance=make_provenance(
+                source_url=f"{BASE_URL}/api/v1/patent/applications/search",
+                source_name="USPTO Open Data Portal",
+            ),
+        )
+```
+
+No retry loop. No cache invalidation. No exception remapping. No connection lifecycle. The library author writes the API-shaped methods; `mcp-data-core` handles everything else.
+
+## What's inside
+
+```
+mcp_data_core/
+├── base_client.py        # BaseAsyncClient
+├── cache.py              # CacheManager, build_cached_http_client, SQLite/WAL storage
+├── resilience.py         # default_retryer, with_retry, RETRYABLE_STATUS_CODES
+├── oauth2.py             # OAuth2ClientCredentialsAuth
+├── envelope.py           # ResponseEnvelope, ListEnvelope, Provenance, cursor helpers
+├── exceptions.py         # McpDataCoreError + 8 subclasses
+├── logging.py            # configure() — per-app file logging
+├── filenames.py          # Download filename conventions
+├── corpus_db.py          # SQLite/FTS5 corpus reader
+├── corpus_compression.py # zstd helpers
+└── mcp/                  # Optional — installed via [mcp] extra
+    ├── server_factory.py # FastMCP app factory
+    ├── auth.py           # OAuth 2.1 + bearer-token helpers
+    ├── middleware.py     # Domain gate, friendly errors, logging
+    ├── conditional.py    # Conditional tool registration
+    ├── downloads.py      # Signed HMAC download URLs + on-disk cache
+    └── annotations.py    # Tool annotations (READ_ONLY, DESTRUCTIVE)
+```
+
+## Provenance
+
+Extracted from [patent-client-agents](https://github.com/parkerhancock/patent-client-agents) 0.20.0 (May 2026) where it had matured as the shared infrastructure across multiple law and patent connectors. Split out as a standalone package so non-IP toolkits — regulatory (FDA), financial, scientific — can use the same scaffolding without pulling the IP-specific connector surface.
+
+### Used by
+
+- [patent-client-agents](https://github.com/parkerhancock/patent-client-agents) — IP-registry connectors (USPTO, EPO, JPO, EUIPO, IP Australia, …)
+
+## Compatibility
+
+- Python 3.11, 3.12, 3.13
+- macOS, Linux. Windows untested.
+- `httpx` 0.27+, `pydantic` 2.7+, `tenacity` 8.4+
+
+## Development
+
+```bash
+git clone https://github.com/parkerhancock/mcp-data-core
+cd mcp-data-core
+uv sync --all-extras --dev
+uv run pytest                                 # 166 tests
+uv run ruff check src tests
+uv run ruff format src tests
+```
+
+Tests are pure-Python — no network, no fixtures, no live APIs. They exercise the cache, retry policy, OAuth refresh, MCP middleware, signed download URLs, and corpus reader against an in-memory transport.
+
+## License
+
+MIT

mcp_data_core-0.1.0/README.md

@@ -0,0 +1,144 @@
+# mcp-data-core
+
+**Batteries-included async HTTP scaffolding and MCP server plumbing for Python data-fetching libraries.**
+
+If you're writing a Python library that pulls structured data from an API — patents, court filings, FDA records, financial filings, anything — you end up rebuilding the same eight things: an `httpx` client with retry, an HTTP cache, a tenacity policy, an OAuth helper, response envelopes, a typed exception hierarchy, per-app logging, and (if you ship an MCP server) tool registration, auth, and signed downloads. `mcp-data-core` is those eight things, packaged.
+
+## Quick Start
+
+```bash
+uv add mcp-data-core           # core scaffolding
+uv add "mcp-data-core[mcp]"    # + FastMCP server helpers
+```
+
+```python
+from mcp_data_core import BaseAsyncClient
+
+class MyApiClient(BaseAsyncClient):
+    DEFAULT_BASE_URL = "https://api.example.com"
+    CACHE_NAME = "my_api"
+
+    async def get_thing(self, id: str) -> dict:
+        return await self._request_json("GET", f"/things/{id}")
+
+async with MyApiClient() as client:
+    result = await client.get_thing("42")
+    stats = await client.cache_stats()
+    print(f"Cache hit rate: {stats.hit_rate:.1f}%")
+```
+
+That's the full surface. Retry, caching, error mapping, and connection pooling are already wired up.
+
+## Features
+
+| Feature | What you get |
+|---|---|
+| **`BaseAsyncClient`** | `httpx.AsyncClient` subclass with retry, caching, error mapping, and cache-management methods. Override `DEFAULT_BASE_URL` + `CACHE_NAME`; the rest is inherited. |
+| **HTTP caching** | `hishel`-backed cache with a custom SQLite/WAL storage layer. Respects HTTP cache headers by default, with TTL override. Inspection (`cache_stats`), eviction (`cache_clear_expired`), and pattern-based invalidation (`cache_invalidate`) built in. |
+| **Retry policy** | `tenacity`-based exponential-jitter retry (4 attempts default). Retryable status set covers 408, 429, 500-504. Honors `Retry-After` headers. |
+| **OAuth2 client credentials** | `OAuth2ClientCredentialsAuth` — drop-in `httpx.Auth` that handles token refresh, retries on 401, and works behind the cache layer. |
+| **Response envelopes** | `ResponseEnvelope`, `ListEnvelope`, `Provenance`. Cursor-based pagination helpers (`encode_cursor` / `decode_cursor`). Every response carries source provenance so downstream consumers can cite. |
+| **Typed exceptions** | `McpDataCoreError` base + `ApiError`, `RateLimitError`, `NotFoundError`, `AuthenticationError`, `ServerError`, `ConfigurationError`, `ValidationError`, `ParseError`. Log-first error formatting: `str(err)` appends the log path so agents can inspect without keeping stacktraces in context. |
+| **Per-app file logging** | `logging.configure("my_app")` attaches a file handler under the `my_app` logger tree, writing to `~/.cache/my_app/my_app.log`. Idempotent; each consumer library logs to its own file. |
+| **Bundled corpora** | `corpus_db` (SQLite/FTS5 reader) and `corpus_compression` (zstd) for libraries that ship statutes, manuals, or other reference text alongside their API client. |
+| **MCP server scaffolding** *(opt-in)* | FastMCP server factory, bearer-token auth, domain gating middleware, conditional tool registration, signed HMAC download URLs with on-disk cache, and OAuth 2.1 + PKCE + DCR helpers. |
+
+## Real-world usage
+
+A trimmed-down version of how [patent-client-agents](https://github.com/parkerhancock/patent-client-agents) wires up a USPTO connector:
+
+```python
+import os
+from mcp_data_core import (
+    BaseAsyncClient,
+    ConfigurationError,
+    ListEnvelope,
+    make_provenance,
+)
+
+BASE_URL = "https://api.uspto.gov"
+
+
+class UsptoOdpClient(BaseAsyncClient):
+    DEFAULT_BASE_URL = BASE_URL
+    CACHE_NAME = "uspto_odp"
+
+    def __init__(self, *, api_key: str | None = None, **kwargs) -> None:
+        api_key = api_key or os.environ.get("USPTO_ODP_API_KEY")
+        if not api_key:
+            raise ConfigurationError("USPTO_ODP_API_KEY required")
+        super().__init__(headers={"X-API-KEY": api_key}, **kwargs)
+
+    async def search_applications(
+        self, query: str, *, limit: int = 25
+    ) -> ListEnvelope[dict]:
+        payload = await self._request_json(
+            "POST",
+            "/api/v1/patent/applications/search",
+            json={"q": query, "pagination": {"limit": limit}},
+        )
+        return ListEnvelope(
+            summary=f"{payload['count']} applications matching {query!r}",
+            items=payload["patentFileWrapperDataBag"],
+            provenance=make_provenance(
+                source_url=f"{BASE_URL}/api/v1/patent/applications/search",
+                source_name="USPTO Open Data Portal",
+            ),
+        )
+```
+
+No retry loop. No cache invalidation. No exception remapping. No connection lifecycle. The library author writes the API-shaped methods; `mcp-data-core` handles everything else.
+
+## What's inside
+
+```
+mcp_data_core/
+├── base_client.py        # BaseAsyncClient
+├── cache.py              # CacheManager, build_cached_http_client, SQLite/WAL storage
+├── resilience.py         # default_retryer, with_retry, RETRYABLE_STATUS_CODES
+├── oauth2.py             # OAuth2ClientCredentialsAuth
+├── envelope.py           # ResponseEnvelope, ListEnvelope, Provenance, cursor helpers
+├── exceptions.py         # McpDataCoreError + 8 subclasses
+├── logging.py            # configure() — per-app file logging
+├── filenames.py          # Download filename conventions
+├── corpus_db.py          # SQLite/FTS5 corpus reader
+├── corpus_compression.py # zstd helpers
+└── mcp/                  # Optional — installed via [mcp] extra
+    ├── server_factory.py # FastMCP app factory
+    ├── auth.py           # OAuth 2.1 + bearer-token helpers
+    ├── middleware.py     # Domain gate, friendly errors, logging
+    ├── conditional.py    # Conditional tool registration
+    ├── downloads.py      # Signed HMAC download URLs + on-disk cache
+    └── annotations.py    # Tool annotations (READ_ONLY, DESTRUCTIVE)
+```
+
+## Provenance
+
+Extracted from [patent-client-agents](https://github.com/parkerhancock/patent-client-agents) 0.20.0 (May 2026) where it had matured as the shared infrastructure across multiple law and patent connectors. Split out as a standalone package so non-IP toolkits — regulatory (FDA), financial, scientific — can use the same scaffolding without pulling the IP-specific connector surface.
+
+### Used by
+
+- [patent-client-agents](https://github.com/parkerhancock/patent-client-agents) — IP-registry connectors (USPTO, EPO, JPO, EUIPO, IP Australia, …)
+
+## Compatibility
+
+- Python 3.11, 3.12, 3.13
+- macOS, Linux. Windows untested.
+- `httpx` 0.27+, `pydantic` 2.7+, `tenacity` 8.4+
+
+## Development
+
+```bash
+git clone https://github.com/parkerhancock/mcp-data-core
+cd mcp-data-core
+uv sync --all-extras --dev
+uv run pytest                                 # 166 tests
+uv run ruff check src tests
+uv run ruff format src tests
+```
+
+Tests are pure-Python — no network, no fixtures, no live APIs. They exercise the cache, retry policy, OAuth refresh, MCP middleware, signed download URLs, and corpus reader against an in-memory transport.
+
+## License
+
+MIT

mcp_data_core-0.1.0/pyproject.toml

@@ -0,0 +1,89 @@
+[project]
+name = "mcp-data-core"
+version = "0.1.0"
+description = "Shared async HTTP scaffolding, response envelopes, corpus storage, and MCP server plumbing for data-fetching research toolkits."
+readme = "README.md"
+authors = [
+    { name = "Parker Hancock", email = "633163+parkerhancock@users.noreply.github.com" }
+]
+requires-python = ">=3.11"
+license = { text = "MIT" }
+keywords = ["mcp", "httpx", "async", "research", "cache", "retry", "scaffolding"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
+dependencies = [
+    "anyio>=4.4",
+    "httpx>=0.27",
+    "h2>=4.1",
+    "pydantic>=2.7",
+    "python-dateutil>=2.9",
+    "tenacity>=8.4",
+    "hishel[async]>=1.1.3",
+    "pyyaml>=6.0",
+    "zstandard>=0.22",
+]
+
+[project.optional-dependencies]
+mcp = [
+    "fastmcp>=3.2.3",
+    "starlette>=0.37",
+    # fastmcp imports `from griffe import ...` — the 2.x release split the
+    # top-level module out into a separate `griffelib` distribution, so
+    # fastmcp's import fails on griffe>=2. Pin here until upstream fastmcp
+    # either migrates to griffelib or re-adds the compat shim.
+    "griffe<2",
+]
+gcs = [
+    "google-cloud-storage>=2.18",
+]
+
+[project.urls]
+Homepage = "https://github.com/parkerhancock/mcp-data-core"
+Repository = "https://github.com/parkerhancock/mcp-data-core"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/mcp_data_core"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-asyncio>=0.24.0",
+    "pytest-cov>=7.0.0",
+    "ruff>=0.9.0",
+]
+
+[tool.ruff]
+line-length = 100
+target-version = "py311"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+ignore = [
+    "E501",
+    "B008",
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["mcp_data_core"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]

mcp_data_core-0.1.0/src/mcp_data_core/__init__.py

@@ -0,0 +1,78 @@
+"""Shared HTTP and MCP scaffolding for consumer libraries.
+
+Provides the infrastructure that consumers build on:
+
+- Exception hierarchy for API errors (``McpDataCoreError`` and subclasses)
+- ``BaseAsyncClient`` with caching and retry support
+- HTTP caching utilities (``CacheManager``, ``build_cached_http_client``)
+- Resilience utilities (``default_retryer``, ``with_retry``)
+- File-based logging configured per consumer app (``configure``)
+"""
+
+from .base_client import BaseAsyncClient
+from .cache import CacheManager, CacheStats, build_cached_http_client
+from .envelope import (
+    ListEnvelope,
+    Provenance,
+    ResponseEnvelope,
+    decode_cursor,
+    encode_cursor,
+    make_provenance,
+)
+from .envelope import configure as configure_envelope
+from .exceptions import (
+    ApiError,
+    AuthenticationError,
+    ConfigurationError,
+    McpDataCoreError,
+    NotFoundError,
+    ParseError,
+    RateLimitError,
+    ServerError,
+    ValidationError,
+)
+from .logging import configure, log_file_hint
+from .oauth2 import OAuth2ClientCredentialsAuth
+from .resilience import (
+    RETRYABLE_STATUS_CODES,
+    default_retryer,
+    is_retryable_error,
+    with_retry,
+)
+
+__all__ = [
+    # Base client
+    "BaseAsyncClient",
+    # Caching
+    "build_cached_http_client",
+    "CacheManager",
+    "CacheStats",
+    # Envelope
+    "Provenance",
+    "ResponseEnvelope",
+    "ListEnvelope",
+    "configure_envelope",
+    "make_provenance",
+    "encode_cursor",
+    "decode_cursor",
+    # Exceptions
+    "McpDataCoreError",
+    "ApiError",
+    "NotFoundError",
+    "RateLimitError",
+    "AuthenticationError",
+    "ServerError",
+    "ValidationError",
+    "ConfigurationError",
+    "ParseError",
+    # Logging
+    "configure",
+    "log_file_hint",
+    # OAuth2
+    "OAuth2ClientCredentialsAuth",
+    # Resilience
+    "RETRYABLE_STATUS_CODES",
+    "is_retryable_error",
+    "default_retryer",
+    "with_retry",
+]