Update docs and remove irrelevant hook and conform to ruff

Author: SamuelMarks

PUBLISH_OUTPUT.md

@@ -1,9 +1,9 @@
 # Publishing the Output (Generated SDK)
 
-When you generate a client SDK using `cdd-python from_openapi to_sdk`, the generated directory will contain a `pyproject.toml` and GitHub Actions workflow.
+When you generate a client SDK using `cdd-python-all from_openapi to_sdk`, the generated directory will contain a `pyproject.toml` and GitHub Actions workflow.
 
 To automate SDK updates:
 1. Schedule a GitHub Action to fetch the latest OpenAPI spec (e.g., via cron).
-2. Run `cdd-python from_openapi to_sdk` on the fetched spec.
-3. Compare `client.py` using `git status`. If changed, commit and bump the version in `pyproject.toml`.
+2. Run `cdd-python-all from_openapi to_sdk` on the fetched spec.
+3. Compare `src/client.py` using `git status`. If changed, commit and bump the version in `pyproject.toml`.
 4. Run `python3 -m build` and upload to PyPI or your internal package registry.

README.md

@@ -1,25 +1,46 @@
 # Usage
 
-The `cdd-python` CLI can be used in two main modes:
+The `cdd-python-all` (also installed as `cdd-python`) CLI and `openapi_client` Python SDK provide lossless, bidirectional compilation between OpenAPI 3.2.0 / Swagger 2.0 / Arazzo 1.1.0 specifications and Python source code.
 
-1. **from_openapi**: Generate Python SDK or server mock from OpenAPI JSON.
+## CLI Modes
+
+1. **`from_openapi`**: Generate a Python Client SDK (`to_sdk`), Client CLI (`to_sdk_cli`), or FastAPI + SQLAlchemy Server (`to_server`) from an OpenAPI JSON file (`-i`) or directory (`-d`).
 ```bash
-cdd-python from_openapi to_sdk -i openapi.json -o my_client
+cdd-python-all from_openapi to_sdk -i openapi.json -o my_client --tests
+cdd-python-all from_openapi to_sdk_cli -i openapi.json -o my_cli --tests --mcp
+cdd-python-all from_openapi to_server -i openapi.json -o my_server --tests --arazzo arazzo.json
 ```
 
-2. **to_openapi**: Extract OpenAPI JSON from Python code.
+2. **`to_openapi`**: Statically extract an OpenAPI 3.2.0 JSON specification from a Python file or project directory.
 ```bash
-cdd-python to_openapi -f my_client/client.py -o openapi.json
+cdd-python-all to_openapi -i my_client -o openapi.json
 ```
 
-3. **from_arazzo**: Generate Python workflow orchestrators, CLI runners, FastAPI workflow routes, or E2E pytest suites from Arazzo 1.1.0 JSON.
+3. **`from_arazzo`**: Generate Python workflow orchestrators (`to_sdk`), CLI workflow runners (`to_sdk_cli`), FastAPI workflow routes (`to_server`), or standalone E2E pytest suites (`to_tests`) from an Arazzo 1.1.0 JSON specification.
 ```bash
-cdd-python from_arazzo to_sdk -i arazzo.json -o my_workflows
+cdd-python-all from_arazzo to_sdk -i arazzo.json -o my_workflows --tests
+cdd-python-all from_arazzo to_sdk_cli -i arazzo.json -o my_workflows_cli --tests
+cdd-python-all from_arazzo to_server -i arazzo.json -o my_server --tests
+cdd-python-all from_arazzo to_tests -i arazzo.json -o my_workflows
 ```
 
-4. **to_arazzo**: Extract Arazzo 1.1.0 JSON from Python workflow code (`workflows.py`, `cli_workflows.py`, `routes/workflows.py`, or `test_workflows.py`).
+4. **`to_arazzo`**: Extract an Arazzo 1.1.0 JSON specification from Python workflow code (`workflows.py`, `cli_workflows.py`, `routes/workflows.py`, or `test_workflows.py`) or a project directory.
 ```bash
-cdd-python to_arazzo -f my_workflows/src/workflows.py -o arazzo.json
+cdd-python-all to_arazzo -i my_workflows/src/workflows.py -o arazzo.json
 ```
 
