schemify-cli 0.1.0__py3-none-any.whl

schemify/registry.py

@@ -0,0 +1,69 @@
+"""A registry of functions picked by name, used by the schema generators and data fillers."""
+
+from collections.abc import Callable
+from typing import Any
+
+
+class NotSupportedError(Exception):
+    """Raised when no function is registered under a name."""
+
+
+class Registry[F: Callable[..., Any]]:
+    """Maps names (case-insensitive) to functions.
+
+    Example:
+    ```python
+    generators = Registry[Callable[[], Schema]]("Type")
+
+
+    @generators.register("string")
+    def generate_string() -> Schema: ...
+
+
+    schema = generators["string"]()
+    ```
+
+    """
+
+    def __init__(self, kind: str) -> None:
+        """Create an empty registry, `kind` names its entries in error messages."""
+        self._kind = kind
+        self._fns: dict[str, F] = {}
+
+    def __contains__(self, name: object) -> bool:
+        """Whether a function is registered under `name`."""
+        return isinstance(name, str) and name.lower() in self._fns
+
+    def __getitem__(self, name: str) -> F:
+        """Return the function registered under `name`.
+
+        Raises:
+            NotSupportedError: Nothing is registered under `name`.
+
+        """
+        if name not in self:
+            supported = ", ".join(self.names)
+            message = f"{self._kind} '{name}' is not supported, supported: {supported}"
+            raise NotSupportedError(message)
+
+        return self._fns[name.lower()]
+
+    @property
+    def names(self) -> list[str]:
+        """The registered names, sorted."""
+        return sorted(self._fns)
+
+    def register(self, *names: str) -> Callable[[F], F]:
+        """Register the decorated function under `names`."""
+
+        def decorator(fn: F) -> F:
+            for name in names:
+                self.add(fn, name)
+
+            return fn
+
+        return decorator
+
+    def add(self, fn: F, name: str) -> None:
+        """Register `fn` under `name`, replacing any existing one."""
+        self._fns[name.lower()] = fn

schemify/validators.py

