openapi-client-codegen 0.1.0__tar.gz → 0.1.2__tar.gz

openapi_client_codegen-0.1.2/.gitattributes

@@ -0,0 +1 @@
+ruff.base.toml -text

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/.github/workflows/ci.yml

@@ -32,6 +32,9 @@ jobs:
       - name: Test
         run: uv run pytest
 
+      - name: Ruff config drift
+        run: uvx --from python-devkit==0.1.3 sync-ruff --check
+
   publish:
     needs: check
     if: github.event_name == 'push' && github.ref == 'refs/heads/main'
@@ -48,4 +51,4 @@ jobs:
       - uses: astral-sh/setup-uv@v7
 
       - name: Publish
-        run: uvx --from git+https://github.com/outernet-foundation/pubpkg.git@ea2ecf35a93a3c6405b9430a651d2a7b3d2faa6c publish-packages --config publish-config.json
+        run: uvx --from release-kit==0.1.0 --with bashrun==0.1.0 publish-packages --config publish-config.json

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/AGENTS.md

@@ -2,7 +2,7 @@
 
 ## 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: downgrading 3.1→3.0, 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** (however its app exposes one), which projects map to which clients, the package-name policy, and the output paths.
+`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** (injected as a required strategy — any callable from project directory to raw spec JSON; the org's uv convention ships as `dump_openapi_spec`), 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/`), 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) and `typer` (the thin CLI), both 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>' ...`.
 
@@ -12,17 +12,20 @@ Publishing rides `ci.yml`'s `publish` job on every push to `main` (gated on the
 
 ## Public API
 
-`__init__` re-exports the surface; import from the package root.
+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`), `downgrade` (`downgrade_openapi_3_1_to_3_0`, `JsonDict`), `naming` (`ClientNaming`, `DefaultNamingPolicy`, `NamingPolicy`), `orchestrator` (`generate_projects`, `dump_openapi_spec`, `SpecProducer`), `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. |
+| `generate_projects(projects, root_name, generated_root, dump_spec, npm_scope=None, license_spdx=None, repository_url=None, project=None, client=None, no_cache=False, root=Path())` | The project orchestrator: per mapping entry (`{project path: [generators]}`), produce the spec via the injected `dump_spec` strategy, 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>`. `project` / `client` restrict the run to one entry; `root` is what project paths resolve against. |
+| `SpecProducer(command)` | Callable class wrapping any shell command that prints the spec to stdout, run with the project directory as cwd; the CLI `--spec-command` bridge. The strategy contract itself is untyped vocabulary — any `Callable[[Path], str]` (project directory in, raw OpenAPI JSON out) satisfies `dump_spec`. |
+| `dump_openapi_spec(project)` | The org strategy: `uv run --project . python -m src.dump_openapi` with `CODEGEN=1` gating heavy imports (per-call env overlay). Shipped as the exemplar — `dump_spec` is required, so every consumer names its strategy explicitly. |
 | `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. |
 | `DefaultNamingPolicy(root_name)` / `ClientNaming` / `NamingPolicy` | Package-name derivation. `DefaultNamingPolicy("placeframe")("docker/api")` → base `api-client`, dashed `placeframe-api-client`, underscored `placeframe_api_client`, camel `PlaceframeApiClient`. |
 
-A consumer orchestrates: `regenerate_templates(tmp)` once, then per `(project, client)` produce the spec, `downgrade` it, and call `generate_client`. The generator version pin and the shipped configs/patches/ignore-file live in `src/openapi_client_codegen/_data/` (paths in `_data.py`).
+`generate_projects` orchestrates the whole run — `regenerate_templates` once, then per project: produce (via the injected strategy) → downgrade → committed-spec skip → per-client generate. Consumers hand it their parsed mapping, their spec-production strategy, and their identity parameters. The generator version pin and the shipped configs/patches/ignore-file live in `src/openapi_client_codegen/_data/` (paths in `_data.py`).
 
 ## Constraints
 