-It can also sync directories (`--truth arazzo` or `--truth openapi`), generate docs, or serve a JSON-RPC / MCP interface.
+5. **`sync`**: Synchronize a directory containing `client.py`, `models.py`, `mock_server.py`, `test_client.py`, `cli_main.py`, `workflows.py`, `openapi.json`, and `arazzo.json` with a configurable source of truth (`class`, `sqlalchemy`, `function`, `openapi`, `arazzo`, or `workflow`).
+```bash
+cdd-python-all sync -i my_client --truth openapi
+```
+
+6. **`to_docs_json`**: Generate documentation-ready Python code snippets JSON from an OpenAPI or Arazzo specification.
+```bash
+cdd-python-all to_docs_json --no-imports --no-wrapping -i openapi.json -o docs.json
+```
+
+7. **`serve_json_rpc` & `mcp`**: Expose the compiler over a JSON-RPC 2.0 HTTP server or a Model Context Protocol (`stdio`) server.
+```bash
+cdd-python-all serve_json_rpc --port 8080 --listen 127.0.0.1
+cdd-python-all mcp
+```

USAGE.md

@@ -187,7 +187,9 @@ def main() -> None:
         finally:
             if container_name:
                 subprocess.run(
-                    ["docker", "rm", "-f", container_name], capture_output=True
+                    ["docker", "rm", "-f", container_name],
+                    check=False,
+                    capture_output=True,
                 )
 
     finally:

scripts/run_generated_server_test.py

