schemify-cli 0.1.0__py3-none-any.whl

schemify/__init__.py

@@ -0,0 +1,21 @@
+"""schemify: build JSON Schemas interactively, and fill JSON data from them."""
+
+from .computers import ComputeError, compute, computers
+from .fillers import InvalidDataError, ask_data, ask_list, fillers
+from .formatters import formatters
+from .generators import ask_schema, generators
+from .registry import NotSupportedError
+
+__all__ = [
+    "ComputeError",
+    "InvalidDataError",
+    "NotSupportedError",
+    "ask_data",
+    "ask_list",
+    "ask_schema",
+    "compute",
+    "computers",
+    "fillers",
+    "formatters",
+    "generators",
+]

schemify/cli/__init__.py

@@ -0,0 +1 @@
+"""The schemify command line interface."""

schemify/cli/dependencies/__init__.py

@@ -0,0 +1,4 @@
+"""Typer dependencies shared by the commands, injected with typer-di.
+
+They are importable by other typer-di apps, like templify.
+"""

schemify/cli/dependencies/console.py

@@ -0,0 +1,9 @@
+"""The rich console used for command output."""
+
+from typing import Annotated
+
+from rich.console import Console
+from typer_di import Depends
+
+ConsoleDI = Annotated[Console, Depends(lambda: Console(color_system="truecolor"))]
+"""Injects a truecolor rich console."""

schemify/cli/dependencies/schema.py

@@ -0,0 +1,128 @@
+"""The schema file, and the data the user fills from it, as an option or an argument.
+
+Other typer-di apps can reuse them, pick the version matching how the path is given:
+
+```python
+@app.command()
+def fill_template(data: FilledDataOptionDI) -> None: ...  # app --js person.json
+
+
+@app.command()
+def fill_template(data: FilledDataArgumentDI) -> None: ...  # app person.json
+
+
+@app.command()
+def fill_many(items: FilledListArgumentDI) -> None: ...  # app person.json, a list of people
+```
+"""
+
+import json
+from collections.abc import Callable
+from pathlib import Path
+from typing import Annotated, Any
+
+import typer
+from typer_di import Depends
+
+from schemify.fillers import InvalidDataError, ask_data, ask_list
+from schemify.models import Schema
+from schemify.registry import NotSupportedError
+from schemify.validators import check_schema
+
+_PATH_HELP = "Path to the JSON Schema file"
+
+# -----------------------
+# schema
+# -----------------------
+
+
+def _load_schema(path: Path) -> Schema:
+    try:
+        schema = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, UnicodeDecodeError) as e:
+        msg = f"Could not read schema file '{path.name}': {e}"
+        raise typer.BadParameter(msg) from e
+
+    error = check_schema(schema)
+
+    if error is not None:
+        msg = f"Invalid schema file '{path.name}': {error}"
+        raise typer.BadParameter(msg)
+
+    return schema
+
+
+def _schema_from_option(
+    path: Annotated[
+        Path,
+        typer.Option(
+            "--js",
+            "--json-schema",
+            help=_PATH_HELP,
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            resolve_path=True,
+        ),
+    ],
+) -> Schema:
+    return _load_schema(path)
+
+
+def _schema_from_argument(
+    path: Annotated[
+        Path,
+        typer.Argument(
+            help=_PATH_HELP,
+            exists=True,
+            file_okay=True,
+            dir_okay=False,
+            resolve_path=True,
+        ),
+    ],
+) -> Schema:
+    return _load_schema(path)
+
+
+# -----------------------
+# filled data
+# -----------------------
+
+
+def _filled_data(
+    read_schema: Callable[..., Schema], ask: Callable[[Schema], Any] = ask_data
+) -> Callable[..., Any]:
+    """Build a dependency asking (with `ask`) for data matching the schema `read_schema` injects."""
+
+    def fill(schema: Annotated[Schema, Depends(read_schema)]) -> Any:
+        try:
+            return ask(schema)
+        except (NotSupportedError, InvalidDataError) as e:
+            raise typer.BadParameter(str(e)) from e
+        except KeyboardInterrupt:
+            raise typer.Abort from None
+
+    return fill
+
+
+# -----------------------
+# DI
+# -----------------------
+
+SchemaOptionDI = Annotated[Schema, Depends(_schema_from_option)]
+"""Injects the valid JSON Schema read from the `--js` / `--json-schema` option."""
+
+SchemaArgumentDI = Annotated[Schema, Depends(_schema_from_argument)]
+"""Injects the valid JSON Schema read from the `PATH` argument."""
+
+FilledDataOptionDI = Annotated[Any, Depends(_filled_data(_schema_from_option))]
+"""Injects the data the user entered, matching the `--js` / `--json-schema` file."""
+
+FilledDataArgumentDI = Annotated[Any, Depends(_filled_data(_schema_from_argument))]
+"""Injects the data the user entered, matching the `PATH` argument file."""
+
+FilledListOptionDI = Annotated[list[Any], Depends(_filled_data(_schema_from_option, ask_list))]
+"""Injects the list of items the user entered, each matching the `--js` / `--json-schema` file."""
+
+FilledListArgumentDI = Annotated[list[Any], Depends(_filled_data(_schema_from_argument, ask_list))]
+"""Injects the list of items the user entered, each matching the `PATH` argument file."""

schemify/cli/main.py

@@ -0,0 +1,138 @@
+"""The schemify command line application."""
+
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from rich.syntax import Syntax
+from typer_di import TyperDI
+from typer_swissknife import command
+
+from schemify.cli.dependencies.console import ConsoleDI
+from schemify.cli.dependencies.schema import FilledDataArgumentDI, FilledListArgumentDI
+from schemify.formatters import formatters, to_json
+from schemify.generators import ask_schema
+
+app = TyperDI(
+    name="schemify",
+    help="Build JSON Schemas interactively, and fill JSON data from them",
+    no_args_is_help=True,
+)
+
+
+def _confirm_overwrite(output: Path | None) -> Path | None:
+    """Ask before the long interactive session, not after it."""
+    if output is not None and output.exists():
+        typer.confirm(f"'{output.name}' already exists, overwrite it?", abort=True)
+
+    return output
+
+
+OutputOption = Annotated[  # not a `type` alias, typer can not read through those
+    Path | None,
+    typer.Option(
+        "-o",
+        "--output",
+        help="Path to save the output to, printed when missing",
+        file_okay=True,
+        dir_okay=False,
+        resolve_path=True,
+        callback=_confirm_overwrite,
+    ),
+]
+
+
+def _check_if_format_is_supported(name: str) -> str:
+    if name not in formatters:
+        supported = ", ".join(formatters.names)
+        message = f"Format '{name}' is not supported, supported: {supported}"
+        raise typer.BadParameter(message)
+
+    return name.lower()
+
+
+FormatOption = Annotated[
+    str,
+    typer.Option(
+        "-f",
+        "--format",
+        help=f"Output format ({', '.join(formatters.names)})",
+        callback=_check_if_format_is_supported,
+    ),
+]
+
+
+def _output(console: ConsoleDI, text: str, lexer: str, output: Path | None) -> None:
+    if output is None:
+        console.print(Syntax(text, lexer, background_color="default"))
+        return
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    output.write_text(f"{text}\n", encoding="utf-8")
+    console.print(f"[green]Saved to:[/] {output}")
+
+
+@command(
+    app,
+    name="generate",
+    aliases=("g",),
+    help="Ask for the properties of an object and build its JSON Schema",
+)
+def generate_schema(
+    console: ConsoleDI,
+    output: OutputOption = None,
+    title: Annotated[
+        str | None,
+        typer.Option("-t", "--title", help="Title of the schema"),
+    ] = None,
+) -> None:
+    """Ask for the properties of an object and build its JSON Schema."""
+    try:
+        schema = ask_schema(title)
+    except KeyboardInterrupt:
+        raise typer.Abort from None
+
+    _output(console, to_json(schema), "json", output)
+
+
+@command(
+    app,
+    name="fill",
+    aliases=("f",),
+    no_args_is_help=True,
+    help="Ask for data matching a JSON Schema",
+)
+def fill_data(
+    console: ConsoleDI,
+    data: FilledDataArgumentDI,
+    output: OutputOption = None,
+    output_format: FormatOption = "json",
+) -> None:
+    """Ask for data matching a JSON Schema."""
+    _output(console, formatters[output_format](data), output_format, output)
+
+
+@command(
+    app,
+    name="list",
+    aliases=("l",),
+    no_args_is_help=True,
+    help="Ask for a list of items, each matching a JSON Schema",
+)
+def fill_list(
+    console: ConsoleDI,
+    items: FilledListArgumentDI,
+    output: OutputOption = None,
+    output_format: FormatOption = "json",
+) -> None:
+    """Ask for a list of items, each matching a JSON Schema."""
+    _output(console, formatters[output_format](items), output_format, output)
+
+
+def main() -> None:
+    """Run the schemify command line application."""
+    app()
+
+
+if __name__ == "__main__":
+    main()