@@ -34,7 +37,7 @@ To author a new patch: author the raw templates (`openapi-generator-cli author t
 
 ### 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 only the generator this package runs itself; a consumer's spec-production step owns its own environment (e.g. any import-gating flag its services read).
+`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 only the generator this package runs itself. The shipped `dump_openapi_spec` strategy follows the same rule: `CODEGEN=1` (which gates a service's heavy imports so the app imports cleanly for the dump) rides bashrun's per-call env overlay and never touches this process's `os.environ`.
 
 ### The Unity reference set is coupled to the patched templates
 
@@ -48,7 +51,7 @@ The generated `.csproj` stays inside the UPM package because it is the `dotnet p
 
 ### What the consumer owns
 
-The project→clients mapping, the naming policy, and the output paths are the consumer's. This package ships `DefaultNamingPolicy` as a convenience but defines no schema for the mapping file — the consumer iterates its own config and calls the API per entry. `NamingPolicy` is a `Protocol`; a consumer can supply any callable `(project: str) -> ClientNaming`.
+The spec-production strategy (`dump_spec`, required — the package is consumable by projects that use no Python, no uv, or no dump entry point at all; the org's `dump_openapi_spec` ships beside it, and a project whose spec is a committed file needs only a file read), the project→clients mapping (in whatever config shape it likes — the verb takes the parsed mapping, not a file path), the naming root, the npm scope, license, repository URL, and the generated output root. The orchestrator iterates the mapping itself and fixes `DefaultNamingPolicy`; a consumer needing a different policy calls the per-client API directly — `NamingPolicy` is a `Protocol`, any callable `(project: str) -> ClientNaming` works there.
 
 ## See also
 

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: openapi-client-codegen
-Version: 0.1.0
+Version: 0.1.2
 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.2/README.md

@@ -0,0 +1,74 @@
+# 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 — the org's uv convention ships as `dump_openapi_spec`), 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
+
+A thin CLI exposes the OpenAPI 3.1→3.0 downgrade, single-client generation, and the multi-project orchestrator:
+
+```bash
+uv run openapi-client-codegen downgrade path/to/openapi.json            # 3.1→3.0 in place
+uv run openapi-client-codegen downgrade path/to/openapi.json out.json   # write elsewhere
+
+uv run openapi-client-codegen generate path/to/openapi.json generated/csharp/api-client \
+  --root-name myproject --project services/api \
+  --npm-scope org.example.myproject --license-spdx Apache-2.0 \
+  --repository-url https://github.com/org/repo.git
+
+uv run openapi-client-codegen generate-projects clients.json \
+  --spec-command 'uv run --project . python -m src.dump_openapi' \
+  --root-name myproject --generated-root generated \
+  --npm-scope org.example.myproject --license-spdx Apache-2.0 \
+  --repository-url https://github.com/org/repo.git
+```
+
+`clients.json` maps each project path to its client generators (`{"services/api": ["python", "csharp"]}`). `--spec-command` names the strategy: a shell command that prints the project's raw OpenAPI JSON to stdout, run with the project directory as cwd (env prefixes like `CODEGEN=1 …` inline directly). 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>`.
+
+The same surface is the library API, for in-process consumption from a consumer's own command — `dump_spec` is required, so every consumer names its strategy explicitly:
+
+```python
+import json
+from pathlib import Path
+
+from openapi_client_codegen.orchestrator import dump_openapi_spec, generate_projects
+
+projects = json.loads(Path("clients.json").read_text(encoding="utf-8"))
+generate_projects(
+    projects,
+    root_name="myproject",
+    generated_root=Path("generated"),
+    dump_spec=dump_openapi_spec,
+    npm_scope="org.example.myproject",
+    license_spdx="Apache-2.0",
+    repository_url="https://github.com/org/repo.git",
+)
+```
+
+A non-uv project passes its own callable instead — e.g. `dump_spec=lambda project: bash_output("dotnet run -- dump-openapi", cwd=project)`, or a file read for a project whose spec is committed rather than dumped.
+
+## 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
+```

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "openapi-client-codegen"
-version = "0.1.0"
+version = "0.1.2"
 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.2/ruff.base.toml

@@ -0,0 +1,204 @@
+# Org-canonical ruff configuration, hosted in python-devkit.
+# Consuming repos carry this file verbatim as ruff.base.toml, written by the
+# sync-ruff verb (uvx --from python-devkit sync-ruff) and drift-gated in CI.
+# Never edit a synced copy: change this canonical, release python-devkit, and
+# re-run sync-ruff in each consuming repo.
+target-version = "py313"
+line-length = 120
+preview = true
+required-version = ">=0.14.11"
+
+[lint]
+select = ["ALL"]
+ignore = [
+    # ── Temporarily ignored (inline noqas exist for these rules but are redundant
+    # while the rules are globally ignored — RUF100 suppresses the "unused noqa" warning
+    # until we un-ignore each ticket's rules)
+    "RUF100",
+
+    # ── Permanently ignored ──────────────────────────────────────────────
+    # Type annotations — basedpyright strict mode handles this
+    "ANN",
+    # EM101 (string literal in exception) — the msg = ... indirection adds verbosity without benefit
+    "EM101",
+    # TRY003 (raise vanilla args) — requires custom exception class for every raise site;
+    # the real problem (interpolation) is caught by EM102/EM103
+    "TRY003",
+    # A003 (class attribute shadowing) — class attributes via self.x never conflict with builtins
+    "A003",
+    # Function complexity counting — C901 already covers structural complexity;
+    # these counting rules are largely redundant
+    "PLR0911",
+    "PLR0912",
+    "PLR0913",
+    "PLR0914",
+    "PLR0915",
+    "PLR0917",
+
+    # ── Temporarily ignored (will enable when conventions are established) ─
+    # Docstrings — project policy is "no docstrings" for now
+    "D",
+    # Copyright notices — not yet established
+    "CPY",
+    # Docstring formatting — blocked on D
+    "DOC",
+    # TODO/FIXME comment formatting
+    "TD",
+    "FIX",
+
+    # The "Ticket N" blocks below are the transitional cleanup slices tracked
+    # by PLE-248 (Enforce the deferred ruff rules):
+    #   https://linear.app/plerionplatforms/issue/PLE-248
+    # Ticket 3 (T201, print → logging) is tracked by PLE-336:
+    #   https://linear.app/plerionplatforms/issue/PLE-336
+    # Lifting a rule = remove it here in python-devkit's canonical config,
+    # release, and run sync-ruff in every consuming repo.
+
+    # ── Ticket 1: Auto-fix formatting & type modernization ───────────────
+    # Zero risk. Purely mechanical, all auto-fixable via ruff --fix.
+    "COM812",   # missing trailing commas
+    "I001",     # import sorting
+    "ISC003",   # explicit string concatenation
+    "RUF031",   # parenthesized tuple in subscript
+    "TC001",    # move import into TYPE_CHECKING block
+    "TC002",    # move third-party import into TYPE_CHECKING block
+    "TC003",    # move stdlib import into TYPE_CHECKING block
+    "TC006",    # move typing import into TYPE_CHECKING block (PEP 695)
+    "TC008",    # move import into TYPE_CHECKING block (quoted annotation)
+    "UP006",    # use X instead of typing.X
+    "UP007",    # use X | Y instead of Union
+    "UP011",    # unnecessary parentheses to functools.lru_cache
+    "UP015",    # unnecessary open mode parameters
+    "UP017",    # use datetime.UTC alias
+    "UP034",    # extraneous parentheses
+    "UP035",    # deprecated import (use collections.abc, etc.)
+    "UP040",    # use PEP 695 type alias
+    "UP042",    # use PEP 695 type parameters
+    "UP045",    # use X | None instead of Optional
+
+    # ── Ticket 2: Auto-fix code simplifications ──────────────────────────
+    # Very low risk. Auto-fixable with trivial semantic changes.
+    "C401",     # unnecessary generator — use set/dict comprehension
+    "C416",     # unnecessary comprehension — use list/dict
+    "ERA001",   # commented-out code
+    "FURB101",  # read-text can replace open+read
+    "FURB103",  # write-text can replace open+write
+    "FURB110",  # use ternary instead of try/except for default
+    "FURB113",  # use list.extend instead of repeated append
+    "FURB118",  # use operator module instead of lambda
+    "LOG004",   # use __name__ as logger name
+    "PERF401",  # use list comprehension instead of manual append
+    "PIE810",   # unnecessary spread of single-element starred
+    "PLC0207",  # use a single __all__ definition
+    "PLC1901",  # compare to empty string using falsy check
+    "PLR1711",  # useless return at end of function
+    "PLR6104",  # use augmented assignment
+    "PLR6201",  # use a set literal for membership test
+    "PLW1510",  # subprocess.run without explicit check= argument
+    "PLW1514",  # open without explicit encoding
+    "PT001",    # use @pytest.fixture over @pytest.fixture()
+    "PT018",    # composite assertion — split into multiple asserts
+    "PTH101",   # os.chmod → Path.chmod
+    "PTH111",   # os.path.expanduser → Path.expanduser
+    "PTH112",   # os.path.isdir → Path.is_dir
+    "PTH118",   # os.path.join → Path /
+    "PTH123",   # open() → Path.open()
+    "PTH201",   # pathlib.Path(".")
+    "RET501",   # unnecessary explicit return None
+    "RET504",   # unnecessary assignment before return
+    "RET505",   # unnecessary else after return
+    "RET506",   # unnecessary else after raise
+    "RET507",   # unnecessary else after continue
+    "RSE102",   # unnecessary parentheses on raised exception
+    "RUF005",   # consider spread operator instead of concatenation
+    "RUF010",   # use explicit conversion flag in f-string
+    "RUF015",   # prefer next() over single-element slice
+    "RUF029",   # function is declared async but has no await
+    "RUF052",   # local variable is assigned but never used (underscore prefix)
+    "RUF056",   # unnecessary default value for keyword argument
+    "SIM102",   # collapsible if statements
+    "SIM105",   # use contextlib.suppress instead of try/except/pass
+    "SIM115",   # use context manager for opening files
+    "SIM117",   # use single with statement for multiple context managers
+    "SIM118",   # use key in dict instead of key in dict.keys()
+    "TID252",   # prefer absolute imports over relative
+
+    # ── Ticket 3: print → logging ────────────────────────────────────────
+    # All code should use logging, including CLI scripts.
+    "T201",     # print found
+
+    # ── Ticket 4: Exception message interpolation ────────────────────────
+    # Remove f-strings from exception messages — use string literals.
+    "EM102",    # f-string in exception message
+
+    # ── Ticket 5: Missing __init__.py + shebangs ─────────────────────────
+    # Add __init__.py to installable packages; remove vestigial shebangs.
+    "INP001",   # implicit namespace package — add __init__.py
+    "EXE001",   # shebang present but file not executable
+
+    # ── Ticket 6: Type ignore specificity ────────────────────────────────
+    # Replace blanket type: ignore with specific error codes.
+    "PGH003",   # blanket type: ignore
+
+    # ── Ticket 7: Boolean trap refactoring ───────────────────────────────
+    # Change function signatures — callers must update too.
+    "FBT001",   # boolean positional argument
+    "FBT002",   # boolean default value in function definition
+    "FBT003",   # boolean positional value in call
+
+    # ── Ticket 8: Exception handling patterns ────────────────────────────
+    # Behavioral changes to error handling.
+    "B020",     # loop variable overwritten by except
+    "B903",     # generator should use yield from
+    "B904",     # raise without from inside except
+    "B905",     # zip() without strict= parameter
+    "BLE001",   # blind except Exception
+    "S101",     # assert outside tests
+    "TRY002",   # create custom exception class
+    "TRY300",   # try/except/return — move return into else
+
+    # ── Ticket 9: Complexity, naming & refactoring ───────────────────────
+    # Structural changes requiring judgment.
+    "A001",     # builtin shadowing (dir, bytes)
+    "ARG001",   # unused function argument
+    "ARG002",   # unused method argument
+    "C901",     # function too complex
+    "E501",     # line too long
+    "N802",     # function name should be lowercase
+    "N806",     # variable in function should be lowercase
+    "N815",     # mixed-case variable in class scope
+    "N818",     # exception name should end in Error
+    "PLC0415",  # import not at top level
+    "PLE0704",  # bare raise not inside except handler
+    "PLR1702",  # too many nested blocks
+    "PLR2004",  # magic value used in comparison
+    "PLR6301",  # method could be function or static method
+    "PLW0603",  # global statement
+    "PLW2901",  # loop variable overwritten
+    "RUF001",   # ambiguous unicode — replace with ASCII
+    "RUF003",   # ambiguous unicode in comment
+    "S106",     # possible hardcoded password
+    "S108",     # probable insecure temp file/dir usage
+    "S110",     # try/except/pass on broad exception
+    "S202",     # use of tarfile.extractall
+    # S404/S603: prerequisite — bash.py needs env, stderr=STDOUT merge, and no-raise-with-capture
+    # before context_sha.py, deptry_check.py, test_context_sha.py, list_debug_targets.py can migrate
+    "S404",     # suspicious subprocess import
+    "S603",     # subprocess call with non-literal
+    "S606",     # starting process without shell
+    "S607",     # starting process with partial path
+]
+
+[lint.per-file-ignores]
+# Tests use assert as the standard pytest mechanism; fixtures take arguments
+# that pytest consumes implicitly; pytest-style test classes need no self use
+"**/tests/**" = ["S101", "ARG001", "ARG002", "PLR6301"]
+
+[lint.ruff]
+# RUF067 in strict mode: __init__.py files must be empty — no re-exports, no
+# side effects. Consumers import submodule paths (from pkg.mod import thing);
+# the package layout is the public surface.
+strictly-empty-init-modules = true
+
+[lint.flake8-builtins]
+ignorelist = ["id", "map"]

openapi_client_codegen-0.1.2/ruff.toml

@@ -0,0 +1 @@
+extend = "ruff.base.toml"

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/src/openapi_client_codegen/cli.py

@@ -8,6 +8,7 @@ from typer import Argument, Option, Typer
 from .client import generate_client
 from .downgrade import downgrade_openapi_3_1_to_3_0
 from .naming import DefaultNamingPolicy
+from .orchestrator import SpecProducer, generate_projects
 from .templates import regenerate_templates
 
 app = Typer(pretty_exceptions_show_locals=False)
@@ -51,3 +52,40 @@ def generate(
             license_spdx=license_spdx,
             repository_url=repository_url,
         )
+
+
+@app.command("generate-projects")
+def generate_projects_command(
+    config: Annotated[Path, Option(help="JSON file mapping project paths to client generator lists")],
+    root_name: Annotated[str, Option(help="Root name handed to DefaultNamingPolicy")],
+    generated_root: Annotated[Path, Option(help="Root directory the generated clients sync into")],
+    spec_command: Annotated[
+        str,
+        Option(
+            help="Shell command printing the project's raw OpenAPI JSON to stdout; runs with the project directory as cwd"
+        ),
+    ],
+    npm_scope: Annotated[str | None, Option(help="npm scope composing the UPM package identity")] = None,
+    license_spdx: Annotated[str | None, Option(help="SPDX license id written to package.json")] = None,
+    repository_url: Annotated[str | None, Option(help="git repository URL written to package.json")] = None,
+    project: Annotated[str | None, Option(help="Generate only this project, as keyed in the config")] = None,
+    client: Annotated[str | None, Option(help="Generate only this client generator")] = None,
+    no_cache: Annotated[
+        bool, Option("--no-cache", help="Regenerate even when the committed spec is unchanged")
+    ] = False,
+    root: Annotated[Path, Option(help="Repository root the project paths resolve against")] = Path(),
+) -> None:
+    projects: dict[str, list[str]] = json.loads(config.read_text(encoding="utf-8"))
+    generate_projects(
+        projects,
+        root_name=root_name,
+        generated_root=generated_root,
+        dump_spec=SpecProducer(spec_command),
+        npm_scope=npm_scope,
+        license_spdx=license_spdx,
+        repository_url=repository_url,
+        project=project,
+        client=client,
+        no_cache=no_cache,
+        root=root,
+    )

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/src/openapi_client_codegen/client.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from shutil import copytree
 from tempfile import NamedTemporaryFile, TemporaryDirectory
 
-from bashrun import bash
+from bashrun.bash import bash
 
 from .resources import CONFIGS_DIR, IGNORE_FILE, OPENAPI_GENERATOR_CLI_VERSION
 from .naming import ClientNaming

openapi_client_codegen-0.1.2/src/openapi_client_codegen/orchestrator.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Callable
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from bashrun.bash import bash_output
+
+from .client import generate_client
+from .downgrade import downgrade_openapi_3_1_to_3_0
+from .naming import DefaultNamingPolicy
+from .templates import regenerate_templates
+
+
+class SpecProducer:
+    def __init__(self, command: str) -> None:
+        self.command = command
+
+    def __call__(self, project: Path) -> str:
+        return bash_output(self.command, cwd=project)
+
+
+def generate_projects(
+    projects: dict[str, list[str]],
+    root_name: str,
+    generated_root: Path,
+    dump_spec: Callable[[Path], str],
+    npm_scope: str | None = None,
+    license_spdx: str | None = None,
+    repository_url: str | None = None,
+    project: str | None = None,
+    client: str | None = None,
+    no_cache: bool = False,
+    root: Path = Path(),
+) -> None:
+    root = root.resolve()
+    naming = DefaultNamingPolicy(root_name)
+
+    with TemporaryDirectory() as templates_directory_string:
+        templates_directory = Path(templates_directory_string)
+        regenerate_templates(templates_directory)
+
+        for project_name, clients in projects.items():
+            if project is not None and project != project_name:
+                continue
+
+            openapi_spec = _produce_and_cache_spec(root / project_name, dump_spec, no_cache)
+
+            if openapi_spec is None:
+                continue
+
+            names = naming(project_name)
+
+            for client_name in clients:
+                if client is not None and client_name != client:
+                    continue
+
+                generate_client(
+                    openapi_spec,
+                    client_name,
+                    generated_root / client_name / names.base,
+                    names,
+                    templates_dir=templates_directory,
+                    npm_scope=npm_scope,
+                    license_spdx=license_spdx,
+                    repository_url=repository_url,
+                )
+
+
+def dump_openapi_spec(project: Path) -> str:
+    # CODEGEN=1 gates a service package's heavy imports so the app imports cleanly for the spec
+    # dump; it reaches the child through bashrun's per-call env overlay.
+    return bash_output("uv run --project . python -m src.dump_openapi", cwd=project, env={"CODEGEN": "1"})
+
+
+def _produce_and_cache_spec(project: Path, dump_spec: Callable[[Path], str], no_cache: bool) -> str | None:
+    print(f"Producing OpenAPI spec for project: {project}")
+
+    openapi_json = json.loads(dump_spec(project))
+    downgrade_openapi_3_1_to_3_0(openapi_json)
+    openapi_spec = json.dumps(openapi_json, indent=2)
+
+    spec_path = project / "openapi.json"
+
+    if spec_path.exists():
+        old_spec = spec_path.read_text(encoding="utf-8")
+
+        if openapi_spec == old_spec and not no_cache:
+            print("OpenAPI spec unchanged, skipping client generation")
+            return None
+
+    spec_path.write_text(openapi_spec, encoding="utf-8")
+
+    return openapi_spec

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/src/openapi_client_codegen/templates.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from bashrun import bash
+from bashrun.bash import bash
 
 from .resources import OPENAPI_GENERATOR_CLI_VERSION, SHIPPED_PATCHES_DIR
 

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/tests/test_downgrade.py

@@ -1,6 +1,6 @@
 from typing import Any
 
-from openapi_client_codegen import downgrade_openapi_3_1_to_3_0
+from openapi_client_codegen.downgrade import downgrade_openapi_3_1_to_3_0
 
 
 def test_bumps_version():

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/tests/test_naming.py

@@ -1,4 +1,4 @@
-from openapi_client_codegen import DefaultNamingPolicy
+from openapi_client_codegen.naming import DefaultNamingPolicy
 
 
 def test_default_naming_derives_all_variants():

openapi_client_codegen-0.1.2/tests/test_orchestrate.py

@@ -0,0 +1,157 @@
+import copy
+import json
+from collections.abc import Callable
+from pathlib import Path
+
+import pytest
+
+from openapi_client_codegen import orchestrator
+from openapi_client_codegen.downgrade import JsonDict, downgrade_openapi_3_1_to_3_0
+from openapi_client_codegen.naming import ClientNaming
+from openapi_client_codegen.orchestrator import SpecProducer, dump_openapi_spec, generate_projects
+
+RAW_SCHEMA: JsonDict = {"openapi": "3.1.0", "info": {"title": "demo", "version": "0.0.0"}, "paths": {}}
+
+
+class Recorder:
+    def __init__(self) -> None:
+        self.generated: list[tuple[str, Path, ClientNaming]] = []
+        self.dumps: list[Path | None] = []
+        self.commands: list[tuple[str, Path | None, dict[str, str] | None]] = []
+
+    def fake_dump_spec(self, project: Path) -> str:
+        self.dumps.append(project)
+        return json.dumps(RAW_SCHEMA)
+
+    def fake_bash_output(self, command: str, *, cwd: Path | None = None, env: dict[str, str] | None = None) -> str:
+        self.commands.append((command, cwd, env))
+        return json.dumps(RAW_SCHEMA)
+
+    def fake_regenerate_templates(self, target_dir: Path, extra_patches_dir: Path | None = None) -> None:
+        pass
+
+    def fake_generate_client(
+        self,
+        spec: str,
+        generator: str,
+        output_dir: Path,
+        names: ClientNaming,
+        templates_dir: Path | None = None,
+        extra_references: list[str] | None = None,
+        npm_scope: str | None = None,
+        license_spdx: str | None = None,
+        repository_url: str | None = None,
+    ) -> None:
+        self.generated.append((generator, output_dir, names))
+
+
+@pytest.fixture
+def recorder(monkeypatch: pytest.MonkeyPatch) -> Recorder:
+    recorder = Recorder()
+    monkeypatch.setattr(orchestrator, "bash_output", recorder.fake_bash_output)
+    monkeypatch.setattr(orchestrator, "regenerate_templates", recorder.fake_regenerate_templates)
+    monkeypatch.setattr(orchestrator, "generate_client", recorder.fake_generate_client)
+    return recorder
+
+
+def downgraded_spec() -> str:
+    schema = copy.deepcopy(RAW_SCHEMA)
+    downgrade_openapi_3_1_to_3_0(schema)
+    return json.dumps(schema, indent=2)
+
+
+def make_project(root: Path, name: str) -> Path:
+    project = root / name
+    project.mkdir(parents=True)
+    return project
+
+
+def test_generates_all_clients_and_writes_downgraded_spec(tmp_path: Path, recorder: Recorder) -> None:
+    make_project(tmp_path, "docker/api")
+
+    generate_projects(
+        {"docker/api": ["python", "csharp"]},
+        "placeframe",
+        tmp_path / "generated",
+        recorder.fake_dump_spec,
+        root=tmp_path,
+    )
+
+    assert [(generator, output_dir.name) for generator, output_dir, _ in recorder.generated] == [
+        ("python", "api-client"),
+        ("csharp", "api-client"),
+    ]
+    assert all(output_dir.parent.parent == tmp_path / "generated" for _, output_dir, _ in recorder.generated)
+
+    written = (tmp_path / "docker" / "api" / "openapi.json").read_text(encoding="utf-8")
+    assert written == downgraded_spec()
+    assert json.loads(written)["openapi"] == "3.0.3"
+
+    assert recorder.dumps == [tmp_path.resolve() / "docker" / "api"]
+
+
+def test_skips_generation_when_committed_spec_unchanged(tmp_path: Path, recorder: Recorder) -> None:
+    project = make_project(tmp_path, "docker/api")
+    (project / "openapi.json").write_text(downgraded_spec(), encoding="utf-8")
+
+    generate_projects(
+        {"docker/api": ["python"]}, "placeframe", tmp_path / "generated", recorder.fake_dump_spec, root=tmp_path
+    )
+
+    assert recorder.generated == []
+
+
+def test_no_cache_forces_generation_despite_unchanged_spec(tmp_path: Path, recorder: Recorder) -> None:
+    project = make_project(tmp_path, "docker/api")
+    (project / "openapi.json").write_text(downgraded_spec(), encoding="utf-8")
+
+    generate_projects(
+        {"docker/api": ["python"]},
+        "placeframe",
+        tmp_path / "generated",
+        recorder.fake_dump_spec,
+        no_cache=True,
+        root=tmp_path,
+    )
+
+    assert len(recorder.generated) == 1
+
+
+def test_project_and_client_filters(tmp_path: Path, recorder: Recorder) -> None:
+    make_project(tmp_path, "docker/api")
+    make_project(tmp_path, "docker/localizer")
+
+    generate_projects(
+        {"docker/api": ["python", "csharp"], "docker/localizer": ["python"]},
+        "placeframe",
+        tmp_path / "generated",
+        recorder.fake_dump_spec,
+        project="docker/api",
+        client="csharp",
+        root=tmp_path,
+    )
+
+    assert len(recorder.generated) == 1
+    generator, output_dir, names = recorder.generated[0]
+    assert generator == "csharp"
+    assert output_dir == tmp_path / "generated" / "csharp" / "api-client"
+    assert names.dashed == "placeframe-api-client"
+
+
+def test_dump_openapi_spec_pins_the_org_convention(recorder: Recorder) -> None:
+    dump_openapi_spec(Path("docker/api"))
+
+    assert len(recorder.commands) == 1
+    command, cwd, env = recorder.commands[0]
+    assert command == "uv run --project . python -m src.dump_openapi"
+    assert cwd == Path("docker/api")
+    assert env == {"CODEGEN": "1"}
+
+
+def test_command_spec_producer_runs_with_project_cwd(recorder: Recorder) -> None:
+    producer: Callable[[Path], str] = SpecProducer("dotnet run -- dump-openapi")
+
+    produced = producer(Path("services/api"))
+
+    assert json.loads(produced) == RAW_SCHEMA
+    assert recorder.commands == [("dotnet run -- dump-openapi", Path("services/api"), None)]

{openapi_client_codegen-0.1.0 → openapi_client_codegen-0.1.2}/tests/test_unity.py

@@ -1,7 +1,7 @@
 import json
 from pathlib import Path
 
-from openapi_client_codegen import write_unity_package_metadata
+from openapi_client_codegen.unity import write_unity_package_metadata
 
 
 def write_package(

openapi_client_codegen-0.1.0/README.md

@@ -1,73 +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 OpenAPI spec, the project→client mapping, the package-name policy, and the output paths. 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
-
-A thin CLI exposes the OpenAPI 3.1→3.0 downgrade and single-client generation:
-
-```bash
-uv run openapi-client-codegen downgrade path/to/openapi.json            # 3.1→3.0 in place
-uv run openapi-client-codegen downgrade path/to/openapi.json out.json   # write elsewhere
-
-uv run openapi-client-codegen generate path/to/openapi.json generated/csharp/api-client \
-  --root-name myproject --project services/api \
-  --npm-scope org.example.myproject --license-spdx Apache-2.0 \
-  --repository-url https://github.com/org/repo.git
-```
-
-Client generation itself is driven from Python (it needs the consumer's project map, naming policy, and output paths):
-
-```python
-import json
-import tempfile
-from pathlib import Path
-
-from openapi_client_codegen import (
-    DefaultNamingPolicy,
-    downgrade_openapi_3_1_to_3_0,
-    generate_client,
-    regenerate_templates,
-)
-
-naming = DefaultNamingPolicy("myproject")
-templates_dir = Path(tempfile.mkdtemp())
-regenerate_templates(templates_dir)
-
-# Produce the raw OpenAPI JSON however your app exposes it, then downgrade it.
-schema = json.loads(my_openapi_spec_json())
-downgrade_openapi_3_1_to_3_0(schema)
-spec = json.dumps(schema, indent=2)
-
-generate_client(spec, "python", Path("generated/python/api-client"), naming("services/api"))
-generate_client(
-    spec, "csharp", Path("generated/csharp/api-client"), naming("services/api"), templates_dir=templates_dir
-)
-```
-
-## 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
-```

openapi_client_codegen-0.1.0/ruff.toml

@@ -1,71 +0,0 @@
-target-version = "py313"
-line-length = 120
-preview = true
-
-[lint]
-select = ["ALL"]
-ignore = [
-    # ── Permanent ─────────────────────────────────────────────────────────
-    # Type annotations — basedpyright strict mode handles this
-    "ANN",
-    # No docstrings, no copyright headers
-    "D",
-    "DOC",
-    "CPY",
-    # TODO/FIXME comment formatting
-    "TD",
-    "FIX",
-    # Exception message ergonomics — literal-indirection and custom-class churn without benefit
-    "EM101",
-    "EM102",
-    "TRY003",
-    # Class attribute names never conflict with builtins via self.x
-    "A003",
-    # Function-size counters — C901 already covers structural complexity
-    "PLR0911",
-    "PLR0912",
-    "PLR0913",
-    "PLR0914",
-    "PLR0915",
-    "PLR0917",
-    # Typer's Option/Argument in argument defaults is its standard API pattern
-    "B008",
-    # Boolean parameters read fine as keyword-only flags here
-    "FBT001",
-    "FBT002",
-    "FBT003",
-    # Relative imports are the intra-package convention
-    "TID252",
-    # Formatter-owned; enforced by `ruff format`
-    "COM812",
-    "I001",
-    # Magic values in comparisons are readable in this CLI
-    "PLR2004",
-    # The formatter owns wrapping; long string literals and URLs stay on one line
-    "E501",
-    # src-layout tests need no __init__.py
-    "INP001",
-    # Runtime-used typing imports stay at module level
-    "TC001",
-    "TC002",
-    "TC003",
-    # Small literal tuples read fine in membership tests
-    "PLR6201",
-
-    # ── Deferred to PLE-248 — Enforce the deferred ruff rules
-    # https://linear.app/plerionplatforms/issue/PLE-248
-    # Mirrors placeframe's root ruff.toml transitional Ticket-N blocks; lifting
-    # a rule here should happen alongside lifting it from placeframe's ruff.toml.
-    "C901",     # function too complex — Ticket 9
-    "PLR1702",  # too many nested blocks — Ticket 9
-
-    # ── Deferred to PLE-336 — Replace print() with structured logging
-    # https://linear.app/plerionplatforms/issue/PLE-336
-    "T201",     # print found
-]
-
-[lint.per-file-ignores]
-"tests/**" = ["S101", "S404", "S607", "PLR6301"]
-
-[lint.flake8-builtins]
-ignorelist = ["id", "map"]

openapi_client_codegen-0.1.0/src/openapi_client_codegen/__init__.py

@@ -1,15 +0,0 @@
-from .client import generate_client
-from .downgrade import downgrade_openapi_3_1_to_3_0
-from .naming import ClientNaming, DefaultNamingPolicy, NamingPolicy
-from .templates import regenerate_templates
-from .unity import write_unity_package_metadata
-
-__all__ = [
-    "ClientNaming",
-    "DefaultNamingPolicy",
-    "NamingPolicy",
-    "downgrade_openapi_3_1_to_3_0",
-    "generate_client",
-    "regenerate_templates",
-    "write_unity_package_metadata",
-]