openapi-client-codegen 0.1.14__tar.gz → 0.1.15.dev37253060679__tar.gz

openapi_client_codegen-0.1.15.dev37253060679/.github/actions/setup-release-devkit/action.yml

@@ -0,0 +1,11 @@
+name: setup-release-devkit
+description: Install release-devkit at the pinned commit into RUNNER_TEMP
+runs:
+  using: composite
+  steps:
+    - shell: bash
+      env:
+        RELEASE_DEVKIT_COMMIT: ad4215260f7b24ec36d94ddc2ba6660be8afc5fb
+      run: |
+        git clone https://github.com/outernet-foundation/release-devkit.git "$RUNNER_TEMP/release-devkit"
+        git -C "$RUNNER_TEMP/release-devkit" checkout "$RELEASE_DEVKIT_COMMIT"

openapi_client_codegen-0.1.15.dev37253060679/.github/workflows/integrate.yml

@@ -0,0 +1,56 @@
+name: Integrate
+
+on:
+  workflow_dispatch:
+  pull_request:
+    branches: [dev]
+
+concurrency:
+  group: integrate-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  lint-workflows:
+    runs-on: ubuntu-latest
+    steps:
+      - &checkout
+        uses: actions/checkout@v5
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          persist-credentials: false
+      - &uv-restore
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          save-cache: "false"
+      - &setup-release-devkit
+        uses: ./.github/actions/setup-release-devkit
+      - run: uv run --project "$RUNNER_TEMP/release-devkit" --locked --no-dev lint-workflows
+
+  preflight:
+    needs: [lint-workflows]
+    runs-on: ubuntu-latest
+    steps:
+      - *checkout
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          save-cache: "true"
+      - run: uv run preflight-python
+
+  validate-release-plan:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ github.event.pull_request.head.sha }}
+          # Perform a full clone, required for tags
+          fetch-depth: 0
+          fetch-tags: true
+          persist-credentials: false
+      - *uv-restore
+      - *setup-release-devkit
+      - run: uv run --project "$RUNNER_TEMP/release-devkit" --locked --no-dev validate-release-plan

openapi_client_codegen-0.1.15.dev37253060679/.github/workflows/merge-gate.yml

@@ -0,0 +1,41 @@
+name: Merge gate
+
+on:
+  pull_request:
+    branches: [dev]
+    types: [labeled]
+  workflow_run:
+    workflows: [Integrate]
+    types: [completed]
+
+concurrency:
+  group: merge-gate-${{ github.event.pull_request.number || github.event.workflow_run.head_branch }}
+
+permissions:
+  contents: read
+
+jobs:
+  merge-gate:
+    if: github.event.label.name == 'ready-to-merge' || (github.event_name == 'workflow_run' && github.event.workflow_run.conclusion == 'success')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: ${{ github.event.pull_request.head.sha || github.event.workflow_run.head_sha }}
+          # Perform a full clone, required so merge-gate can validate that this PR is a fast forward from dev
+          fetch-depth: 0
+          persist-credentials: false
+      - uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          save-cache: "false"
+      - uses: ./.github/actions/setup-release-devkit
+      - uses: actions/create-github-app-token@v3
+        id: mint
+        with:
+          app-id: ${{ vars.MERGE_BOT_APP_ID }}
+          private-key: ${{ secrets.MERGE_BOT_APP_PRIVATE_KEY }}
+      - run: uv run --project "$RUNNER_TEMP/release-devkit" --locked --no-dev merge-gate
+        env:
+          GITHUB_TOKEN: ${{ steps.mint.outputs.token }}
+          HEAD_SHA: ${{ github.event.pull_request.head.sha || github.event.workflow_run.head_sha }}

openapi_client_codegen-0.1.15.dev37253060679/.github/workflows/release.yml

