oed-cli 0.1.0__tar.gz → 0.1.2__tar.gz

{oed_cli-0.1.0/src/oed_cli.egg-info → oed_cli-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oed-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: oed — openEuler Infra command line. Auto-discovered, AI-friendly.
 Author: oed-cli contributors
 License: Apache-2.0
@@ -97,7 +97,7 @@ pip install -e .
 Verify:
 
 ```bash
-oed --version       # → oed, version 0.2.0
+oed --version       # → oed, version 0.1.2
 ```
 
 ---
@@ -248,7 +248,7 @@ invocation. Drop it with `pip uninstall oed-cli` when you're done.
 python -m pytest -q
 ```
 
-39 tests cover v0.1 + v0.2 dispatch, the operation-help cheatsheet,
+41 tests cover v0.1 + v0.2 dispatch, the operation-help cheatsheet,
 per-parameter flag coercion, the `API_`-prefix alias, the
 `resolve_runtime_gateway` no-fallback semantics, and every exit code path.
 They monkeypatch the discovery layer so no gateway access is needed.

{oed_cli-0.1.0 → oed_cli-0.1.2}/README.md

@@ -63,7 +63,7 @@ pip install -e .
 Verify:
 
 ```bash
-oed --version       # → oed, version 0.2.0
+oed --version       # → oed, version 0.1.2
 ```
 
 ---
@@ -214,7 +214,7 @@ invocation. Drop it with `pip uninstall oed-cli` when you're done.
 python -m pytest -q
 ```
 
-39 tests cover v0.1 + v0.2 dispatch, the operation-help cheatsheet,
+41 tests cover v0.1 + v0.2 dispatch, the operation-help cheatsheet,
 per-parameter flag coercion, the `API_`-prefix alias, the
 `resolve_runtime_gateway` no-fallback semantics, and every exit code path.
 They monkeypatch the discovery layer so no gateway access is needed.

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "oed-cli"
-version = "0.1.0"
+version = "0.1.2"
 description = "oed — openEuler Infra command line. Auto-discovered, AI-friendly."
 readme = "README.md"
 requires-python = ">=3.10"

{oed_cli-0.1.0 → oed_cli-0.1.2}/src/oed_cli/__init__.py

@@ -2,5 +2,5 @@
 
 from __future__ import annotations
 
-__version__ = "0.2.0"
+__version__ = "0.1.2"
 __all__ = ["__version__"]

{oed_cli-0.1.0 → oed_cli-0.1.2}/src/oed_cli/dynamic.py

@@ -149,6 +149,13 @@ class Operation:
     description: str = ""
     parameters: tuple[dict[str, Any], ...] = field(default_factory=tuple)
     body_required: bool = False
+    # Raw ``requestBody`` block (so we don't lose the OpenAPI-level metadata)
+    # plus the inlined ``body_schema`` resolved against ``components/schemas``
+    # for the ``application/json`` content type — the latter is what agents
+    # consume to learn how to build a ``--json`` body. ``None`` when the op
+    # has no JSON body.
+    request_body: dict[str, Any] | None = None
+    body_schema: dict[str, Any] | None = None
     operation_id: str = ""
     # Resolved runtime base URL — read from ``ServiceMeta.base_url`` via
     # :func:`resolve_runtime_gateway`. Empty by default so callers that
@@ -166,7 +173,12 @@ class Operation:
         op: dict[str, Any],
         backend: Backend,
         base_url: str = "",
+        spec: dict[str, Any] | None = None,
     ) -> Operation:
+        request_body = op.get("requestBody") if isinstance(op.get("requestBody"), dict) else None
+        body_schema: dict[str, Any] | None = None
+        if request_body is not None and spec is not None:
+            body_schema = _resolve_json_body_schema(request_body, spec)
         return cls(
             service_name=service_name,
             path=path,
@@ -176,6 +188,8 @@ class Operation:
             description=op.get("description", ""),
             parameters=tuple(op.get("parameters", []) or ()),
             body_required=bool(op.get("requestBody", {}).get("required")),
+            request_body=request_body,
+            body_schema=body_schema,
             operation_id=op.get("operationId") or f"{verb.upper()} {path}",
             base_url=base_url,
         )
@@ -224,6 +238,60 @@ def _parse_backend(op: dict[str, Any], *, path: str, verb: str) -> Backend:
     )
 
 