@@ -40,6 +40,7 @@ def main() -> None:
     print("Running tests and calculating coverage...")
     test_result = subprocess.run(
         ["pytest", "tests/", "--cov=src/openapi_client", "--cov-report=term"],
+        check=False,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         text=True,
@@ -57,6 +58,7 @@ def main() -> None:
     print("Running interrogate for doc coverage...")
     doc_result = subprocess.run(
         ["interrogate", "--fail-under=0", "src/openapi_client"],
+        check=False,
         stdout=subprocess.PIPE,
         stderr=subprocess.STDOUT,
         text=True,

scripts/run_petstore_test.py

@@ -107,7 +107,7 @@ def generate_docs_json(
         no_wrapping: If True, omit `main()` wrapper from generated snippets.
         output_file: Optional file path to write JSON output; prints to stdout if None.
     """
-    if input_path.startswith("http://") or input_path.startswith("https://"):
+    if input_path.startswith(("http://", "https://")):
         req = urllib.request.Request(input_path)
         with urllib.request.urlopen(req) as response:
             content = response.read().decode("utf-8")
@@ -1069,7 +1069,7 @@ def send_response(
                             "content": [{"type": "text", "text": buffer.getvalue()}]
                         },
                     )
-                except Exception as e:
+                except Exception as e:  # noqa: BLE001
                     send_response(
                         req_id,
                         result={
@@ -1082,7 +1082,7 @@ def send_response(
                     send_response(
                         req_id, error={"code": -32601, "message": "Method not found"}
                     )
-        except Exception as e:
+        except Exception as e:  # noqa: BLE001
             if "req_id" in locals() and req_id is not None:
                 send_response(req_id, error={"code": -32603, "message": str(e)})
 
@@ -1173,7 +1173,7 @@ def do_POST(self) -> None:
                     result = "Success"
                 else:
                     error = {"code": -32601, "message": "Method not found"}
-            except Exception as e:
+            except Exception as e:  # noqa: BLE001
                 error = {
                     "code": -32000,
                     "message": str(e),

scripts/update_badges.py

@@ -36,7 +36,7 @@ def visit_Call(self, node: cst.Call) -> None:
 
                 found = False
                 if self.spec.paths:
-                    for _path, path_item in self.spec.paths.items():
+                    for path_item in self.spec.paths.values():
                         for method in ["get", "post", "put", "delete", "patch"]:
                             op = getattr(path_item, method, None)
                             if op and op.operationId == op_id:
@@ -56,27 +56,25 @@ def visit_Call(self, node: cst.Call) -> None:
         elif (
             isinstance(node.func, cst.Attribute)
             and node.func.attr.value == "add_argument"
+            and self.current_op
+            and node.args
+            and isinstance(node.args[0].value, cst.SimpleString)
         ):
-            if (
-                self.current_op
-                and node.args
-                and isinstance(node.args[0].value, cst.SimpleString)
-            ):
-                arg_name = node.args[0].value.value.strip("\"'")
-                if arg_name.startswith("--"):
-                    p_name = arg_name[2:]
-
-                    p_desc = ""
-                    for arg in node.args:
-                        if getattr(arg.keyword, "value", None) == "help" and isinstance(
-                            arg.value, cst.SimpleString
-                        ):
-                            p_desc = arg.value.value.strip("\"'")
-
-                    if self.current_op.parameters:
-                        for p in self.current_op.parameters:
-                            if getattr(p, "name", "").replace("-", "_") == p_name:
-                                p.description = p_desc
+            arg_name = node.args[0].value.value.strip("\"'")
+            if arg_name.startswith("--"):
+                p_name = arg_name[2:]
+
+                p_desc = ""
+                for arg in node.args:
+                    if getattr(arg.keyword, "value", None) == "help" and isinstance(
+                        arg.value, cst.SimpleString
+                    ):
+                        p_desc = arg.value.value.strip("\"'")
+
+                if self.current_op.parameters:
+                    for p in self.current_op.parameters:
+                        if getattr(p, "name", "").replace("-", "_") == p_name:
+                            p.description = p_desc
 
 
 def extract_cli_from_ast(module: cst.Module, spec: OpenAPI) -> None:

src/openapi_client/cli.py

@@ -18,19 +18,18 @@ def parse_docstring(
     Returns:
         A tuple of `(summary, description)`, where either element may be None.
     """
-    if isinstance(node.body, cst.IndentedBlock):
-        if node.body.body:
-            first_stmt = node.body.body[0]
-            if isinstance(first_stmt, cst.SimpleStatementLine) and first_stmt.body:
-                first_expr = first_stmt.body[0]
-                if isinstance(first_expr, cst.Expr) and isinstance(
-                    first_expr.value, cst.SimpleString
-                ):
-                    doc_val = first_expr.value.evaluated_value
-                    if doc_val:
-                        doc_str = str(doc_val).strip("'\"").strip()
-                        parts = re.split(r"\n\s*\n", doc_str, maxsplit=1)
-                        summary = parts[0].strip() if parts else None
-                        description = parts[1].strip() if len(parts) > 1 else None
-                        return summary, description
+    if isinstance(node.body, cst.IndentedBlock) and node.body.body:
+        first_stmt = node.body.body[0]
+        if isinstance(first_stmt, cst.SimpleStatementLine) and first_stmt.body:
+            first_expr = first_stmt.body[0]
+            if isinstance(first_expr, cst.Expr) and isinstance(
+                first_expr.value, cst.SimpleString
+            ):
+                doc_val = first_expr.value.evaluated_value
+                if doc_val:
+                    doc_str = str(doc_val).strip("'\"").strip()
+                    parts = re.split(r"\n\s*\n", doc_str, maxsplit=1)
+                    summary = parts[0].strip() if parts else None
+                    description = parts[1].strip() if len(parts) > 1 else None
+                    return summary, description
     return None, None

src/openapi_client/cli_sdk/parse.py

@@ -26,37 +26,33 @@ def visit_FunctionDef(self, node: cst.FunctionDef) -> None:
             node: The LibCST FunctionDef node being visited.
         """
         for decorator in node.decorators:
-            if isinstance(decorator.decorator, cst.Call):
-                if isinstance(decorator.decorator.func, cst.Attribute):
-                    if isinstance(
-                        decorator.decorator.func.value, cst.Name
-                    ) and decorator.decorator.func.value.value in ("app", "router"):
-                        method = decorator.decorator.func.attr.value
-                        if method in ["get", "post", "put", "delete", "patch"]:
-                            if decorator.decorator.args and isinstance(
-                                decorator.decorator.args[0].value, cst.SimpleString
-                            ):
-                                path = decorator.decorator.args[0].value.value.strip(
-                                    "\"'"
-                                )
+            if (
+                isinstance(decorator.decorator, cst.Call)
+                and isinstance(decorator.decorator.func, cst.Attribute)
+                and isinstance(decorator.decorator.func.value, cst.Name)
+                and decorator.decorator.func.value.value in ("app", "router")
+            ):
+                method = decorator.decorator.func.attr.value
+                if (
+                    method in ["get", "post", "put", "delete", "patch"]
+                    and decorator.decorator.args
+                    and isinstance(decorator.decorator.args[0].value, cst.SimpleString)
+                ):
+                    path = decorator.decorator.args[0].value.value.strip("\"'")
 
-                                if not self.spec.paths:
-                                    self.spec.paths = {}
-                                if path not in self.spec.paths:
-                                    self.spec.paths[path] = PathItem()
+                    if not self.spec.paths:
+                        self.spec.paths = {}
+                    if path not in self.spec.paths:
+                        self.spec.paths[path] = PathItem()
 
-                                summary, description = parse_docstring(node)
-                                op = Operation(
-                                    operationId=node.name.value,
-                                    summary=summary,
-                                    description=description,
-                                    responses={
-                                        "200": Response(
-                                            description="Successful Response"
-                                        )
-                                    },
-                                )
-                                setattr(self.spec.paths[path], method, op)
+                    summary, description = parse_docstring(node)
+                    op = Operation(
+                        operationId=node.name.value,
+                        summary=summary,
+                        description=description,
+                        responses={"200": Response(description="Successful Response")},
+                    )
+                    setattr(self.spec.paths[path], method, op)
 
 
 def extract_fastapi_from_ast(module: cst.Module, spec: OpenAPI) -> None: