ebay-apiroute 0.1.0__tar.gz

ebay_apiroute-0.1.0/.agent/skills/apiroute-client.md

@@ -0,0 +1,172 @@
+---
+name: apiroute-client
+description: Create, set up and maintain a GitHub repository that publishes apiroute-generated Python clients for an API described by OpenAPI/Swagger specs or WSDLs. Covers gathering the specs and documentation links, the repository layout, the apis.yaml generation config, hand-written auth base classes, the README, CI/Build/Release workflows (the Build workflow regenerates and commits changes), PyPI publishing (only if the user wants it), and ongoing maintenance.
+---
+
+# apiroute client repositories
+
+Use this skill when asked to create a client repository for an API ("make an ebay-apiroute / stripe-apiroute repo"), or to maintain one: adding or removing an API, a spec change that broke generation, upgrading apiroute, or setting up releases.
+
+A client repository holds generated code that is never edited by hand. It is the output of [apiroute](https://github.com/dougyouch/apiroute)'s generator (`apiroute generate openapi|wsdl`), applied to specs listed in one config file, and refreshed by a scheduled workflow. The reference implementation is **[ebay-apiroute](https://github.com/dougyouch/ebay-apiroute)**. Copy its files and adapt them rather than writing new ones; the sections below say what to change.
+
+## 1. Gather before creating anything
+
+Ask the user (an AskUserQuestion-style prompt with choices works well), and confirm what you find:
+
+1. **Names:**
+   - the repository (`<api>-apiroute`)
+   - the PyPI name (the same)
+   - the Python package (`<api>_apiroute`)
+   - the GitHub owner
+2. **Which APIs to cover.** Offer "everything with a published spec" as the default; lazy loading makes unused APIs free.
+3. **Will it be released to PyPI?** Always ask; never assume. If yes, the repo gets `release.yml` and the user must create a PyPI pending publisher (step 6). If no, skip `release.yml`, and the README says to install from GitHub (`pip install git+https://github.com/<owner>/<repo>`).
+4. **Public or private.** Releasing to PyPI implies public.
+5. **Auth model:** OAuth bearer tokens, API keys, Basic auth, request signing, SOAP header credentials, or extra per-call parameters. This decides the auth base class (step 4).
+
+Then find each API's machine-readable description and its documentation page:
+
+- **Download every spec and check its content, not the HTTP status.** Some sites (eBay's among them) answer unknown URLs with a normal 200 page. A spec must parse as JSON/YAML with an `openapi` or `swagger` key, or as XML with `definitions` (WSDL).
+- **Treat documentation links the same way.** Some sites serve an error page to `curl` but the real page to browsers. A page's `<title>` that says "Error" or "Not Found" means "try another URL or a web search", not "it doesn't exist". Every API in the README table needs a working documentation link.
+- **Probe URL patterns** when a site publishes many specs (for eBay: `/api-docs/master/<group>/<api>/openapi/3/<group>_<api>_<version>_oas3.json`), but keep only the ones whose content validates.
+- **Generate each spec into a scratch directory** before committing to it: `apiroute generate openapi <url> -o /tmp/x --models`. Note any spec the generator can't handle, and either fix apiroute or leave that API out, telling the user which.
+
+## 2. Repository layout
+
+```text
+<repo>/
+  apis.yaml                     the source of truth: one entry per API (hand-written)
+  specs/                        committed copies of the specs (written by --fetch)
+  scripts/generate.py           fetch specs, run apiroute generate, write the README table
+  src/<package>/
+    __init__.py                 package docstring (hand-written)
+    auth.py                     auth base classes the generated clients extend (hand-written)
+    <group>/__init__.py         written by scripts/generate.py
+    <group>/<api>/              generated by apiroute (never edited)
+  tests/                        config checks, auth behaviour, one call per protocol
+  .github/workflows/            ci.yml, build.yml, release.yml (if releasing)
+  release-please-config.json    .release-please-manifest.json   (if releasing)
+  AGENT.md  CLAUDE.md           agent guidance; CLAUDE.md imports AGENT.md with "@AGENT.md"
+  .agent/skills/apiroute-client.md   this skill (copy it into the new repository)
+  README.md  CHANGELOG.md  LICENSE  pyproject.toml  uv.lock
+```
+
+`apis.yaml`, one entry per API:
+
+```yaml
+package: ebay_apiroute
+apis:
+  - name: sell_inventory            # unique; also the spec file name in specs/
+    title: Inventory API            # shown in the README table
+    format: openapi                 # openapi (covers Swagger 2.0) or wsdl
+    spec: https://.../sell_inventory_v1_oas3.json
+    docs: https://developer.ebay.com/api-docs/sell/static/api-inventory.html
+    module: sell.inventory          # -> src/ebay_apiroute/sell/inventory/
+    client: SellInventoryApi
+    base_class: ebay_apiroute.auth:EbayAuth   # optional; owns auth
+    models: true                    # optional, default true: the typed .models layer
+```
+
+`scripts/generate.py`: copy [ebay-apiroute's](https://github.com/dougyouch/ebay-apiroute/blob/main/scripts/generate.py). It does the following:
+
+- `--fetch` downloads each spec, validates it, and re-indents JSON (keeping key order) so diffs stay readable.
+- It runs `apiroute generate <format> specs/<name> -o src/<package>/<module> --client-name ... --models --base-class ...` for each API.
+- It writes the group packages' `__init__.py`, marked "Generated by scripts/generate.py".
+- It rewrites the README table between `<!-- apis:start -->` and `<!-- apis:end -->`.
+- `--only NAME` limits the run to the named APIs.
+
+Remove the eBay-specific `_write_trading_version`, or adapt it to any value your auth class must read from a spec.
+
+`pyproject.toml`:
+- Depend on `apiroute>=<current>` (add `apiroute[soap]` when any API is a WSDL) and `pydantic>=2`. Put `apiroute[codegen]`, `pytest` and `ruff` in the `dev` dependency group.
+- Set ruff's `line-length = 100` and `extend-exclude = ["specs"]`.
+- Keep `specs/` out of the sdist.
+
+## 3. Generate, lint, import
+
+```bash
+uv sync
+uv run python scripts/generate.py --fetch
+uv run ruff check . && uv run ruff format --check .   # generated code passes both
+```
+
+Then import every module and build every model, on the lowest and highest supported Python versions. A Python 3.10 import catches annotation problems that 3.14's deferred annotations hide. The checks live in `tests/test_apis_config.py`:
+
+- every `apis.yaml` entry has a spec file, a documentation link, an importable client and the configured base class
+- every route compiles
+
+## 4. Auth base class (hand-written, in `auth.py`)
+
+Every generated root client extends the `base_class` from `apis.yaml`, and apiroute then generates no auth of its own. Write the class once, by subclassing `apiroute.Client`. Sections inherit its `headers` and `query_params`, and they use its hooks.
+
+| Need | How |
+| --- | --- |
+| Bearer token | `headers = {"Authorization": lambda self: f"Bearer {self.current_token()}" if self._token else None}`; accept a string or a function returning one (for refreshing OAuth helpers) |
+| API key in a header or query | an entry in `headers` or `query_params` reading an attribute |
+| Request signing | `on_request(self, request)` returning `dataclasses.replace(request, headers=...)` |
+| Per-call parameters | `on_request`, with `request.operation` (the spec's operationId or WSDL operation name) |
+| SOAP header credentials | `soap_header(self, operation) -> dict`, in the same xmltodict shape as bodies |
+| Sandbox or region hosts | an `__init__` flag that sets `kwargs["base_url"]` from `type(self)._config.base_url` |
+
+Test each behaviour in `tests/` with `httpx.MockTransport`: the header or parameter on the wire, the sandbox host, and a SOAP header if any.
+
+## 5. README (generate it as part of setup)
+
+It must have:
+- a one-paragraph description with CI and Build badges
+- installation instructions (PyPI, or from GitHub when not releasing)
+- usage per protocol: dict and typed calls, `.aio`, auth arguments and sandbox
+- **links to the API's documentation and its auth or token guide**
+- the generated API table, with a docs link per API
+- **how the repository stays up to date:**
+  - the Build schedule
+  - the `specs/` snapshot and `git log -p specs/`
+  - apiroute as the generator
+  - the commit types and the releases they produce
+  - what CI checks
+- development commands, and how to add an API
+
+Use ebay-apiroute's README as the template.
+
+## 6. Workflows
+
+Copy them from ebay-apiroute and change the names, the PyPI project and the schedule.
+
+- **`ci.yml`** runs on pushes to main, pull requests and `workflow_call`:
+  - Lint: `ruff check` and `ruff format --check`.
+  - `generated-is-current`: runs `scripts/generate.py` without `--fetch` and fails on any `git status` difference. This catches hand edits, and specs out of step with the code.
+  - Tests on every supported Python version.
+- **`build.yml`** runs on a schedule and `workflow_dispatch`:
+  1. `uv lock --upgrade-package apiroute`, then `uv sync`.
+  2. `scripts/generate.py --fetch`.
+  3. Lint and test.
+  4. If `git status` shows changes, commit and push to main:
+     - `feat(specs): update clients from <API>'s latest specs` when `specs/` changed (a minor release)
+     - otherwise `fix(codegen): regenerate clients with apiroute <version>` (a patch)
+
+  It needs `permissions: contents: write`. If `main` is protected, give the workflow a bypass or have it open a PR instead.
+- **`release.yml`**, only if the user said yes to PyPI, runs release-please, then CI through `workflow_call`, then publishes with `uv publish --trusted-publishing always` in the `pypi` environment. It skips a version that's already on PyPI, and attaches the distributions to the GitHub release. Besides `push` and `workflow_dispatch`, trigger it on `workflow_run` of Build: commits pushed with `GITHUB_TOKEN` don't trigger other workflows.
+
+Each repository needs these GitHub and PyPI settings:
+
+- Delete branches on merge: `gh repo edit --delete-branch-on-merge`.
+- Let Actions open pull requests, for release-please: `gh api -X PUT repos/<owner>/<repo>/actions/permissions/workflow -f default_workflow_permissions=read -F can_approve_pull_request_reviews=true`.
+- If releasing:
+  - The user creates a PyPI **pending publisher**: the project name, the repository owner and name, workflow `release.yml`, environment `pypi`.
+  - Before the first release, set the version (e.g. `0.1.0`) in `pyproject.toml` and `.release-please-manifest.json`.
+  - Tag `v<version>`, create its GitHub release, and run Release manually to publish. After that, release-please opens release PRs and merging them publishes.
+
+## 7. Maintenance
+
+- **Routine:** none. Build commits changes and release-please collects them. Review the release PR's CHANGELOG, then merge.
+- **A spec change breaks generation:** Build fails before committing, and the last good code stays on main. Reproduce with `scripts/generate.py --fetch --only <name>`, then fix apiroute (preferred) or the auth class. Never patch `specs/` or generated files by hand.
+- **Add an API:** add an `apis.yaml` entry, verifying its spec and docs as in step 1, then `generate.py --fetch --only <name>`, then test and commit (`feat:`).
+- **Remove an API:** delete its entry, its spec and its folder, then regenerate and commit (`feat!:` if it was released).
+- **apiroute adds a feature you need:** release apiroute, raise the minimum in `pyproject.toml`, `uv lock`, regenerate, commit.
+
+## 8. Before handing over
+
+- [ ] Every API has a working spec and a working docs link (checked by content, not by status).
+- [ ] `ruff check`, `ruff format --check`, the tests, and a Python 3.10 import of every module all pass.
+- [ ] CI, Build (run it once by hand) and, if releasing, Release are green.
+- [ ] Branch auto-delete is on and Actions can open PRs. If releasing, the pending publisher exists, or the user knows to create it.
+- [ ] README, AGENT.md, CLAUDE.md (importing AGENT.md) and this skill are in the repository.

ebay_apiroute-0.1.0/.github/workflows/build.yml

@@ -0,0 +1,55 @@
+name: Build
+
+# Keeps the clients current: fetches eBay's latest API specs, upgrades apiroute, regenerates,
+# checks, and commits any difference to main. A changed spec is committed as feat(specs)
+# (a minor release); output that changed only because apiroute did, as fix(codegen) (a patch).
+on:
+  schedule:
+    - cron: "23 7 * * 1" # Mondays 07:23 UTC
+  workflow_dispatch:
+
+permissions:
+  contents: write # commit regenerated clients
+
+concurrency:
+  group: build
+  cancel-in-progress: false
+
+jobs:
+  regenerate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.14"
+      - name: Use the newest apiroute
+        run: uv lock --upgrade-package apiroute
+      - run: uv sync
+      - name: Fetch the latest specs and regenerate
+        run: uv run python scripts/generate.py --fetch
+      - name: Check
+        run: |
+          uv run ruff check .
+          uv run ruff format --check .
+          uv run pytest
+      - name: Commit changes
+        run: |
+          if [ -z "$(git status --porcelain)" ]; then
+            echo "Specs and generated clients are unchanged."
+            exit 0
+          fi
+          specs=$(git status --porcelain -- specs | awk '{print $2}' | xargs -r -n1 basename | sed 's/\..*$//' | sort -u | paste -sd ' ' -)
+          if [ -n "$specs" ]; then
+            subject="feat(specs): update clients from eBay's latest API specs"
+            body="Changed specs: $specs"
+          else
+            version=$(uv run python -c "import importlib.metadata as m; print(m.version('apiroute'))")
+            subject="fix(codegen): regenerate clients with apiroute $version"
+            body="No spec changed; the generated code did, with the newer apiroute."
+          fi
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          git add -A
+          git commit -m "$subject" -m "$body"
+          git push

ebay_apiroute-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_call: # run by release.yml before publishing
+
+permissions:
+  contents: read
+
+jobs:
+  lint:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.14"
+      - run: uv sync
+      - run: uv run ruff check .
+      - run: uv run ruff format --check .
+
+  # The committed code must be exactly what the committed specs generate: nothing in src/
+  # is edited by hand, and specs/ and src/ never drift apart.
+  generated-is-current:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: "3.14"
+      - run: uv sync
+      - run: uv run python scripts/generate.py
+      - name: Check for differences
+        run: |
+          if [ -n "$(git status --porcelain)" ]; then
+            git status --short
+            echo "::error::Generated code differs from the committed specs. Run 'uv run python scripts/generate.py' and commit the result."
+            exit 1
+          fi
+
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12", "3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v6
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: uv sync
+      - run: uv run pytest

ebay_apiroute-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,111 @@
+name: Release
+
+# release-please keeps a release PR open that bumps the version in pyproject.toml and
+# CHANGELOG.md from conventional commits. Merging it tags the release, creates the GitHub
+# release and publishes the package to PyPI (trusted publishing, environment "pypi").
+# It also runs after Build, whose commits (pushed by a workflow) don't trigger push events.
+# Run it manually (workflow_dispatch) to retry publishing the current version.
+on:
+  push:
+    branches: [main]
+  workflow_run:
+    workflows: [Build]
+    types: [completed]
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # release commits, tags and GitHub releases
+      issues: write # release labels
+      pull-requests: write # the release PR
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+      tag_name: ${{ steps.release.outputs.tag_name }}
+      pr_branch: ${{ steps.release.outputs.pr && fromJSON(steps.release.outputs.pr).headBranchName || '' }}
+    steps:
+      - uses: googleapis/release-please-action@45996ed1f6d02564a971a2fa1b5860e934307cf7 # v5.0.0
+        id: release
+        with:
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+
+  # uv.lock records this package's own version, which release-please doesn't update,
+  # so regenerate the lockfile on the release PR branch.
+  sync-lockfile:
+    needs: release-please
+    if: needs.release-please.outputs.pr_branch != ''
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # push to the release PR branch
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          ref: ${{ needs.release-please.outputs.pr_branch }}
+      - uses: astral-sh/setup-uv@v6
+      - run: uv lock
+      - name: Push updated uv.lock
+        run: |
+          git diff --quiet uv.lock && exit 0
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          git commit -m 'build(deps): sync uv.lock version' uv.lock
+          git push
+
+  # The release PR is opened with GITHUB_TOKEN, which doesn't trigger CI on it,
+  # so run the suite here before anything is published.
+  ci:
+    needs: release-please
+    if: needs.release-please.outputs.release_created == 'true' || github.event_name == 'workflow_dispatch'
+    uses: ./.github/workflows/ci.yml
+
+  publish:
+    needs: [release-please, ci]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/ebay-apiroute/
+    permissions:
+      contents: write # attach the distributions to the GitHub release
+      id-token: write # PyPI trusted publishing (OIDC)
+    steps:
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          # the new tag on release; the dispatched commit on a manual retry
+          ref: ${{ needs.release-please.outputs.tag_name || github.sha }}
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@v6
+
+      - name: Read version
+        run: |
+          version=$(uv version --short)
+          echo "VERSION=$version" >> "$GITHUB_ENV"
+          echo "TAG=v$version" >> "$GITHUB_ENV"
+
+      - name: Build
+        run: uv build
+
+      # A version that's already on PyPI is skipped, so a manual retry can finish a
+      # partially published release.
+      - name: Publish to PyPI
+        run: |
+          if curl -sf "https://pypi.org/pypi/ebay-apiroute/$VERSION/json" > /dev/null; then
+            echo "ebay-apiroute $VERSION is already published"
+          else
+            uv publish --trusted-publishing always
+          fi
+
+      - name: Attach distributions to GitHub release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          gh release upload "$TAG" dist/* --repo "$GITHUB_REPOSITORY" --clobber

ebay_apiroute-0.1.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.venv/
+.pytest_cache/
+.ruff_cache/
+dist/
+build/
+*.egg-info/

ebay_apiroute-0.1.0/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.1.0"
+}

ebay_apiroute-0.1.0/AGENT.md

@@ -0,0 +1,50 @@
+# AGENT.md
+
+Guidance for AI coding agents (and people) working in this repository.
+
+## What this repository is
+
+`ebay-apiroute` publishes Python clients for eBay's APIs: 29 REST APIs (Buy, Sell, Commerce, Developer) and the SOAP Trading API. The clients are **generated** by [apiroute](https://github.com/dougyouch/apiroute) from the API specs eBay publishes. They're kept current by the weekly Build workflow, and released to PyPI as `ebay-apiroute`.
+
+## Layout
+
+| Path | What it is | Edit by hand? |
+| --- | --- | --- |
+| `apis.yaml` | Every API: spec URL, docs URL, module, client class, auth base class | **yes**: this is the source of truth |
+| `specs/` | Committed copies of the specs, written by `scripts/generate.py --fetch` | no (fetch them) |
+| `scripts/generate.py` | Fetches specs, runs `apiroute generate` per API, writes group `__init__`s, `trading_version.py`, the README table | yes |
+| `src/ebay_apiroute/auth.py` | `EbayAuth` (REST OAuth, marketplace, sandbox) and `TradingAuth` (SOAP credentials, call name), which generated clients extend | **yes** |
+| `src/ebay_apiroute/__init__.py` | Package docstring | yes |
+| `src/ebay_apiroute/<group>/<api>/`, `trading/` | Generated clients (every file starts with `# Generated by apiroute`) | **never** |
+| `src/ebay_apiroute/<group>/__init__.py`, `trading_version.py` | Written by `scripts/generate.py` | never |
+| `tests/` | Config checks, REST auth, Trading SOAP | yes |
+| `.github/workflows/` | `ci.yml`, `build.yml` (regenerate and commit), `release.yml` (release-please and PyPI) | yes |
+| `.agent/skills/apiroute-client.md` | Skill for creating and maintaining repos like this one | yes |
+
+## Rules
+
+- **Never edit generated code.** CI regenerates from `specs/` and fails on any difference. To change generated output:
+  - Edit `apis.yaml` or `auth.py` and regenerate.
+  - If the generator itself is wrong, fix apiroute; the Build workflow picks up its next release.
+- **Regenerate after any change** to `apis.yaml` or the generate script: `uv run python scripts/generate.py`. Add `--fetch` to download the latest specs first. Commit the specs and the generated code together.
+- **Credentials belong in `auth.py`.** Every generated root client extends the `base_class` named in `apis.yaml`, and spec-declared security schemes aren't generated. REST APIs use `EbayAuth`; Trading uses `TradingAuth`.
+- **Use conventional commits.** release-please derives versions from them:
+  - `feat:` is a minor release
+  - `fix:` is a patch
+  - `chore:`, `docs:`, `test:` and `ci:` produce no release
+- **Before committing:** `uv run ruff check .`, `uv run ruff format --check .` and `uv run pytest`.
+
+## Common tasks
+
+- **Add an eBay API:**
+  1. Find its OpenAPI 3 contract: `https://developer.ebay.com/api-docs/master/<group>/<api>/openapi/3/<group>_<api>_<version>_oas3.json`.
+  2. Check the download is JSON with an `openapi` key. eBay answers unknown URLs with a normal page instead of a 404.
+  3. Add an entry to `apis.yaml`, using an existing one as a template.
+  4. Run `scripts/generate.py --fetch --only <name>`, then the tests.
+- **A spec change broke generation:** the Build workflow fails before committing anything. Reproduce with `scripts/generate.py --fetch --only <name>`, then fix apiroute or `auth.py`. Patching `specs/` by hand would be overwritten by the next fetch.
+- **Remove an API:** delete its `apis.yaml` entry, its file in `specs/` and its folder under `src/ebay_apiroute/`, then regenerate.
+- **Release:** merge the release PR that release-please keeps open. Publishing uses PyPI trusted publishing (the `pypi` environment, `release.yml`). Running Release manually retries publishing the current version.
+
+## Skill
+
+`.agent/skills/apiroute-client.md` describes how to create, set up and maintain a client repository like this one for any API with OpenAPI/Swagger specs or WSDLs. Read it before restructuring this repo or creating a sibling.

ebay_apiroute-0.1.0/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Changelog
+
+## [0.1.0] - Unreleased
+
+### Added
+
+- Generated clients for 29 eBay REST APIs (Buy, Sell, Commerce, Developer) from eBay's OpenAPI 3 contracts, and for the Trading API from its WSDL, with dict and pydantic model layers, sync and async.
+- `EbayAuth`: OAuth access tokens (strings, or functions returning the current one), `X-EBAY-C-MARKETPLACE-ID`, and the sandbox.
+- `TradingAuth`: `RequesterCredentials` in the SOAP header, plus the call name, site, application ID and version in the query.
+- Weekly Build workflow that refetches the specs, regenerates and commits changes; CI that checks the generated code matches the committed specs; release-please and PyPI trusted publishing.

ebay_apiroute-0.1.0/CLAUDE.md

@@ -0,0 +1,7 @@
+# CLAUDE.md
+
+This repository's guidance for coding agents lives in AGENT.md, imported here:
+
+@AGENT.md
+
+Skills for this repository are in `.agent/skills/`. Read `.agent/skills/apiroute-client.md` before creating or restructuring an apiroute client repository.

ebay_apiroute-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dougyouch
+
+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.