@@ -0,0 +1,70 @@
+name: Release
+
+on:
+  push:
+    branches: [main, dev]
+
+concurrency:
+  group: release-${{ github.ref }}
+
+permissions:
+  contents: read
+
+jobs:
+  ensure-release-pr:
+    if: github.ref == 'refs/heads/dev'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          persist-credentials: false
+      - &uv-restore
+        uses: astral-sh/setup-uv@v7
+        with:
+          enable-cache: true
+          save-cache: "false"
+      - &setup-release-devkit
+        uses: ./.github/actions/setup-release-devkit
+      - run: uv run --project "$RUNNER_TEMP/release-devkit" --locked --no-dev ensure-release-pr
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
+
+  publish-prerelease:
+    if: github.ref == 'refs/heads/dev'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          # Perform a full clone, required for tags
+          fetch-depth: 0
+          fetch-tags: true
+          persist-credentials: false
+      - *uv-restore
+      - *setup-release-devkit
+      - run: uv run --project "$RUNNER_TEMP/release-devkit" --locked --no-dev publish-prerelease
+
+  release:
+    if: github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      id-token: write
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          # Perform a full clone, required for tags
+          fetch-depth: 0
+          fetch-tags: true
+          # Persist credentials so that the release command can push release tags
+          persist-credentials: true
+      - *uv-restore
+      - *setup-release-devkit
+      - run: uv run --project "$RUNNER_TEMP/release-devkit" --locked --no-dev release
+        env:
+          GITHUB_TOKEN: ${{ github.token }}

openapi_client_codegen-0.1.15.dev37253060679/AGENTS.md