+# --------------------------------------------------------------------------- #
+# $ref resolver for request-body schemas
+# --------------------------------------------------------------------------- #
+
+
+def _inline_refs(node: Any, *, spec: dict[str, Any], _seen: frozenset[str] = frozenset()) -> Any:
+    """Recursively inline ``$ref: #/components/schemas/X`` in ``node``.
+
+    Only resolves refs the openEuler gateway actually emits (a single schema
+    bag under ``components.schemas``); external ``$ref``s and non-JSON-Reference
+    forms are left alone so the original spec stays recoverable for
+    diagnostics. Recursion depth is bounded by the ref-graph so a cyclic
+    schema can't blow the stack.
+    """
+
+    if isinstance(node, dict):
+        if "$ref" in node and isinstance(node["$ref"], str):
+            ref = node["$ref"]
+            if ref.startswith("#/components/schemas/") and ref not in _seen:
+                key = ref.rsplit("/", 1)[-1]
+                schemas = (spec.get("components") or {}).get("schemas") or {}
+                target = schemas.get(key)
+                if isinstance(target, dict):
+                    return _inline_refs(
+                        target, spec=spec, _seen=_seen | {ref}
+                    )
+            return node
+        return {k: _inline_refs(v, spec=spec, _seen=_seen) for k, v in node.items()}
+    if isinstance(node, list):
+        return [_inline_refs(v, spec=spec, _seen=_seen) for v in node]
+    return node
+
+
+def _resolve_json_body_schema(
+    request_body: dict[str, Any], spec: dict[str, Any]
+) -> dict[str, Any] | None:
+    """Return the inlined JSON-body schema for a requestBody block.
+
+    Prefers the ``application/json`` content type; falls back to the first
+    declared content type when JSON isn't there. Returns ``None`` if the
+    block has no schema to resolve.
+    """
+
+    content = request_body.get("content") or {}
+    media = content.get("application/json") or next(iter(content.values()), None)
+    if not isinstance(media, dict):
+        return None
+    schema = media.get("schema")
+    if not isinstance(schema, dict):
+        return None
+    resolved = _inline_refs(schema, spec=spec)
+    return resolved if isinstance(resolved, dict) else None
+
+
 def collect_operations(
     spec: dict[str, Any], service_name: str, *, base_url: str = ""
 ) -> list[Operation]:
@@ -232,7 +300,9 @@ def collect_operations(
     ``base_url`` is the resolved runtime URL (output of
     :func:`resolve_runtime_gateway`); it is baked into every returned
     :class:`Operation` so :mod:`oed_cli.invoke` does not need to know
-    which service produced the operation.
+    which service produced the operation. The ``spec`` is also passed
+    through so each operation's ``requestBody`` can be resolved against
+    ``components/schemas``.
     """
 
     out: list[Operation] = []
@@ -251,6 +321,7 @@ def collect_operations(
                     op=op,
                     backend=_parse_backend(op, path=path, verb=verb),
                     base_url=base_url,
+                    spec=spec,
                 )
             )
     return out

{oed_cli-0.1.0 → oed_cli-0.1.2}/src/oed_cli/invoke.py

@@ -34,6 +34,12 @@ def _fill_path(template: str, params: dict[str, Any]) -> tuple[str, list[str]]:
 
     Returns the rendered path and the list of placeholder names that were
     not provided, so the caller can raise a precise error.
+
+    Huawei APIG marks required path params with a trailing ``+`` in the
+    template (``/t/{id+}``); the ``+`` is a spec-side marker that never
+    appears in the real request URL or in the declared
+    ``parameters[].name``. Strip it so the lookup matches what the
+    caller actually provided under ``--<flag>`` / ``--params``.
     """
 
     missing: list[str] = []
@@ -48,13 +54,14 @@ def _fill_path(template: str, params: dict[str, Any]) -> tuple[str, list[str]]:
         if name_end == -1:
             parts.append(head + sep + chunk)
             break
-        name = chunk[:name_end]
+        raw_name = chunk[:name_end]
+        name = raw_name.rstrip("+")
         parts.append(head)
         if name in params:
             parts.append(str(params[name]))
         else:
             missing.append(name)
-            parts.append("{" + name + "}")
+            parts.append("{" + raw_name + "}")
         rest = chunk[name_end + 1 :]
     return "".join(parts), missing
 
@@ -75,6 +82,36 @@ def _select_params(
     return path_params, query_params, unused
 
 
+def _body_field_summary(
+    schema: dict[str, Any] | None,
+) -> list[dict[str, Any]]:
+    """Project a resolved body schema down to ``[{name, type, required}]``.
+
+    Listing views use this so the per-operation summary stays compact
+    while still telling an agent which fields exist and which are
+    mandatory. The full schema is exposed separately under
+    ``body_schema`` on ``oed <service> <op> --help``.
+    """
+
+    if not isinstance(schema, dict):
+        return []
+    properties = schema.get("properties") or {}
+    required = set(schema.get("required") or [])
+    out: list[dict[str, Any]] = []
+    for name, prop in properties.items():
+        if not isinstance(prop, dict):
+            continue
+        entry: dict[str, Any] = {
+            "name": name,
+            "type": prop.get("type", "object"),
+            "required": name in required,
+        }
+        if prop.get("description"):
+            entry["description"] = prop["description"]
+        out.append(entry)
+    return out
+
+
 def _render_response(resp: httpx.Response) -> Any:
     """Parse the JSON body of ``resp``, returning a wrapped string for non-JSON."""
 
@@ -207,6 +244,8 @@ def describe_operation(op: Operation) -> dict[str, Any]:
         "query_params": [p["name"] for p in op.query_params],
         "body_required": op.body_required,
     }
+    if op.body_required:
+        out["body_required_fields"] = _body_field_summary(op.body_schema)
     if op.display_name != op.operation_id:
         out["operation_id_raw"] = op.operation_id
     return out
@@ -273,6 +312,9 @@ def describe_operation_help(op: Operation, service) -> dict[str, Any]:
     }
     if name != op.operation_id:
         out["operation_id_raw"] = op.operation_id
