schemify-cli 0.1.0__tar.gz

schemify_cli-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.3
+Name: schemify-cli
+Version: 0.1.0
+Summary: Build JSON Schemas interactively, and fill JSON data from them, from the command line.
+Author: aaltatan
+Author-email: aaltatan <a.altatan@gmail.com>
+Requires-Dist: jsonschema>=4.26.0
+Requires-Dist: num2words>=0.5.14
+Requires-Dist: questionary>=2.1.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: typer>=0.27.3
+Requires-Dist: typer-di>=0.1.5
+Requires-Dist: typer-swissknife>=0.1.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# schemify-cli
+
+Build JSON Schemas interactively, and fill JSON data from them, from the command line.
+
+Source: [github.com/aaltatan/schemify-cli](https://github.com/aaltatan/schemify-cli)
+
+A web version runs at [schemify.surge.sh](https://schemify.surge.sh)
+([source](https://github.com/aaltatan/schemify)): the same questions as fields, with the
+schema updating as you type.
+
+## Install
+
+```bash
+uv tool install schemify
+```
+
+## Usage
+
+```bash
+schemify generate -t Person -o person.schema.json   # ask for the properties, write the schema
+schemify fill person.schema.json -o person.json     # ask for one object matching it
+schemify list person.schema.json -f python          # ask for a list of them
+```
+
+| Command | Alias | Does |
+|---|---|---|
+| `generate` | `g` | Asks for the properties of an object and builds its JSON Schema (Draft 2020-12) |
+| `fill` | `f` | Asks for data matching a schema file, checked against it |
+| `list` | `l` | Asks for a list of items, each matching the schema |
+
+- `-o, --output` saves to a file (asks before overwriting); without it the result is printed.
+- `-f, --format` picks the output of `fill` and `list`: `json`, `python` or `javascript`.
+
+Types: `string`, `integer`, `number`, `boolean`, `date`, `datetime`, `enum`, `array`, `object`,
+each with its constraints (length, pattern, format, range, items, ...) and an optional default.
+
+## Computed properties
+
+A property with `x-compute` is not asked in `fill`, it is computed from the other values:
+
+```json
+"full_name": {"type": "string", "x-compute": {"fn": "join", "from": ["first", "middle?", "last"]}}
+```
+
+- `fn`: the computer, `from`: source paths (a list, or an `{alias: path}` object for `template`
+  and `expr`), `options`: extra arguments, `default`: the value when a source is missing.
+- Paths are relative to the owning object (`address.city`, `items[0]`), or to the root
+  (`$.company`). `items[*].price` gives every price; a trailing `?` makes a source optional.
+
+Built-in computers:
+
+- **Text**: join, concat, template, upper, lower, title, capitalize, trim, replace, slice,
+  initials, slug, length, pad, mask
+- **Numbers**: sum, subtract, multiply, divide, average, min, max, abs, round, percent,
+  percent_of, expr
+- **Dates**: today, now, add_days, add_months, add_years, days_between, age, year, month, day,
+  weekday, format_date, start_of_month, end_of_month
+- **Number to words**: words
+- **Logic, lookup and misc**: coalesce, if_else, equals, lookup, constant, count, count_if,
+  unique, uuid
+
+## Reusing it in a typer app
+
+`schemify.cli.dependencies.schema` exposes typer-di dependencies that load a schema file and ask
+for its data: `FilledDataArgumentDI` and `FilledListArgumentDI` take the path as an argument,
+`FilledDataOptionDI` and `FilledListOptionDI` as `--js`.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check . && uv run mypy src
+```
+
+After changing `generators.py`, `validators.py` or `computers.py`, run `pnpm sync && pnpm check`
+in [schemify-web](https://github.com/aaltatan/schemify-web) so it stays in step.

schemify_cli-0.1.0/README.md

@@ -0,0 +1,77 @@
+# schemify-cli
+
+Build JSON Schemas interactively, and fill JSON data from them, from the command line.
+
+Source: [github.com/aaltatan/schemify-cli](https://github.com/aaltatan/schemify-cli)
+
+A web version runs at [schemify.surge.sh](https://schemify.surge.sh)
+([source](https://github.com/aaltatan/schemify)): the same questions as fields, with the
+schema updating as you type.
+
+## Install
+
+```bash
+uv tool install schemify
+```
+
+## Usage
+
+```bash
+schemify generate -t Person -o person.schema.json   # ask for the properties, write the schema
+schemify fill person.schema.json -o person.json     # ask for one object matching it
+schemify list person.schema.json -f python          # ask for a list of them
+```
+
+| Command | Alias | Does |
+|---|---|---|
+| `generate` | `g` | Asks for the properties of an object and builds its JSON Schema (Draft 2020-12) |
+| `fill` | `f` | Asks for data matching a schema file, checked against it |
+| `list` | `l` | Asks for a list of items, each matching the schema |
+
+- `-o, --output` saves to a file (asks before overwriting); without it the result is printed.
+- `-f, --format` picks the output of `fill` and `list`: `json`, `python` or `javascript`.
+
+Types: `string`, `integer`, `number`, `boolean`, `date`, `datetime`, `enum`, `array`, `object`,
+each with its constraints (length, pattern, format, range, items, ...) and an optional default.
+
+## Computed properties
+
+A property with `x-compute` is not asked in `fill`, it is computed from the other values:
+
+```json
+"full_name": {"type": "string", "x-compute": {"fn": "join", "from": ["first", "middle?", "last"]}}
+```
+
+- `fn`: the computer, `from`: source paths (a list, or an `{alias: path}` object for `template`
+  and `expr`), `options`: extra arguments, `default`: the value when a source is missing.
+- Paths are relative to the owning object (`address.city`, `items[0]`), or to the root
+  (`$.company`). `items[*].price` gives every price; a trailing `?` makes a source optional.
+
+Built-in computers:
+
+- **Text**: join, concat, template, upper, lower, title, capitalize, trim, replace, slice,
+  initials, slug, length, pad, mask
+- **Numbers**: sum, subtract, multiply, divide, average, min, max, abs, round, percent,
+  percent_of, expr
+- **Dates**: today, now, add_days, add_months, add_years, days_between, age, year, month, day,
+  weekday, format_date, start_of_month, end_of_month
+- **Number to words**: words
+- **Logic, lookup and misc**: coalesce, if_else, equals, lookup, constant, count, count_if,
+  unique, uuid
+
+## Reusing it in a typer app
+
+`schemify.cli.dependencies.schema` exposes typer-di dependencies that load a schema file and ask
+for its data: `FilledDataArgumentDI` and `FilledListArgumentDI` take the path as an argument,
+`FilledDataOptionDI` and `FilledListOptionDI` as `--js`.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check . && uv run mypy src
+```
+
+After changing `generators.py`, `validators.py` or `computers.py`, run `pnpm sync && pnpm check`
+in [schemify-web](https://github.com/aaltatan/schemify-web) so it stays in step.

schemify_cli-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "schemify-cli"
+version = "0.1.0"
+description = "Build JSON Schemas interactively, and fill JSON data from them, from the command line."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "jsonschema>=4.26.0",
+    "num2words>=0.5.14",
+    "questionary>=2.1.1",
+    "rich>=15.0.0",
+    "typer>=0.27.3",
+    "typer-di>=0.1.5",
+    "typer-swissknife>=0.1.1",
+]
+
+[[project.authors]]
+name = "aaltatan"
+email = "a.altatan@gmail.com"
+
+[project.scripts]
+schemify = "schemify.cli.main:main"
+
+[build-system]
+requires = ["uv_build>=0.13.5,<0.14.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "mypy>=2.4.1",
+    "pytest>=9.2.0",
+    "ruff>=0.17.3",
+    "types-jsonschema>=4.26.0.20261006",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[[tool.mypy.overrides]]
+module = [
+    "typer_swissknife",
+    "num2words",
+]
+ignore_missing_imports = true
+
+[tool.uv.build-backend]
+module-name = "schemify"

schemify_cli-0.1.0/pyproject.toml.orig

@@ -0,0 +1,43 @@
+[project]
+name = "schemify-cli"
+version = "0.1.0"
+description = "Build JSON Schemas interactively, and fill JSON data from them, from the command line."
+readme = "README.md"
+authors = [
+    { name = "aaltatan", email = "a.altatan@gmail.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "jsonschema>=4.26.0",
+    "num2words>=0.5.14",
+    "questionary>=2.1.1",
+    "rich>=15.0.0",
+    "typer>=0.27.3",
+    "typer-di>=0.1.5",
+    "typer-swissknife>=0.1.1",
+]
+
+[project.scripts]
+schemify = "schemify.cli.main:main"
+
+[build-system]
+requires = ["uv_build>=0.13.5,<0.14.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "mypy>=2.4.1",
+    "pytest>=9.2.0",
+    "ruff>=0.17.3",
+    "types-jsonschema>=4.26.0.20261006",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[[tool.mypy.overrides]]
+module = ["typer_swissknife", "num2words"]
+ignore_missing_imports = true
+
+[tool.uv.build-backend]
+module-name = "schemify"

schemify_cli-0.1.0/src/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-0.1.0/src/schemify/cli/__init__.py

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

schemify_cli-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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()