mkschema 0.1.0__tar.gz

mkschema-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 mkschema contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

mkschema-0.1.0/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: mkschema
+Version: 0.1.0
+Summary: Generate a JSON Schema from sample JSON — merge multiple samples (or NDJSON) with type + format inference and required-key detection. Zero dependencies.
+Author: yyfjj
+License: MIT
+Project-URL: Homepage, https://github.com/jjdoor/mkschema-py
+Project-URL: Repository, https://github.com/jjdoor/mkschema-py
+Project-URL: Issues, https://github.com/jjdoor/mkschema-py/issues
+Keywords: json-schema,schema,json,generate,infer,ndjson,openapi,cli,codegen,validation
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mkschema
+
+**Generate a JSON Schema from real JSON — and feed it more than one sample.**
+You have an API response, a config, a pile of log records, and you want a JSON
+Schema for validation, docs, or contract tests. Hand-writing it is tedious;
+most generators take a *single* example and over-fit it — every field marked
+required, types pinned to whatever that one record happened to contain.
+`mkschema` merges **many** samples: a field in *every* sample is `required`, a
+field in only some is optional, and differing types are unioned. **Zero
+dependencies, no network.**
+
+```bash
+pip install mkschema
+
+$ printf '{"id":1,"name":"Ada","age":30}\n{"id":2,"age":30.5}\n' | mkschema --ndjson -
+
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "age":  { "type": "number" },        // 30 and 30.5 unioned to number
+    "id":   { "type": "integer" },
+    "name": { "type": "string" }
+  },
+  "required": ["age", "id"]               // name was missing from the 2nd sample, so it's optional
+}
+```
+
+> This is the Python build. A behavior-equivalent Node build is on npm:
+> `npx mkschema` (<https://github.com/jjdoor/mkschema>).
+
+## Usage
+
+```bash
+mkschema sample.json                 # infer from one file
+mkschema a.json b.json c.json        # merge several samples into one schema
+mkschema --ndjson records.ndjson     # one sample per line (logs, exports)
+cat response.json | mkschema -        # read a JSON value from stdin
+mkschema users.json --title User --id https://ex.com/user.schema.json
+```
+
+Schema goes to **stdout**, so redirect it: `mkschema data.json > schema.json`.
+
+## What it infers
+
+- **Types** — `null`, `boolean`, `integer`, `number`, `string`, `array`,
+  `object`. Numbers are classified by value, so `5.0` is an `integer` and the
+  Python and Node builds agree.
+- **String `format`** — `date-time`, `date`, `email`, `uuid`, `ipv4`, `uri`
+  (kept only when *all* samples of a field agree).
+- **`required`** — the intersection across samples: a key present in every
+  sample. (One sample ⇒ everything required.)
+- **Arrays** — `items` is the merge of all element schemas, so `[1, "x"]`
+  becomes `{ "type": ["integer", "string"] }`.
+- **Unions** — a field that is an integer in one sample and a float in another
+  becomes `number`; genuinely different types become a sorted `type` array.
+
+## Options
+
+| Flag | Effect |
+|------|--------|
+| `--ndjson <src>` | Treat each line of `<src>` (a file, or `-` for stdin) as a separate sample |
+| `--title <name>` | Set the schema `title` |
+| `--id <uri>` | Set `$id` |
+| `-` | Read one JSON value from stdin |
+| `-v`, `--version` · `-h`, `--help` | |
+
+## Notes
+
+- **Output is draft 2020-12** JSON Schema, deterministic (properties and
+  `required` are sorted) so it diffs cleanly in version control.
+- **Same tool, two builds.** A behavior-equivalent Node build is on npm
+  (`npx mkschema`); use whichever your stack has.
+- It infers structure, not constraints — add your own `minLength`, `enum`,
+  `pattern`, etc. afterward. mkschema gives you the scaffold from real data.
+
+## Exit codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | schema written |
+| `2` | error (no input, invalid JSON, unreadable file) |
+
+## License
+
+MIT

mkschema-0.1.0/README.md

@@ -0,0 +1,86 @@
+# mkschema
+
+**Generate a JSON Schema from real JSON — and feed it more than one sample.**
+You have an API response, a config, a pile of log records, and you want a JSON
+Schema for validation, docs, or contract tests. Hand-writing it is tedious;
+most generators take a *single* example and over-fit it — every field marked
+required, types pinned to whatever that one record happened to contain.
+`mkschema` merges **many** samples: a field in *every* sample is `required`, a
+field in only some is optional, and differing types are unioned. **Zero
+dependencies, no network.**
+
+```bash
+pip install mkschema
+
+$ printf '{"id":1,"name":"Ada","age":30}\n{"id":2,"age":30.5}\n' | mkschema --ndjson -
+
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "age":  { "type": "number" },        // 30 and 30.5 unioned to number
+    "id":   { "type": "integer" },
+    "name": { "type": "string" }
+  },
+  "required": ["age", "id"]               // name was missing from the 2nd sample, so it's optional
+}
+```
+
+> This is the Python build. A behavior-equivalent Node build is on npm:
+> `npx mkschema` (<https://github.com/jjdoor/mkschema>).
+
+## Usage
+
+```bash
+mkschema sample.json                 # infer from one file
+mkschema a.json b.json c.json        # merge several samples into one schema
+mkschema --ndjson records.ndjson     # one sample per line (logs, exports)
+cat response.json | mkschema -        # read a JSON value from stdin
+mkschema users.json --title User --id https://ex.com/user.schema.json
+```
+
+Schema goes to **stdout**, so redirect it: `mkschema data.json > schema.json`.
+
+## What it infers
+
+- **Types** — `null`, `boolean`, `integer`, `number`, `string`, `array`,
+  `object`. Numbers are classified by value, so `5.0` is an `integer` and the
+  Python and Node builds agree.
+- **String `format`** — `date-time`, `date`, `email`, `uuid`, `ipv4`, `uri`
+  (kept only when *all* samples of a field agree).
+- **`required`** — the intersection across samples: a key present in every
+  sample. (One sample ⇒ everything required.)
+- **Arrays** — `items` is the merge of all element schemas, so `[1, "x"]`
+  becomes `{ "type": ["integer", "string"] }`.
+- **Unions** — a field that is an integer in one sample and a float in another
+  becomes `number`; genuinely different types become a sorted `type` array.
+
+## Options
+
+| Flag | Effect |
+|------|--------|
+| `--ndjson <src>` | Treat each line of `<src>` (a file, or `-` for stdin) as a separate sample |
+| `--title <name>` | Set the schema `title` |
+| `--id <uri>` | Set `$id` |
+| `-` | Read one JSON value from stdin |
+| `-v`, `--version` · `-h`, `--help` | |
+
+## Notes
+
+- **Output is draft 2020-12** JSON Schema, deterministic (properties and
+  `required` are sorted) so it diffs cleanly in version control.
+- **Same tool, two builds.** A behavior-equivalent Node build is on npm
+  (`npx mkschema`); use whichever your stack has.
+- It infers structure, not constraints — add your own `minLength`, `enum`,
+  `pattern`, etc. afterward. mkschema gives you the scaffold from real data.
+
+## Exit codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | schema written |
+| `2` | error (no input, invalid JSON, unreadable file) |
+
+## License
+
+MIT

mkschema-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "mkschema"
+version = "0.1.0"
+description = "Generate a JSON Schema from sample JSON — merge multiple samples (or NDJSON) with type + format inference and required-key detection. Zero dependencies."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "yyfjj" }]
+keywords = ["json-schema", "schema", "json", "generate", "infer", "ndjson", "openapi", "cli", "codegen", "validation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Code Generators",
+    "Topic :: Utilities",
+]
+dependencies = []
+
+[project.urls]
+Homepage = "https://github.com/jjdoor/mkschema-py"
+Repository = "https://github.com/jjdoor/mkschema-py"
+Issues = "https://github.com/jjdoor/mkschema-py/issues"
+
+[project.scripts]
+mkschema = "mkschema.cli:main"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

mkschema-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

mkschema-0.1.0/src/mkschema/__init__.py

@@ -0,0 +1,3 @@
+"""mkschema — generate a JSON Schema from sample JSON. Zero dependencies."""
+
+__version__ = "0.1.0"

mkschema-0.1.0/src/mkschema/__main__.py

@@ -0,0 +1,6 @@
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

mkschema-0.1.0/src/mkschema/cli.py

@@ -0,0 +1,126 @@
+"""mkschema command-line interface."""
+
+import json
+import re
+import sys
+
+from . import core
+
+VERSION = "0.1.0"
+
+HELP = """mkschema — generate a JSON Schema from sample JSON. Feed several samples to merge.
+
+Usage
+  mkschema <sample.json> [more.json ...]   Infer a schema (multiple files merge as samples)
+  mkschema -                               Read one JSON value from stdin
+  mkschema --ndjson <file|->               Treat each line as a separate sample
+
+Options
+  --title <name>   Set the schema "title"
+  --id <uri>       Set "$id"
+  --ndjson <src>   Merge newline-delimited JSON samples (a file, or - for stdin)
+  -h, --help       Show this help
+  -v, --version    Show version
+
+Merging samples: a key present in EVERY sample is "required"; a key in only some
+is optional; differing types are unioned. Output is a JSON Schema (draft 2020-12)
+written to stdout.
+
+Exit  0 ok · 2 error (no input / invalid JSON / unreadable file)
+"""
+
+
+def fail(msg):
+    sys.stderr.write(f"mkschema: {msg}\n")
+    sys.exit(2)
+
+
+def read_src(path):
+    try:
+        if path == "-":
+            return sys.stdin.buffer.read().decode("utf-8")  # raw read, no newline translation (matches Node)
+        with open(path, "r", encoding="utf-8", newline="") as f:
+            return f.read()
+    except FileNotFoundError:
+        fail(f"cannot read {path}: no such file")
+    except OSError as e:
+        fail(f"cannot read {'stdin' if path == '-' else path}: {e}")
+
+
+def _reject_const(c):
+    raise ValueError(f"{c} is not valid JSON")
+
+
+def parse_json(text, label):
+    try:
+        # parse_constant rejects NaN/Infinity/-Infinity, which JSON.parse also rejects
+        return json.loads(text, parse_constant=_reject_const)
+    except ValueError as e:
+        fail(f"{label}: not valid JSON ({e})")
+
+
+def main(argv=None):
+    try:
+        import signal
+        signal.signal(signal.SIGPIPE, signal.SIG_DFL)  # die quietly on broken pipe (Unix), like Node
+    except (AttributeError, ValueError, OSError):
+        pass
+    argv = list(sys.argv[1:] if argv is None else argv)
+    title = None
+    id_ = None
+    ndjson = None
+    paths = []
+
+    i = 0
+    while i < len(argv):
+        a = argv[i]
+        if a in ("-h", "--help"):
+            sys.stdout.write(HELP)
+            return 0
+        elif a in ("-v", "--version"):
+            sys.stdout.write(VERSION + "\n")
+            return 0
+        elif a == "--title":
+            i += 1
+            if i >= len(argv):
+                fail("--title needs a value")
+            title = argv[i]
+        elif a == "--id":
+            i += 1
+            if i >= len(argv):
+                fail("--id needs a value")
+            id_ = argv[i]
+        elif a == "--ndjson":
+            i += 1
+            if i >= len(argv):
+                fail("--ndjson needs a file or -")
+            ndjson = argv[i]
+        elif a == "-":
+            paths.append("-")
+        elif a.startswith("-"):
+            fail(f"unknown option: {a} (try --help)")
+        else:
+            paths.append(a)
+        i += 1
+
+    samples = []
+    if ndjson is not None:
+        text = read_src(ndjson)
+        label = "stdin" if ndjson == "-" else ndjson
+        n = 0
+        for line in re.split(r"\r?\n", text):
+            if re.fullmatch(r"[ \t\n\v\f\r]*", line):
+                continue
+            n += 1
+            samples.append(parse_json(line, f"{label} line {n}"))
+        if not samples:
+            fail("no JSON samples found in --ndjson input")
+    else:
+        if not paths:
+            fail("no input — pass a JSON file, -, or --ndjson (try --help)")
+        for p in paths:
+            samples.append(parse_json(read_src(p), "stdin" if p == "-" else p))
+
+    schema = core.generate(samples, title=title, id=id_)
+    sys.stdout.write(json.dumps(schema, indent=2, ensure_ascii=False) + "\n")
+    return 0

mkschema-0.1.0/src/mkschema/core.py

@@ -0,0 +1,134 @@
+"""mkschema core — pure JSON Schema inference from samples. No fs, no network.
+
+`infer` turns one JSON value into a schema node; `merge` combines two nodes;
+`generate` reduces many samples into one JSON Schema (draft 2020-12). Feeding
+multiple samples is the point: a key present in *every* sample is `required`, a
+key in only some is optional, and differing types are unioned — so the schema
+fits real data instead of over-fitting one example.
+
+Mirrors the Node build byte-for-byte (same key order, same inference).
+"""
+
+import re
+
+DRAFT = "https://json-schema.org/draft/2020-12/schema"
+
+# String formats, tried in order; ASCII digit classes so both builds agree.
+# `\Z` (absolute end), not `$`, to match JS `$` semantics — Python `$` also matches
+# before a trailing newline, which a JSON `\n`-escaped value could contain.
+_FORMATS = [
+    ("date-time", re.compile(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}[Tt][0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?(?:[Zz]|[+-][0-9]{2}:?[0-9]{2})?\Z")),
+    ("date", re.compile(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}\Z")),
+    ("uuid", re.compile(r"^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\Z")),
+    ("uri", re.compile(r"^[a-zA-Z][a-zA-Z0-9+.\-]*://\S+\Z")),  # before email: URI with userinfo isn't an email
+    ("email", re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+\Z")),
+    ("ipv4", re.compile(r"^(?:[0-9]{1,3}\.){3}[0-9]{1,3}\Z")),
+]
+
+
+def infer_type(v):
+    """JSON type of a value. Numbers are classified by VALUE — 5.0 is an integer —
+    so the Python and Node builds agree."""
+    if v is None:
+        return "null"
+    if isinstance(v, bool):  # bool before int (bool is a subclass of int)
+        return "boolean"
+    if isinstance(v, int):
+        return "integer"
+    if isinstance(v, float):
+        return "integer" if v.is_integer() else "number"
+    if isinstance(v, str):
+        return "string"
+    if isinstance(v, list):
+        return "array"
+    return "object"
+
+
+def infer_format(s):
+    for name, rx in _FORMATS:
+        if rx.match(s):
+            return name
+    return None
+
+
+def infer(v):
+    """Infer a schema node from a single JSON value."""
+    t = infer_type(v)
+    if t == "object":
+        keys = sorted(v.keys())
+        node = {"type": "object", "properties": {k: infer(v[k]) for k in keys}}
+        if keys:
+            node["required"] = list(keys)
+        return node
+    if t == "array":
+        if not v:
+            return {"type": "array"}
+        return {"type": "array", "items": merge_all([infer(e) for e in v])}
+    if t == "string":
+        fmt = infer_format(v)
+        return {"type": "string", "format": fmt} if fmt else {"type": "string"}
+    return {"type": t}
+
+
+def _type_set(node):
+    return list(node["type"]) if isinstance(node["type"], list) else [node["type"]]
+
+
+def merge(a, b):
+    """Merge two schema nodes (objects union props & intersect required; arrays
+    merge items; integer+number → number; mixed types → sorted type array)."""
+    s = set(_type_set(a)) | set(_type_set(b))
+    if "integer" in s and "number" in s:
+        s.discard("integer")
+    types = sorted(s)
+
+    if len(types) == 1:
+        t = types[0]
+        if t == "object":
+            a_props, b_props = a.get("properties", {}), b.get("properties", {})
+            keys = sorted(set(a_props) | set(b_props))
+            properties = {}
+            for k in keys:
+                if k in a_props and k in b_props:
+                    properties[k] = merge(a_props[k], b_props[k])
+                else:
+                    properties[k] = a_props[k] if k in a_props else b_props[k]
+            a_req, b_req = a.get("required", []), b.get("required", [])
+            required = sorted(k for k in a_req if k in b_req)
+            node = {"type": "object", "properties": properties}
+            if required:
+                node["required"] = required
+            return node
+        if t == "array":
+            node = {"type": "array"}
+            if a.get("items") is not None and b.get("items") is not None:
+                node["items"] = merge(a["items"], b["items"])
+            elif a.get("items") is not None or b.get("items") is not None:
+                node["items"] = a.get("items") if a.get("items") is not None else b.get("items")
+            return node
+        if t == "string":
+            node = {"type": "string"}
+            if a.get("format") and a.get("format") == b.get("format"):
+                node["format"] = a["format"]
+            return node
+        return {"type": t}
+    return {"type": types}
+
+
+def merge_all(nodes):
+    acc = None
+    for n in nodes:
+        acc = n if acc is None else merge(acc, n)
+    return acc
+
+
+def generate(samples, title=None, id=None):
+    """Generate a JSON Schema (draft 2020-12) from one or more sample values."""
+    node = merge_all([infer(s) for s in samples])
+    schema = {"$schema": DRAFT}
+    if id:
+        schema["$id"] = id
+    if title:
+        schema["title"] = title
+    schema.update(node)
+    return schema

mkschema-0.1.0/src/mkschema.egg-info/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: mkschema
+Version: 0.1.0
+Summary: Generate a JSON Schema from sample JSON — merge multiple samples (or NDJSON) with type + format inference and required-key detection. Zero dependencies.
+Author: yyfjj
+License: MIT
+Project-URL: Homepage, https://github.com/jjdoor/mkschema-py
+Project-URL: Repository, https://github.com/jjdoor/mkschema-py
+Project-URL: Issues, https://github.com/jjdoor/mkschema-py/issues
+Keywords: json-schema,schema,json,generate,infer,ndjson,openapi,cli,codegen,validation
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Utilities
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# mkschema
+
+**Generate a JSON Schema from real JSON — and feed it more than one sample.**
+You have an API response, a config, a pile of log records, and you want a JSON
+Schema for validation, docs, or contract tests. Hand-writing it is tedious;
+most generators take a *single* example and over-fit it — every field marked
+required, types pinned to whatever that one record happened to contain.
+`mkschema` merges **many** samples: a field in *every* sample is `required`, a
+field in only some is optional, and differing types are unioned. **Zero
+dependencies, no network.**
+
+```bash
+pip install mkschema
+
+$ printf '{"id":1,"name":"Ada","age":30}\n{"id":2,"age":30.5}\n' | mkschema --ndjson -
+
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "properties": {
+    "age":  { "type": "number" },        // 30 and 30.5 unioned to number
+    "id":   { "type": "integer" },
+    "name": { "type": "string" }
+  },
+  "required": ["age", "id"]               // name was missing from the 2nd sample, so it's optional
+}
+```
+
+> This is the Python build. A behavior-equivalent Node build is on npm:
+> `npx mkschema` (<https://github.com/jjdoor/mkschema>).
+
+## Usage
+
+```bash
+mkschema sample.json                 # infer from one file
+mkschema a.json b.json c.json        # merge several samples into one schema
+mkschema --ndjson records.ndjson     # one sample per line (logs, exports)
+cat response.json | mkschema -        # read a JSON value from stdin
+mkschema users.json --title User --id https://ex.com/user.schema.json
+```
+
+Schema goes to **stdout**, so redirect it: `mkschema data.json > schema.json`.
+
+## What it infers
+
+- **Types** — `null`, `boolean`, `integer`, `number`, `string`, `array`,
+  `object`. Numbers are classified by value, so `5.0` is an `integer` and the
+  Python and Node builds agree.
+- **String `format`** — `date-time`, `date`, `email`, `uuid`, `ipv4`, `uri`
+  (kept only when *all* samples of a field agree).
+- **`required`** — the intersection across samples: a key present in every
+  sample. (One sample ⇒ everything required.)
+- **Arrays** — `items` is the merge of all element schemas, so `[1, "x"]`
+  becomes `{ "type": ["integer", "string"] }`.
+- **Unions** — a field that is an integer in one sample and a float in another
+  becomes `number`; genuinely different types become a sorted `type` array.
+
+## Options
+
+| Flag | Effect |
+|------|--------|
+| `--ndjson <src>` | Treat each line of `<src>` (a file, or `-` for stdin) as a separate sample |
+| `--title <name>` | Set the schema `title` |
+| `--id <uri>` | Set `$id` |
+| `-` | Read one JSON value from stdin |
+| `-v`, `--version` · `-h`, `--help` | |
+
+## Notes
+
+- **Output is draft 2020-12** JSON Schema, deterministic (properties and
+  `required` are sorted) so it diffs cleanly in version control.
+- **Same tool, two builds.** A behavior-equivalent Node build is on npm
+  (`npx mkschema`); use whichever your stack has.
+- It infers structure, not constraints — add your own `minLength`, `enum`,
+  `pattern`, etc. afterward. mkschema gives you the scaffold from real data.
+
+## Exit codes
+
+| Code | Meaning |
+|------|---------|
+| `0` | schema written |
+| `2` | error (no input, invalid JSON, unreadable file) |
+
+## License
+
+MIT

mkschema-0.1.0/src/mkschema.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/mkschema/__init__.py
+src/mkschema/__main__.py
+src/mkschema/cli.py
+src/mkschema/core.py
+src/mkschema.egg-info/PKG-INFO
+src/mkschema.egg-info/SOURCES.txt
+src/mkschema.egg-info/dependency_links.txt
+src/mkschema.egg-info/entry_points.txt
+src/mkschema.egg-info/top_level.txt
+tests/test_core.py

mkschema-0.1.0/src/mkschema.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

mkschema-0.1.0/src/mkschema.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mkschema = mkschema.cli:main

mkschema-0.1.0/src/mkschema.egg-info/top_level.txt

@@ -0,0 +1 @@
+mkschema

mkschema-0.1.0/tests/test_core.py

@@ -0,0 +1,85 @@
+from mkschema.core import infer_type, infer_format, infer, merge, merge_all, generate
+
+
+def test_infer_type_by_value():
+    assert infer_type(None) == "null"
+    assert infer_type(True) == "boolean"
+    assert infer_type(5) == "integer"
+    assert infer_type(5.0) == "integer"  # value-based, so Node & Python agree
+    assert infer_type(5.5) == "number"
+    assert infer_type("x") == "string"
+    assert infer_type([]) == "array"
+    assert infer_type({}) == "object"
+
+
+def test_infer_format():
+    assert infer_format("2026-06-19T08:00:00Z") == "date-time"
+    assert infer_format("2026-06-19") == "date"
+    assert infer_format("a@b.co") == "email"
+    assert infer_format("550e8400-e29b-41d4-a716-446655440000") == "uuid"
+    assert infer_format("10.0.0.1") == "ipv4"
+    assert infer_format("https://x.io/y") == "uri"
+    assert infer_format("just a string") is None
+
+
+def test_infer_format_uri_userinfo_and_datetime_anchor():
+    assert infer_format("https://user@github.com/repo") == "uri"   # uri tried before email
+    assert infer_format("https://user:pw@host.com/p") == "uri"
+    assert infer_format("a@b.co") == "email"                       # plain email unaffected
+    assert infer_format("2026-06-19T08:00:00.5+02:00") == "date-time"  # fractional + offset
+    assert infer_format("2026-06-19T08:00:00 then junk") is None   # anchored: trailing junk rejected
+
+
+def test_infer_object_required_sorted_recurse():
+    assert infer({"b": 1, "a": "x"}) == {
+        "type": "object",
+        "properties": {"a": {"type": "string"}, "b": {"type": "integer"}},
+        "required": ["a", "b"],
+    }
+
+
+def test_infer_array_items_merged():
+    assert infer([1, 2, 3]) == {"type": "array", "items": {"type": "integer"}}
+    assert infer([1, "x"]) == {"type": "array", "items": {"type": ["integer", "string"]}}
+    assert infer([]) == {"type": "array"}
+
+
+def test_infer_string_format():
+    assert infer("2026-06-19") == {"type": "string", "format": "date"}
+
+
+def test_merge_integer_number_collapses():
+    assert merge({"type": "integer"}, {"type": "number"}) == {"type": "number"}
+
+
+def test_merge_mixed_types_to_sorted_array():
+    assert merge({"type": "string"}, {"type": "object", "properties": {}}) == {"type": ["object", "string"]}
+
+
+def test_merge_objects_union_props_intersect_required():
+    a = infer({"id": 1, "name": "x"})
+    b = infer({"id": 2, "email": "a@b.co"})
+    m = merge(a, b)
+    assert sorted(m["properties"].keys()) == ["email", "id", "name"]
+    assert m["required"] == ["id"]
+
+
+def test_merge_string_format_only_when_agree():
+    assert merge({"type": "string", "format": "date"}, {"type": "string", "format": "date"}) == {"type": "string", "format": "date"}
+    assert merge({"type": "string", "format": "date"}, {"type": "string", "format": "email"}) == {"type": "string"}
+    assert merge({"type": "string", "format": "date"}, {"type": "string"}) == {"type": "string"}
+
+
+def test_merge_all_required_across_all_samples():
+    m = merge_all([infer({"a": 1, "b": 2}), infer({"a": 1, "b": 2}), infer({"a": 1})])
+    assert m["required"] == ["a"]
+    assert sorted(m["properties"].keys()) == ["a", "b"]
+
+
+def test_generate_wraps_and_orders():
+    s = generate([{"n": 1}], title="Thing", id="https://x/s.json")
+    assert list(s.keys()) == ["$schema", "$id", "title", "type", "properties", "required"]
+    assert s["$schema"] == "https://json-schema.org/draft/2020-12/schema"
+    assert s["title"] == "Thing"
+    assert s["$id"] == "https://x/s.json"
+    assert s["properties"] == {"n": {"type": "integer"}}