Prozorro Sale schema exploration

[jpmckinney]

https://procedure-staging.prozorro.sale/api/doc

• Extract and deduplicate - Convert inlined schemas to $ref references, output a compact JSON Schema
• Generate inheritance view - Use the x-baseClass hints to show procedure type hierarchies
• Interactive viewer - Generate HTML/markdown documentation that collapses common types
  • Schema was too large for HTML to give a rapid overview. ERD with dot works.

[jpmckinney]

Here's the generated code for Generate inheritance view. In the end, not that useful, because there are still too many base classes to consider.

import json
from collections import defaultdict
from pathlib import Path

import click
import requests


def generate_tree(inheritance):
    """Generate ASCII tree output grouped by base class."""
    lines = []
    for base, children in sorted(inheritance.items(), key=lambda x: -len(x[1])):
        lines.append(f"{base} ({len(children)})")
        for child in sorted(children):
            lines.append(f"  └── {child}")
    return "\n".join(lines)


def generate_mermaid(inheritance):
    """Generate Mermaid flowchart."""
    lines = ["```mermaid", "flowchart TD"]
    for base, children in sorted(inheritance.items()):
        safe_base = base.replace("-", "_")
        for child in children:
            safe_child = child.replace("-", "_").replace(".", "_")
            lines.append(f"    {safe_base} --> {safe_child}")
    lines.append("```")
    return "\n".join(lines)


def register_command(cli):
    @cli.command()
    @click.argument("url")
    @click.option("-o", "--output", type=click.Path(), help="Output file (default: stdout)")
    @click.option(
        "--format",
        "fmt",
        type=click.Choice(["tree", "mermaid", "json"]),
        default="tree",
        help="Output format: tree (ASCII), mermaid (diagram), json",
    )
    def inheritance_view(url, output, fmt):
        """
        Generate an inheritance hierarchy view from x-baseClass hints in an OpenAPI spec.
        """
        # 1. Fetch the spec
        response = requests.get(url)
        response.raise_for_status()
        spec = response.json()

        # 2. Extract schemas and x-baseClass relationships
        schemas = spec.get("components", {}).get("schemas", spec.get("definitions", {}))

        # Map: base_class_name -> [child_schema_names]
        inheritance = defaultdict(list)
        for name, schema in schemas.items():
            if "x-baseClass" in schema:
                base_path = schema["x-baseClass"]
                base_name = base_path.split(".")[-1]  # e.g., "ProcedureEnglish"
                inheritance[base_name].append(name)

        # 3. Generate output based on format
        if fmt == "tree":
            result = generate_tree(inheritance)
        elif fmt == "mermaid":
            result = generate_mermaid(inheritance)
        else:  # json
            result = json.dumps(dict(inheritance), indent=2, sort_keys=True)

        # 4. Output
        if output:
            Path(output).write_text(result)
            click.echo(f"Wrote {len(result)} bytes to {output}")
        else:
            click.echo(result)