@@ -0,0 +1,300 @@
+"""Validators and parsers for prompt answers and values, they never prompt.
+
+Prompt validators follow the questionary `validate=` contract:
+they return `True` when the answer is valid, else the error message.
+"""
+
+import contextlib
+import json
+import math
+import re
+from collections.abc import Callable, Collection
+from datetime import date, datetime
+from typing import Any
+
+from jsonschema import Draft202012Validator, FormatChecker, SchemaError
+
+from .models import Schema
+
+type Parser = Callable[[str], Any]
+"""Turns a prompt answer into a value, raises `ValueError` with a readable message."""
+
+type PromptValidator = Callable[[str], bool | str]
+"""Returns `True` for a valid answer, else the error message."""
+
+type Constraint = tuple[str, str, Parser, PromptValidator]
+"""A schema keyword, its question, the answer parser and the answer validator."""
+
+# -----------------------
+# parsers
+# -----------------------
+
+
+def to_int(text: str) -> int:
+    """Parse an integer: `"42"`."""
+    try:
+        return int(text.strip())
+    except ValueError:
+        message = f"'{text}' is not an integer"
+        raise ValueError(message) from None
+
+
+def to_number(text: str) -> int | float:
+    """Parse a finite number, keeping integers as `int`: `"42"`, `"4.2"`."""
+    try:
+        return to_int(text)
+    except ValueError:
+        pass
+
+    try:
+        number = float(text.strip())
+    except ValueError:
+        message = f"'{text}' is not a number"
+        raise ValueError(message) from None
+
+    if not math.isfinite(number):
+        message = f"'{text}' is not a finite number"
+        raise ValueError(message)
+
+    return number
+
+
+def to_non_negative_int(text: str) -> int:
+    """Parse an integer that is 0 or more, like a length."""
+    number = to_int(text)
+
+    if number < 0:
+        message = f"'{text}' must be 0 or more"
+        raise ValueError(message)
+
+    return number
+
+
+def to_positive_number(text: str) -> int | float:
+    """Parse a number greater than 0, like `multipleOf`."""
+    number = to_number(text)
+
+    if number <= 0:
+        message = f"'{text}' must be greater than 0"
+        raise ValueError(message)
+
+    return number
+
+
+def to_regex(text: str) -> str:
+    """Check `text` compiles as a regular expression and return it unchanged."""
+    try:
+        re.compile(text)
+    except re.error as e:
+        message = f"Invalid regular expression: {e}"
+        raise ValueError(message) from None
+
+    return text
+
+
+def to_choices(text: str) -> list[str]:
+    """Parse comma separated choices: `"red, green"` -> `["red", "green"]`."""
+    choices = [choice.strip() for choice in text.split(",") if choice.strip()]
+
+    if not choices:
+        message = "Enter at least one choice"
+        raise ValueError(message)
+
+    if len(set(choices)) != len(choices):
+        message = "Choices must be unique"
+        raise ValueError(message)
+
+    return choices
+
+
+def to_date(text: str) -> str:
+    """Parse an ISO date, returned as an ISO string: `"2026-11-04"`."""
+    return date.fromisoformat(text.strip()).isoformat()
+
+
+def to_datetime(text: str) -> str:
+    """Parse an ISO datetime, returned as an RFC 3339 string.
+
+    A datetime without offset is taken as local time, RFC 3339 requires the offset.
+    """
+    value = datetime.fromisoformat(text.strip())
+
+    return (value if value.tzinfo else value.astimezone()).isoformat()
+
+
+def default_parser(schema: Schema) -> Parser:
+    """Build a parser for a default value of `schema`.
+
+    The answer is read as JSON (`42`, `true`, `["a"]`), else as text, the first matching `schema`
+    is kept: `42` is a number for an integer and the text `"42"` for a string.
+    """
+
+    def parse(text: str) -> Any:
+        candidates: list[Any] = [text.strip()]
+
+        with contextlib.suppress(json.JSONDecodeError):
+            candidates.insert(0, json.loads(text))
+
+        errors = [check_value(schema, candidate) for candidate in candidates]
+
+        for candidate, error in zip(candidates, errors, strict=True):
+            if error is None:
+                return candidate
+
+        raise ValueError(errors[0])
+
+    return parse
+
+
+# -----------------------
+# prompt validators
+# -----------------------
+
+
+def validator(parse: Parser) -> PromptValidator:
+    """Build a prompt validator accepting the answers `parse` accepts."""
+
+    def validate(text: str) -> bool | str:
+        try:
+            parse(text)
+        except ValueError as e:
+            return str(e)
+
+        return True
+
+    return validate
+
+
+def optional(validate: PromptValidator) -> PromptValidator:
+    """Accept an empty answer (to skip), else run `validate`."""
+    return lambda text: not text.strip() or validate(text)
+
+
+def is_choice(existing: Collection[str]) -> PromptValidator:
+    """Accept a new enum choice, or an empty answer to finish once one choice exists."""
+
+    def validate(text: str) -> bool | str:
+        choice = text.strip()
+
+        if not choice:
+            return bool(existing) or "Add at least one choice"
+
+        return choice not in existing or f"Choice '{choice}' already exists"
+
+    return validate
+
+
+def is_property_name(existing: Collection[str]) -> PromptValidator:
+    """Accept a new property name, or an empty answer to finish once one property exists."""
+
+    def validate(text: str) -> bool | str:
+        name = text.strip()
+
+        if not name:
+            return bool(existing) or "Add at least one property"
+
+        return name not in existing or f"Property '{name}' already exists"
+
+    return validate
+
+
+# -----------------------
+# constraints
+# -----------------------
+
+STRING_CONSTRAINTS: list[Constraint] = [
+    ("minLength", "Minimum length", to_non_negative_int, validator(to_non_negative_int)),
+    ("maxLength", "Maximum length", to_non_negative_int, validator(to_non_negative_int)),
+    ("pattern", "Regular expression pattern", to_regex, validator(to_regex)),
+    (
+        "not",
+        "Blocked values, comma separated",
+        lambda text: {"enum": to_choices(text)},
+        validator(to_choices),
+    ),
+]
+"""The validators asked for a string, mapped to JSON Schema keywords."""
+
+NUMBER_CONSTRAINTS: list[Constraint] = [
+    ("exclusiveMinimum", "Greater than", to_number, validator(to_number)),
+    ("minimum", "Greater than or equal to", to_number, validator(to_number)),
+    ("exclusiveMaximum", "Less than", to_number, validator(to_number)),
+    ("maximum", "Less than or equal to", to_number, validator(to_number)),
+    ("multipleOf", "Multiple of", to_positive_number, validator(to_positive_number)),
+]
+"""The validators asked for an integer or a number, mapped to JSON Schema keywords."""
+
+ARRAY_CONSTRAINTS: list[Constraint] = [
+    ("minItems", "Minimum items", to_non_negative_int, validator(to_non_negative_int)),
+    ("maxItems", "Maximum items", to_non_negative_int, validator(to_non_negative_int)),
+]
+"""The validators asked for an array, mapped to JSON Schema keywords."""
+
+_BOUNDS = [
+    # (lower keyword, upper keyword, can they be equal)
+    ("minLength", "maxLength", True),
+    ("minItems", "maxItems", True),
+    ("minimum", "maximum", True),
+    ("minimum", "exclusiveMaximum", False),
+    ("exclusiveMinimum", "maximum", False),
+    ("exclusiveMinimum", "exclusiveMaximum", False),
+]
+
+
+def check_bounds(schema: Schema) -> str | None:
+    """Return why no value can satisfy the bounds of `schema`, or `None` when they can."""
+    for low, high, equal_ok in _BOUNDS:
+        if low not in schema or high not in schema:
+            continue
+
+        if schema[low] > schema[high] or (not equal_ok and schema[low] == schema[high]):
+            return f"{low} ({schema[low]}) must be less than {high} ({schema[high]})"
+
+    return None
+
+
+def within_bounds(schema: Schema, constraint: Constraint) -> PromptValidator:
+    """Run the `constraint` validator, then reject an answer conflicting with `schema` bounds.
+
+    So the user stays on the conflicting answer instead of starting the constraints over.
+    """
+    keyword, _, parse, validate = constraint
+
+    def validate_bounds(text: str) -> bool | str:
+        result = validate(text)
+
+        if result is not True:
+            return result
+
+        return check_bounds({**schema, keyword: parse(text)}) or True
+
+    return validate_bounds
+
+
+# -----------------------
+# json schema
+# -----------------------
+
+
+def check_schema(schema: Any) -> str | None:
+    """Return why `schema` is not a valid JSON Schema object, or `None` when it is."""
+    if not isinstance(schema, dict):
+        return "A schema must be a JSON object"
+
+    try:
+        Draft202012Validator.check_schema(schema)
+    except SchemaError as e:
+        return e.message
+
+    return None
+
+
+def check_value(schema: Schema, value: Any) -> str | None:
+    """Return why `value` does not match `schema`, or `None` when it does.
+
+    Formats are checked when jsonschema supports them without extras (date, email, uuid, ...).
+    """
+    validator_ = Draft202012Validator(schema, format_checker=FormatChecker())
+    error = next(validator_.iter_errors(value), None)
+
+    return None if error is None else error.message

schemify_cli-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,18 @@
+schemify/__init__.py,sha256=bVb4Qylc0TYeBR3jhRz5rp0EZe5gCwbRfYToXAMpB_M,564
+schemify/cli/__init__.py,sha256=aayFp21WiVMIDHa1Z84eqw15ZLtteL24vuQR6a1W9Mg,43
+schemify/cli/dependencies/__init__.py,sha256=Nq8g_PGFq5RBHU1ELk7p1PKVVe9Xjj5AVL3dKAJqZAs,134
+schemify/cli/dependencies/console.py,sha256=Ai0VzaU7cL6kK8YjqaPW2YWFeO2FbWazBeFj4vpuIGE,265
+schemify/cli/dependencies/schema.py,sha256=RoNJJLYTR3VoM99FsaENYp09OgRERQGtAq5XgovKQAs,3700
+schemify/cli/main.py,sha256=zN-LH-ci0zqRITOrJtBVtpQoF3rt_m9e0yXaZ_PL-Ns,3766
+schemify/computers.py,sha256=cRbk4DVeXpMB3zWQXbqpSivm-7HieXGLBLoj_Ija_hA,20732
+schemify/fillers.py,sha256=avd50hSzFA86M2a30m3HZm31fpxxV43_kxPA3T1zDnU,8306
+schemify/formatters.py,sha256=RF7NlpOrxTr5TS4cx0aq9c4kB1GNmNLwV6rhXD4Gdiw,1903
+schemify/generators.py,sha256=dnP8f0mpP-6Bb0FBghFI_81q8In6uywPbd8nmXrfGFk,10421
+schemify/models.py,sha256=V9Ob9vTF4U5AsaFHOtl3HOUDpBowBUQ2h-WZo2irO-g,160
+schemify/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+schemify/registry.py,sha256=gLneezkhx6OjnybD35R0DL_KWGfXMFnqK-tuo1SlmCo,1928
+schemify/validators.py,sha256=2CVLgwwl_Ofm1wSaONA7UcWiJJ8LU-5yJy5jEHCw-O0,9079
+schemify_cli-0.1.0.dist-info/WHEEL,sha256=si2p8vW03RnhyBnhWl4tj-ObJa78SpE-c9HsEtblGR0,80
+schemify_cli-0.1.0.dist-info/entry_points.txt,sha256=4uAUa_6hC_cz6oMOXTN-djmSHdPh9Uc9-rq1qd9j_ic,53
+schemify_cli-0.1.0.dist-info/METADATA,sha256=fUOJhRqrfKlJ-s7shE6V_LUdok3Ks8cBVpywJq45DGQ,3565
+schemify_cli-0.1.0.dist-info/RECORD,,

schemify_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.13.5
+Root-Is-Purelib: true
+Tag: py3-none-any

schemify_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+schemify = schemify.cli.main:main
+