+    if op.body_required:
+        out["body_required_fields"] = _body_field_summary(op.body_schema)
+        out["body_schema"] = op.body_schema
     return out
 
 

{oed_cli-0.1.0 → oed_cli-0.1.2/src/oed_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: oed-cli
-Version: 0.1.0
+Version: 0.1.2
 Summary: oed — openEuler Infra command line. Auto-discovered, AI-friendly.
 Author: oed-cli contributors
 License: Apache-2.0
@@ -97,7 +97,7 @@ pip install -e .
 Verify:
 
 ```bash
-oed --version       # → oed, version 0.2.0
+oed --version       # → oed, version 0.1.2
 ```
 
 ---
@@ -248,7 +248,7 @@ invocation. Drop it with `pip uninstall oed-cli` when you're done.
 python -m pytest -q
 ```
 
-39 tests cover v0.1 + v0.2 dispatch, the operation-help cheatsheet,
+41 tests cover v0.1 + v0.2 dispatch, the operation-help cheatsheet,
 per-parameter flag coercion, the `API_`-prefix alias, the
 `resolve_runtime_gateway` no-fallback semantics, and every exit code path.
 They monkeypatch the discovery layer so no gateway access is needed.

{oed_cli-0.1.0 → oed_cli-0.1.2}/tests/test_dynamic.py

@@ -277,6 +277,106 @@ def test_collect_operations_without_backend_block():
     assert op.base_url == "https://apig.osinfra.cn"
 
 
+def test_request_body_schema_resolves_refs():
+    """POST bodies that use ``$ref: #/components/schemas/X`` must surface
+    the resolved schema in ``Operation.body_schema`` so ``--help`` can
+    tell an agent how to construct the ``--json`` body."""
+
+    from oed_cli.dynamic import collect_operations
+
+    spec = {
+        "openapi": "3.0.1",
+        "components": {
+            "schemas": {
+                "SearchCondition": {
+                    "type": "object",
+                    "required": ["keyword", "lang"],
+                    "properties": {
+                        "keyword": {"type": "string", "description": "search kw"},
+                        "lang": {"type": "string", "description": "zh|en"},
+                        "page": {"type": "integer", "default": 1},
+                    },
+                },
+                "Pages": {"type": "object", "properties": {"size": {"type": "integer"}}},
+            },
+        },
+        "paths": {
+            "/search/multitimodal": {
+                "post": {
+                    "operationId": "multitimodalSearchDoc",
+                    "requestBody": {
+                        "required": True,
+                        "content": {
+                            "application/json": {
+                                "schema": {"$ref": "#/components/schemas/SearchCondition"}
+                            }
+                        },
+                    },
+                },
+            },
+            "/cve/findAll": {
+                "post": {
+                    "operationId": "findAllCVEDatabase",
+                    "requestBody": {
+                        "required": True,
+                        "content": {
+                            "application/json": {
+                                "schema": {
+                                    "type": "object",
+                                    "properties": {
+                                        "keyword": {"type": "string"},
+                                        "pages": {"$ref": "#/components/schemas/Pages"},
+                                    },
+                                }
+                            }
+                        },
+                    },
+                },
+            },
+        },
+    }
+    ops = collect_operations(spec, "search", base_url="https://apig.osinfra.cn")
+    by_op = {op.operation_id: op for op in ops}
+
+    # Top-level $ref resolves to the schema body
+    sc = by_op["multitimodalSearchDoc"]
+    assert sc.body_required is True
+    assert sc.body_schema["required"] == ["keyword", "lang"]
+    assert set(sc.body_schema["properties"]) == {"keyword", "lang", "page"}
+    # The resolved schema no longer carries the $ref
+    assert "$ref" not in sc.body_schema
+
+    # Nested $ref (inside a property) inlines too
+    cve = by_op["findAllCVEDatabase"]
+    assert cve.body_schema["properties"]["pages"]["type"] == "object"
+    assert "size" in cve.body_schema["properties"]["pages"]["properties"]
+
+
+def test_request_body_schema_cycles_do_not_blow_stack():
+    """Cyclic ``$ref`` graphs (rare but possible) must terminate."""
+
+    from oed_cli.dynamic import _inline_refs
+
+    spec = {
+        "components": {
+            "schemas": {
+                "A": {
+                    "type": "object",
+                    "properties": {"next": {"$ref": "#/components/schemas/B"}},
+                },
+                "B": {
+                    "type": "object",
+                    "properties": {"next": {"$ref": "#/components/schemas/A"}},
+                },
+            }
+        }
+    }
+    out = _inline_refs({"$ref": "#/components/schemas/A"}, spec=spec)
+    # First level inlined; the cycle is broken at A's re-entry
+    assert out["type"] == "object"
+    assert "next" in out["properties"]
+
+
 def test_parse_json_arg_rejects_garbage():
     from oed_cli.dynamic import parse_json_arg
     from oed_cli.errors import UserError
@@ -426,6 +526,49 @@ def test_call_operation_missing_path_param_raises_user_error(patched):
         call_operation(op)  # no id
 
 
+def test_call_operation_strips_trailing_plus_in_path_template(patched):
+    """Huawei APIG marks required path params with ``{name+}`` in the path
+    template (``/t/{id+}``). The declared ``parameters[].name`` is plain
+    ``id`` — the ``+`` is a spec-side marker. ``oed forum getTopic --id 19308``
+    must therefore resolve the user's ``--id`` value into the rendered URL,
+    not complain that ``id+`` is missing."""
+
+    from oed_cli.dynamic import operations_table
+    from oed_cli.invoke import call_operation
+
+    spec = {
+        "openapi": "3.0.1",
+        "paths": {
+            "/t/{id+}": {
+                "get": {
+                    "operationId": "getTopic",
+                    "parameters": [
+                        {"in": "path", "name": "id",
+                         "required": True, "schema": {"type": "string"}},
+                    ],
+                }
+            }
+        },
+    }
+    table = operations_table(spec, "forum", base_url="https://apig.osinfra.cn")
+    op = table["getTopic"]
+
+    payload = call_operation(op, params={"id": "19308"})
+    assert patched["captured"]["url"].endswith("/t/19308")
+    assert payload["ok"] is True
+    assert payload["status"] == 200
+
+    # Missing-param error must use the clean name (what the user types),
+    # not the APIG-side ``id+`` form.
+    from oed_cli.errors import UserError
+    try:
+        call_operation(op)
+    except UserError as exc:
+        assert exc.to_dict()["message"] == "missing path params: ['id']"
+    else:
+        pytest.fail("expected UserError for missing path param")
+
+
 # ---------- main.py dispatch ----------