@@ -0,0 +1,50 @@
+# openapi-client-codegen
+
+## What this is
+
+`openapi-client-codegen` wraps [OpenAPI Generator](https://openapi-generator.tech/) to turn an OpenAPI schema into typed client packages — a Python (`httpx`) client and a Unity-consumable C# (`httpclient`) client. It owns every step that is generic across consumers: the project orchestration loop, downgrading 3.1→3.0, the committed-spec unchanged skip, authoring and patching the C# templates, running the generator, and writing the Unity package metadata. The caller owns what is inherently project-specific: **producing the OpenAPI spec** (a command string in the consumer's config, run by the library's `SpecProducer`), the project→client mapping, the naming root, the npm scope, license, repository URL, and the generated output root.
+
+The package is `openapi_client_codegen` (src-layout under `src/openapi_client_codegen/`). Python dependencies: `bashrun`, `packaging` (`requires` specifier parsing), `pydantic` (config schema), `strictyaml` (config loading), `typer` (thin CLI) — all from PyPI; git-source pins only in scratch branches testing unreleased changes. At **runtime** it also needs **Java (JDK 11+)** and **`uvx`** on PATH — the generator itself runs as `uvx --from 'openapi-generator-cli[jdk4py]==<pin>' ...`.
+
+## Public API
+
+The package init is empty (RUF067 strict mode); import each symbol from its defining module: `client` (`generate_client`), `cli` (`app`), `downgrade` (`downgrade_openapi_3_1_to_3_0`, `JsonDict`), `orchestrator` (`ProjectsConfig`, `ClientNaming`, `SpecProducer`, `load_config`), `templates` (`regenerate_templates`), `unity` (`write_unity_package_metadata`).
+
+- `ProjectsConfig` is the pydantic schema of a consumer's config (`extra="forbid"`) and the single source of identity — the CLI validates `--config` into it and nothing overrides it per invocation. Required: `projects` (project path → generator list), `root_name`, `generated_root`, `spec_command`, `requires` (a PEP 440 specifier; `load_config` self-checks the installed version and refuses outside range; "no constraint" is explicit `requires: ">=0.0"`; the `0.0.0.dev0` dev sentinel bypasses the check, not the field's presence). Optional: `spec_env`, `npm_scope`, `license_spdx`, `repository_url`.
+- The CLI (`app`, single command, no subcommand; consumer `[project.scripts]` aliases point at it, e.g. placeframe's `generate-clients`) orchestrates per mapping entry: produce the spec via the config-built `SpecProducer` → downgrade 3.1→3.0 → write `<project>/openapi.json` unless byte-identical to the committed spec (`--no-cache` forces through) → `generate_client` per listed generator into `<generated_root>/<generator>/<base>`. `--check` is the CI staleness gate: unconditional regen, non-zero exit if any spec or generated client differs from the committed tree; the checked paths are fully derived from config, no per-consumer path args. Flags are invocation-scoped only (`--project`/`--client` filters, `--no-cache`, `--check`, `--root`). Commands run shell-less (shlex-split, operators rejected) — env gating is the structured `spec_env`, never a `VAR=…` prefix.
+- `SpecProducer(command, env=None)` — callable class wrapping any command that prints the spec to stdout, run with the project directory as cwd and an optional per-call env overlay; programmatic consumers construct it directly.
+- `ClientNaming` — the derived per-project package identity: `base` (last path segment + `-client`), `dashed` (`{root_name}-{base}`), `underscored`, `camel`. Constructed inline by the CLI per project; a consumer needing different names calls the per-client API directly with its own `ClientNaming`.
+- `generate_client(spec, generator, output_dir, names, ...)` — run the generator for one `(spec, generator)` and sync into `output_dir`; `templates_dir` is required for `csharp`, where `npm_scope` composes the UPM identity `{scope}.{base-minus-dashes}` (unset falls back to the legacy `org.nuget.{camel-lower}`).
+- `write_unity_package_metadata(...)` — write `package.json` / `.asmdef` / `csc.rsp` / `Directory.Build.props`; called by `generate_client` for csharp.
+
+The generator version pin and the shipped configs/patches/ignore-file live in `src/openapi_client_codegen/_data/` (paths in `_data.py`).
+
+## Constraints
+
+### The C# template patches are path-generic and repo-independent
+
+The shipped patches (`_data/templates-patches/csharp/00NN-*.patch`) carry generic `a/csharp/<path>` headers, not any consumer's repo layout. `regenerate_templates` applies them with `git apply -p1` and `cwd=target_dir`, which lands them on the freshly-authored tree **without needing a surrounding git repository** — `git apply` patches worktree files fine outside any repo as long as `--index` is not used. Patches apply in filename order (the `00NN` prefix is load-bearing: later patches depend on earlier hunks' context); `extra_patches_dir` patches apply after the shipped set.
+
+To author a new patch: author the raw templates (`openapi-generator-cli author template -g csharp --library httpclient`) into a scratch dir, copy it, edit a `.mustache` in the copy, `git diff --no-index` the two trees, and normalize the diff's path headers to `csharp/<path>` so it applies under the same `-p1` convention.
+
+### Generator env vars are passed per-call, never set at module level
+
+`JAVA_OPTS=-Dlog.level=warn` (quiets the generator) is passed as `bash(..., env={"JAVA_OPTS": "-Dlog.level=warn"})` on the two `openapi-generator-cli` calls that need it — bashrun's `env=` overlays the inherited environment for that one child only. A consumer's spec command needing the same gating (e.g. `CODEGEN=1`) carries it in the config's structured `spec_env` key, which rides the same per-call overlay.
+
+### The Unity reference set is coupled to the patched templates
+
+`unity.write_unity_package_metadata` hardcodes the `.asmdef` base references `Newtonsoft.Json / Polly / JsonSubTypes` — exactly the runtime support the patched C# templates emit calls against. They travel with the patches as one unit; a consumer adds project-specific references via `extra_references`, it does not replace the base set.
+
+`BASE_DEPENDENCIES` is the UPM dual of that reference set: the same three libraries as `package.json` dependencies (Newtonsoft as the Unity-blessed `com.unity.nuget.newtonsoft-json`, the others as UnityNuGet `org.nuget.*` identities), as exact versions — UPM's package.json dependencies accept SemVer values only, and the resolver treats a value as a minimum, so consumer manifests carrying newer minors still resolve. It travels with `BASE_REFERENCES` — change one, change the other.
+
+### The csproj ships in the package; MSBuild output is redirected around it
+
+The generated `.csproj` stays inside the UPM package because it is the `dotnet pack` input for the nuget feed. To keep IDE builds from writing `bin/`/`obj/` into the package (Unity errors on the missing `.meta` files, and the npm tarball must not carry build output), `write_unity_package_metadata` writes a `Directory.Build.props` next to it that redirects `BaseIntermediateOutputPath` / `BaseOutputPath` two directories up — outside the package root under every consumption layout (repo checkout → client grouping dir; Unity PackageCache → `Library/`, which the asset importer ignores). The shipped template patch `0008` points the csproj's `DocumentationFile` at `$(BaseOutputPath)` for the same reason; `Directory.Build.props` is imported before the project body, so the property is visible at that evaluation point.
+
+## Release flow
+
+release-devkit's `AGENTS.md` owns the three-workflow contract; this repo follows it unchanged. Repo-specific facts: release-devkit is never a project dependency (this package sits inside release-devkit's transitive dependency graph; a project-level edge is a resolver cycle), and API-breaking changes ship with a manually bumped `major_minor` (patch-auto assumes additive changes).
+
+## See also
+
+- [`bashrun`](https://github.com/outernet-foundation/bashrun) — the subprocess wrapper this package shells out through.

{openapi_client_codegen-0.1.14 → openapi_client_codegen-0.1.15.dev37253060679}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: openapi-client-codegen
-Version: 0.1.14
+Version: 0.1.15.dev37253060679
 Summary: OpenAPI client-generation wrapper: Litestar spec dump, 3.1->3.0 downgrade, patched openapi-generator templates, Unity package metadata
 License-File: LICENSE
 License-File: NOTICE

openapi_client_codegen-0.1.15.dev37253060679/README.md

@@ -0,0 +1,3 @@
+# openapi-client-codegen
+
+Typed API clients (Python `httpx` + Unity-consumable C# `httpclient`) generated from an OpenAPI schema via OpenAPI Generator. Agent-facing documentation lives in [`AGENTS.md`](./AGENTS.md).

{openapi_client_codegen-0.1.14 → openapi_client_codegen-0.1.15.dev37253060679}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openapi-client-codegen"
-version = "0.1.14"
+version = "0.1.15.dev37253060679"
 description = "OpenAPI client-generation wrapper: Litestar spec dump, 3.1->3.0 downgrade, patched openapi-generator templates, Unity package metadata"
 requires-python = ">=3.13"
 dependencies = [

{openapi_client_codegen-0.1.14 → openapi_client_codegen-0.1.15.dev37253060679}/release-devkit.yaml

@@ -1,5 +1,4 @@
-requires: ">=0.1"
-ci_workflow: ci-cd.yml
+ci_workflow: release.yml
 packages:
   openapi-client-codegen:
     path: .

openapi_client_codegen-0.1.14/.github/workflows/ci-cd.yml

@@ -1,98 +0,0 @@
-name: CI/CD
-
-on:
-  workflow_dispatch:
-  push:
-    branches: [main, dev]
-  pull_request:
-    branches: [dev]
-
-# Cancel superseded runs on the same branch, except main — where publish-stable
-# must never die mid-release (overlapping release merges queue instead).
-concurrency:
-  group: ci-${{ github.ref }}
-  cancel-in-progress: ${{ github.ref != 'refs/heads/main' }}
-
-permissions:
-  contents: read
-
-env:
-  RELEASE_DEVKIT_VERSION: 0.1.25
-
-jobs:
-  check:
-    if: github.ref != 'refs/heads/main'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-          fetch-tags: true
-          persist-credentials: false
-      - uses: astral-sh/setup-uv@v7
-        with:
-          enable-cache: true
-      - run: uv run preflight-python
-      - shell: bash
-        run: uvx --from release-devkit==${{ env.RELEASE_DEVKIT_VERSION }} publish-stable --dry-run
-
-  ensure-release-pr:
-    if: github.event_name == 'push' && github.ref == 'refs/heads/dev'
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      pull-requests: write
-    env:
-      GH_TOKEN: ${{ github.token }}
-    steps:
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-          fetch-tags: true
-          persist-credentials: false
-      - uses: astral-sh/setup-uv@v7
-      - shell: bash
-        run: uvx --from release-devkit==${{ env.RELEASE_DEVKIT_VERSION }} ensure-release-pr
-
-  publish-stable:
-    if: github.event_name == 'push' && github.ref == 'refs/heads/main'
-    runs-on: ubuntu-latest
-    environment: release
-    permissions:
-      contents: write
-      id-token: write
-    env:
-      GH_TOKEN: ${{ github.token }}
-    steps:
-      - uses: actions/checkout@v5
-        with:
-          ref: main
-          fetch-depth: 0
-          fetch-tags: true
-      - uses: astral-sh/setup-uv@v7
-      - shell: bash
-        run: uvx --from release-devkit==${{ env.RELEASE_DEVKIT_VERSION }} publish-stable
-        env:
-          NPM_CONFIG_LOGLEVEL: verbose
-
-  publish-dev:
-    if: github.event_name == 'push' && github.ref == 'refs/heads/dev'
-    needs: [check]
-    runs-on: ubuntu-latest
-    environment: release
-    permissions:
-      contents: read
-      id-token: write
-    env:
-      GH_TOKEN: ${{ github.token }}
-    steps:
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0
-          fetch-tags: true
-          persist-credentials: false
-      - uses: astral-sh/setup-uv@v7
-      - shell: bash
-        run: uvx --from release-devkit==${{ env.RELEASE_DEVKIT_VERSION }} publish-dev
-        env:
-          NPM_CONFIG_LOGLEVEL: verbose

openapi_client_codegen-0.1.14/AGENTS.md

@@ -1,60 +0,0 @@
-# openapi-client-codegen
-
-## What this is
-
-`openapi-client-codegen` wraps [OpenAPI Generator](https://openapi-generator.tech/) to turn an OpenAPI schema into typed client packages — a Python (`httpx`) client and a Unity-consumable C# (`httpclient`) client. It owns every step that is generic across consumers: the project orchestration loop, downgrading 3.1→3.0, the committed-spec unchanged skip, authoring and patching the C# templates, running the generator, and writing the Unity package metadata. The caller owns what is inherently project-specific: **producing the OpenAPI spec** (a command string in the consumer's config, run by the library's `SpecProducer`), the project→client mapping, the naming root, the npm scope, license, repository URL, and the generated output root — all as fields of the `ProjectsConfig` model.
-
-The package is `openapi_client_codegen` (src-layout under `src/openapi_client_codegen/`), renamed from `openapi-clientgen` before the first publish (operator, 2026-09-20 — no artifact carries the old name). Its Python dependencies are `bashrun` (the guardrailed subprocess wrapper), `packaging` (PEP 440 specifier parsing for `requires`), `pydantic` (the config schema), `strictyaml` (config loading), and `typer` (the thin CLI), all from PyPI — git-source pins only in scratch branches testing unreleased changes. At **runtime** it also needs **Java (JDK 11+)** and **`uvx`** on PATH — the generator itself runs as `uvx --from 'openapi-generator-cli[jdk4py]==<pin>' ...`.
-
-## Release flow
-
-Publishing rides `ci-cd.yml`, which combines CI and release: `check` runs `preflight-python` from the python-devkit dev dependency then `publish-stable --dry-run` as its trailing step, and the publish jobs (`publish-stable`, `publish-dev`, `ensure-release-pr`) run release-devkit's verbs as inlined `uvx --from release-devkit==${{ env.RELEASE_DEVKIT_VERSION }}` steps, version-pinned in the workflow `env:` (see release-devkit's `AGENTS.md`), never a project dependency (openapi-client-codegen sits inside release-devkit's transitive dependency graph; a project-level edge is a resolver cycle). The dev channel (`publish-dev` on `dev` push, an in-run job gated on `check`) ships immutable `-dev.<run-id>` prereleases; `ensure-release-pr` maintains the standing `dev` → `main` release-PR gate; `publish-stable` runs on `main` push under OIDC trusted publishing (publisher bound to `ci-cd.yml`, `release` environment). The committed `pyproject.toml` version is permanently the `0.0.0.dev0` sentinel; the `openapi-client-codegen-v*` tags are the version ledger (declared `major_minor` line in `release-devkit.yaml`, patch-auto within the line). API-breaking changes ship with a manually bumped `major_minor` — patch-auto assumes additive changes.
-
-## Public API
-
-The package init is empty (RUF067 strict mode — the canonical ruff config bans any content in `__init__.py`); import each symbol from its defining module: `client` (`generate_client`), `cli` (`app`), `downgrade` (`downgrade_openapi_3_1_to_3_0`, `JsonDict`), `orchestrator` (`ProjectsConfig`, `ClientNaming`, `SpecProducer`, `load_config`), `templates` (`regenerate_templates`), `unity` (`write_unity_package_metadata`).
-
-| Symbol | Role |
-|---|---|
-| `downgrade_openapi_3_1_to_3_0(schema)` | In-place 3.1.0→3.0.3 fixup (openapi-generator rejects 3.1). Pure function. |
-| `ProjectsConfig` | The pydantic schema of a consumer's client-generation config (`extra="forbid"`): required `projects`, `root_name`, `generated_root`, `spec_command`, `requires`; optional `spec_env`, `npm_scope`, `license_spdx`, `repository_url`. `requires` is a PEP 440 specifier; `load_config` self-checks the installed version and refuses outside range; the `0.0.0.dev0` sentinel bypasses the *check*, not the field's presence (omission is a validation error; "no constraint" is explicit `requires: ">=0.0"`). The single source of identity — the CLI validates the `--config` file into it and consumes it; nothing overrides it per invocation. |
-| `load_config(path)` | Parse the consumer's root YAML config into a `ProjectsConfig` (strictyaml, scalars as strings) and enforce the required `requires` version self-check. |
-| `SpecProducer(command, env=None)` | Callable class wrapping any command that prints the spec to stdout, run with the project directory as cwd and an optional per-call env overlay; the CLI command builds it from the config's `spec_command` / `spec_env`, and programmatic consumers construct it directly. |
-| `app` | The single-command CLI (invoked directly, no subcommand) behind the `openapi-client-codegen` console script and consumer `[project.scripts]` aliases (e.g. placeframe's `generate-clients`). It validates the `--config` YAML against the `ProjectsConfig` pydantic model (via `load_config`) (`extra="forbid"`: unknown keys rejected — a `ValidationError` propagates) and then runs the whole orchestration itself: per mapping entry (`projects` maps project paths to generator lists), produce the spec via `SpecProducer`, downgrade it, write `<project>/openapi.json` unless byte-identical to the committed spec (`no_cache` forces through), and `generate_client` per listed generator into `<generated_root>/<generator>/<names.base>`. The flags are invocation-scoped only (filters, `--no-cache`, `--check`, `--root`; project paths resolve against `root`). `--check` forces an unconditional regen and fails if any spec or generated client differs from the committed tree — the staleness gate consumers run in CI; the checked paths are fully derived from `ProjectsConfig` (every `<project>/openapi.json` plus `generated_root`), no per-consumer path args. Commands run shell-less (shlex-split, operators rejected), so env gating is the structured `spec_env`, never a `VAR=…` prefix. |
-| `regenerate_templates(target_dir, extra_patches_dir=None)` | Author the C# templates into `target_dir/csharp` and apply the shipped (then optional extra) patches. |
-| `generate_client(spec, generator, output_dir, names, templates_dir=None, extra_references=None, npm_scope=None, license_spdx=None, repository_url=None)` | Run the generator for one `(spec, generator)` and sync the result into `output_dir`. `templates_dir` is required for `csharp`. For csharp, `npm_scope` composes the UPM identity `{scope}.{base-minus-dashes}` (e.g. `org.outernet.placeframe.apiclient`); unset falls back to the legacy `org.nuget.{camel-lower}` identity. `license_spdx` / `repository_url` populate the manifest's `license` / `repository` fields when given. |
-| `write_unity_package_metadata(package_dir, package_name, extra_references=None, npm_name=None, license_spdx=None, repository_url=None)` | Write `package.json` / `.asmdef` / `csc.rsp` / `Directory.Build.props`. Called by `generate_client` for csharp. |
-| `ClientNaming` | The derived per-project package identity: `base` (last path segment + `-client`), `dashed` (`{root_name}-{base}`), `underscored`, `camel`. Constructed inline by the CLI command per project; `DefaultNamingPolicy("placeframe")("docker/api")` semantics live there. |
-
-The CLI command orchestrates the whole run — `regenerate_templates` once, then per project: produce (via the config-built `SpecProducer`) → downgrade → committed-spec skip → per-client generate. The generator version pin and the shipped configs/patches/ignore-file live in `src/openapi_client_codegen/_data/` (paths in `_data.py`).
-
-## Constraints
-
-### The C# template patches are path-generic and repo-independent
-
-The shipped patches (`_data/templates-patches/csharp/00NN-*.patch`) carry generic `a/csharp/<path>` headers, not any consumer's repo layout. `regenerate_templates` applies them with `git apply -p1` and `cwd=target_dir`, which lands them on the freshly-authored tree **without needing a surrounding git repository** — `git apply` patches worktree files fine outside any repo as long as `--index` is not used. Patches apply in filename order (the `00NN` prefix is load-bearing: later patches depend on earlier hunks' context); `extra_patches_dir` patches apply after the shipped set.
-
-To author a new patch: author the raw templates (`openapi-generator-cli author template -g csharp --library httpclient`) into a scratch dir, copy it, edit a `.mustache` in the copy, `git diff --no-index` the two trees, and normalize the diff's path headers to `csharp/<path>` so it applies under the same `-p1` convention.
-
-### Generator env vars are passed per-call, never set at module level
-
-`JAVA_OPTS=-Dlog.level=warn` (quiets the generator) is passed as `bash(..., env={"JAVA_OPTS": "-Dlog.level=warn"})` on the two `openapi-generator-cli` calls that need it, so it reaches only those child processes and never touches this process's `os.environ`. `bashrun`'s `env=` overlays the inherited environment for that one child (see its AGENTS.md), which is the whole point — the alternative, mutating the global `os.environ`, leaks the var into every later subprocess. This covers the generator this package runs itself; a consumer's spec command needing the same gating (e.g. `CODEGEN=1`) carries it in the config's structured `spec_env` key, which rides the same per-call overlay.
-
-### The Unity reference set is coupled to the patched templates
-
-`unity.write_unity_package_metadata` hardcodes the `.asmdef` base references `Newtonsoft.Json / Polly / JsonSubTypes`. These are exactly the runtime support the patched C# templates emit calls against (Polly retry, JsonSubTypes discriminators, Newtonsoft serialization). They travel with the patches as one unit; a consumer adds project-specific references via `extra_references`, it does not replace the base set.
-
-`BASE_DEPENDENCIES` is the UPM dual of that reference set: the same three libraries expressed as `package.json` dependencies (Newtonsoft as the Unity-blessed `com.unity.nuget.newtonsoft-json`, the others as UnityNuGet `org.nuget.*` identities), as exact versions — UPM's package.json dependencies accept SemVer values only, no range syntax, and the resolver treats a value as a minimum, so consumer manifests carrying newer minors still resolve without conflict. It travels with `BASE_REFERENCES` — change one, change the other.
-
-### The csproj ships in the package; MSBuild output is redirected around it
-
-The generated `.csproj` stays inside the UPM package because it is the `dotnet pack` input for the nuget feed. To keep IDE builds from writing `bin/`/`obj/` into the package (Unity errors on the missing `.meta` files, and the npm tarball must not carry build output), `write_unity_package_metadata` writes a `Directory.Build.props` next to it that redirects `BaseIntermediateOutputPath` / `BaseOutputPath` two directories up — outside the package root under every consumption layout (repo checkout → client grouping dir; Unity PackageCache → `Library/`, which the asset importer ignores). The shipped template patch `0008` points the csproj's `DocumentationFile` at `$(BaseOutputPath)` for the same reason; `Directory.Build.props` is imported before the project body, so the property is visible at that evaluation point.
-
-### What the consumer owns
-
-The spec-production command (`spec_command` + optional `spec_env`, required — the package is consumable by projects that use no Python, no uv, or no dump entry point at all; a project whose spec is a committed file needs only `cat openapi.json`), the project→clients mapping, the naming root, the npm scope, license, repository URL, and the generated output root — all fields of the `ProjectsConfig` model, all carried in the consumer's config file, none overridable per invocation. Naming derivation is fixed inside the CLI command (`ClientNaming` built inline per project from the root name and the project's last path segment); a consumer needing different names calls the per-client API directly with its own `ClientNaming`.
-
-## See also
-
-- `README.md` — human-facing setup and usage.
-- [`bashrun`](https://github.com/outernet-foundation/bashrun) — the subprocess wrapper this package shells out through.

openapi_client_codegen-0.1.14/README.md

@@ -1,70 +0,0 @@
-# openapi-client-codegen
-
-Generate typed API clients from an OpenAPI schema. `openapi-client-codegen` wraps [OpenAPI Generator](https://openapi-generator.tech/): it downgrades OpenAPI 3.1→3.0 (the generator only accepts 3.0), authors and patches the C# templates, runs the generator, and writes Unity package metadata. It produces a Python (`httpx`) client and a Unity-consumable C# (`httpclient`) client.
-
-The generic steps live here; the caller supplies the spec-production strategy (any callable from project directory to raw spec JSON — a shell command carried in the CLI config), the project→client mapping, the naming root, the npm scope, license, repository URL, and the output root. See [`AGENTS.md`](./AGENTS.md) for the API surface, the lib-owns/consumer-owns boundary, and the patch mechanism.
-
-## Requirements
-
-- Python 3.13+ and [uv](https://docs.astral.sh/uv/)
-- **Java (JDK 11+)** and **`uvx`** on PATH at runtime — the generator runs as `uvx --from 'openapi-generator-cli[jdk4py]==<pin>' ...`
-
-## CLI
-
-The CLI is the multi-project orchestrator, invoked directly (single command, no subcommand):
-
-```bash
-uv run openapi-client-codegen --config clients.json
-```
-
-`clients.json` carries everything consumer-owned in one place:
-
-```json
-{
-  "projects": {"services/api": ["python", "csharp"]},
-  "root_name": "myproject",
-  "generated_root": "generated",
-  "spec_command": "uv run --project . python -m src.dump_openapi",
-  "spec_env": {"CODEGEN": "1"},
-  "npm_scope": "org.example.myproject",
-  "license_spdx": "Apache-2.0",
-  "repository_url": "https://github.com/org/repo.git"
-}
-```
-
-`spec_command` is a command that prints the project's raw OpenAPI JSON to stdout, run with the project directory as cwd — no shell sits in front of it (commands are shlex-split; operators like `|` are rejected), so env gating rides the structured `spec_env` key, overlaid per call. The config is the single source of identity: `root_name`, `generated_root`, and `spec_command` are required there, and nothing overrides them per invocation — a different identity is a different config file. The remaining flags are invocation-scoped (`--project` / `--client` filters, `--no-cache`, `--root`). The orchestrator downgrades each produced spec, skips generation when the committed `<project>/openapi.json` is byte-identical (`--no-cache` forces through), and syncs each client under `<generated-root>/<generator>/<base-name>`.
-
-To run it as a first-class command in a consumer repo, point a `[project.scripts]` entry at the same app — e.g. `generate-clients = "openapi_client_codegen.cli:app"`.
-
-The same config drives the library API, for in-process consumption from a consumer's own command:
-
-```python
-from pathlib import Path
-
-from openapi_client_codegen.orchestrator import ProjectsConfig, generate_projects
-
-config = ProjectsConfig.model_validate_json(Path("clients.json").read_text(encoding="utf-8"))
-generate_projects(config)
-```
-
-A non-uv project declares its own `spec_command` instead — e.g. `dotnet run -- dump-openapi`; a project whose spec is a committed file uses `cat openapi.json`.
-
-## Consuming from another repo
-
-Install from PyPI:
-
-```toml
-[project]
-dependencies = ["openapi-client-codegen>=0.1.0"]
-```
-
-`bashrun` resolves transitively. At **runtime** the generator also needs Java (JDK 11+) and `uvx` on PATH. To test an unreleased change, pin the repo at a git ref in a scratch branch instead (`openapi-client-codegen = { git = "…", rev = "<sha>" }` under `[tool.uv.sources]`) and drop the pin when the release lands.
-
-## Development
-
-```bash
-uv run ruff check .
-uv run ruff format --check .
-uv run basedpyright
-uv run pytest
-```