namz 1.0.0__tar.gz

namz-1.0.0/.gitignore

@@ -0,0 +1,13 @@
+# Python build / cache artifacts
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.tox/
+.venv/
+venv/

namz-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Oleh Tsymaienko <oleh@darwinscat.com> & Alisa Lafoks <alisa@darwinscat.com> (Darwin's Cat)
+
+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.

namz-1.0.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: namz
+Version: 1.0.0
+Summary: Lossless codec for NeuralAmpModeler .nam files — ~5.5x smaller, bit-exact float32, deterministic.
+Project-URL: Homepage, https://github.com/darwinscat/namz
+Project-URL: Repository, https://github.com/darwinscat/namz
+Project-URL: Wire format, https://github.com/darwinscat/namz/blob/main/NAMZ-FORMAT.md
+Author-email: Oleh Tsymaienko <oleh@darwinscat.com>, Alisa Lafoks <alisa@darwinscat.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: audio,codec,dsp,float32,guitar,nam,neural-amp-modeler
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: numpy>=1.21
+Provides-Extra: test
+Requires-Dist: pytest>=7; extra == 'test'
+Description-Content-Type: text/markdown
+
+<!-- SPDX-License-Identifier: MIT -->
+# namz (Python)
+
+Lossless codec for [NeuralAmpModeler](https://github.com/sdatkinson/neural-amp-modeler) `.nam` files.
+
+A `.nam` is JSON whose bulk is one or more flat `"weights"` arrays written as ~20-character decimal
+strings — which the NAM engine loads into `float32` **anyway**. `.namz` stores each weight as a 4-byte
+float32 instead: **≈5.5× smaller**, **bit-exact** to what the engine computes, and **deterministic**
+(no compression → byte-identical across runs, platforms, and languages). A small readable header exposes
+tone/gear/device metadata without decoding the weights.
+
+This package is a **native Python port** of the C++ reference and is **byte-for-byte compatible** with it
+and with every other port — it is validated against the shared [conformance vectors](https://github.com/darwinscat/namz/tree/main/conformance)
+(the cross-language TCK).
+
+## Install
+
+```bash
+pip install namz
+```
+
+Requires Python ≥ 3.9 and NumPy.
+
+## Library
+
+```python
+import namz
+
+nam = b'{"architecture":"WaveNet","weights":[0.5,-0.5,0.25]}'
+
+blob = namz.pack(nam)                 # -> .namz bytes
+assert namz.is_namz(blob)
+assert namz.unpack(blob) == nam       # lossless to float32
+
+# Stamp a readable metadata header (typed: "true"/"false" -> bool, digits -> int, else string):
+opts = namz.PackOptions(metadata={"tone_type": "hi-gain", "boost": "true", "device": "tube:1,pnp:1"})
+blob = namz.pack(nam, opts)
+namz.read_meta(blob)   # {'tone_type': 'hi-gain', 'boost': 'true', 'device': 'tube:1,pnp:1'} — no weight decode
+```
+
+### API
+
+| function | description |
+|---|---|
+| `pack(nam_json, options=None) -> bytes` | `.nam` JSON (str/bytes) → `.namz`. `b""` on invalid JSON. |
+| `unpack(data, max_json_bytes=256MiB) -> bytes` | `.namz` → `.nam` JSON. `b""` on corruption / over-cap. Never raises. |
+| `read_meta(data) -> dict[str, str]` | display header without touching weights. `{}` for v1 / non-`.namz`. |
+| `is_namz(data) -> bool` | cheap magic check. |
+| `PackOptions(shuffle=True, metadata={})` | packing options. |
+
+`unpack` is total: for **any** input bytes it returns `bytes` (empty on failure) and never raises.
+
+## CLI
+
+```bash
+namz encode in.nam out.namz [--no-shuffle] [--set key=value ...]
+namz decode in.namz out.nam
+namz map    in.namz [--json]        # print the metadata header (no weight decode)
+namz verify in.nam                  # pack->unpack round-trip check + ratio
+```
+
+(Also available as `python -m namz`.)
+
+## Guarantees
+
+- **Lossless to float32** — `unpack(pack(x))` is bit-exact at any nesting depth, including `-0.0`,
+  subnormals, and `FLT_MAX`.
+- **Deterministic** — `pack(x)` is byte-identical across runs and platforms; the codec is idempotent.
+- **Robust** — every malformed input (bad magic, unknown version/codec/dtype, truncation, trailing junk,
+  a lying `metaLen`/`numArrays`, an over-cap body) is rejected cleanly.
+
+### Byte-match note
+
+The skeleton is minified JSON with keys sorted ascending, matching the reference (nlohmann). It is
+validated byte-for-byte against the reference over the whole NAM domain (a large differential fuzz —
+config integers, simple decimals, non-ASCII, control chars, nesting). The weight payload itself is always
+exact float32, never text. Two documented edges, both outside the NAM domain:
+
+- Non-finite weights (`NaN`/`±Inf`) are out of contract and are **rejected**, exactly as the reference
+  rejects them.
+- An integer literal outside `[int64_min, uint64_max]` in a *non-weight* field is coerced to a double, as
+  nlohmann does; this is byte-exact for double-representable magnitudes (e.g. `2**64`). For extreme
+  23+-digit integers nlohmann's own parser rounds imprecisely and may differ by one ULP — such values
+  never occur in NAM config.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest                      # runs the shared conformance vectors + property fuzz + adversarial suite
+```
+
+Versioned independently of the C++ reference; tracks **wire format version 2**.
+
+## License
+
+MIT — see [LICENSE](LICENSE). © 2026 Oleh Tsymaienko &lt;oleh@darwinscat.com&gt; &amp; Alisa Lafoks
+&lt;alisa@darwinscat.com&gt; (Darwin's Cat).

namz-1.0.0/README.md

@@ -0,0 +1,98 @@
+<!-- SPDX-License-Identifier: MIT -->
+# namz (Python)
+
+Lossless codec for [NeuralAmpModeler](https://github.com/sdatkinson/neural-amp-modeler) `.nam` files.
+
+A `.nam` is JSON whose bulk is one or more flat `"weights"` arrays written as ~20-character decimal
+strings — which the NAM engine loads into `float32` **anyway**. `.namz` stores each weight as a 4-byte
+float32 instead: **≈5.5× smaller**, **bit-exact** to what the engine computes, and **deterministic**
+(no compression → byte-identical across runs, platforms, and languages). A small readable header exposes
+tone/gear/device metadata without decoding the weights.
+
+This package is a **native Python port** of the C++ reference and is **byte-for-byte compatible** with it
+and with every other port — it is validated against the shared [conformance vectors](https://github.com/darwinscat/namz/tree/main/conformance)
+(the cross-language TCK).
+
+## Install
+
+```bash
+pip install namz
+```
+
+Requires Python ≥ 3.9 and NumPy.
+
+## Library
+
+```python
+import namz
+
+nam = b'{"architecture":"WaveNet","weights":[0.5,-0.5,0.25]}'
+
+blob = namz.pack(nam)                 # -> .namz bytes
+assert namz.is_namz(blob)
+assert namz.unpack(blob) == nam       # lossless to float32
+
+# Stamp a readable metadata header (typed: "true"/"false" -> bool, digits -> int, else string):
+opts = namz.PackOptions(metadata={"tone_type": "hi-gain", "boost": "true", "device": "tube:1,pnp:1"})
+blob = namz.pack(nam, opts)
+namz.read_meta(blob)   # {'tone_type': 'hi-gain', 'boost': 'true', 'device': 'tube:1,pnp:1'} — no weight decode
+```
+
+### API
+
+| function | description |
+|---|---|
+| `pack(nam_json, options=None) -> bytes` | `.nam` JSON (str/bytes) → `.namz`. `b""` on invalid JSON. |
+| `unpack(data, max_json_bytes=256MiB) -> bytes` | `.namz` → `.nam` JSON. `b""` on corruption / over-cap. Never raises. |
+| `read_meta(data) -> dict[str, str]` | display header without touching weights. `{}` for v1 / non-`.namz`. |
+| `is_namz(data) -> bool` | cheap magic check. |
+| `PackOptions(shuffle=True, metadata={})` | packing options. |
+
+`unpack` is total: for **any** input bytes it returns `bytes` (empty on failure) and never raises.
+
+## CLI
+
+```bash
+namz encode in.nam out.namz [--no-shuffle] [--set key=value ...]
+namz decode in.namz out.nam
+namz map    in.namz [--json]        # print the metadata header (no weight decode)
+namz verify in.nam                  # pack->unpack round-trip check + ratio
+```
+
+(Also available as `python -m namz`.)
+
+## Guarantees
+
+- **Lossless to float32** — `unpack(pack(x))` is bit-exact at any nesting depth, including `-0.0`,
+  subnormals, and `FLT_MAX`.
+- **Deterministic** — `pack(x)` is byte-identical across runs and platforms; the codec is idempotent.
+- **Robust** — every malformed input (bad magic, unknown version/codec/dtype, truncation, trailing junk,
+  a lying `metaLen`/`numArrays`, an over-cap body) is rejected cleanly.
+
+### Byte-match note
+
+The skeleton is minified JSON with keys sorted ascending, matching the reference (nlohmann). It is
+validated byte-for-byte against the reference over the whole NAM domain (a large differential fuzz —
+config integers, simple decimals, non-ASCII, control chars, nesting). The weight payload itself is always
+exact float32, never text. Two documented edges, both outside the NAM domain:
+
+- Non-finite weights (`NaN`/`±Inf`) are out of contract and are **rejected**, exactly as the reference
+  rejects them.
+- An integer literal outside `[int64_min, uint64_max]` in a *non-weight* field is coerced to a double, as
+  nlohmann does; this is byte-exact for double-representable magnitudes (e.g. `2**64`). For extreme
+  23+-digit integers nlohmann's own parser rounds imprecisely and may differ by one ULP — such values
+  never occur in NAM config.
+
+## Development
+
+```bash
+pip install -e ".[test]"
+pytest                      # runs the shared conformance vectors + property fuzz + adversarial suite
+```
+
+Versioned independently of the C++ reference; tracks **wire format version 2**.
+
+## License
+
+MIT — see [LICENSE](LICENSE). © 2026 Oleh Tsymaienko &lt;oleh@darwinscat.com&gt; &amp; Alisa Lafoks
+&lt;alisa@darwinscat.com&gt; (Darwin's Cat).

namz-1.0.0/conformance/README.md

@@ -0,0 +1,49 @@
+<!-- SPDX-License-Identifier: MIT -->
+# Conformance vectors — the cross-language TCK
+
+These files are the **contract every language implementation of namz must satisfy.** They are how a
+Python / JS / Rust / … port proves it is byte-for-byte compatible with the C++ reference — no port is
+"the" binary; the vectors are the source of truth.
+
+```
+manifest.json         machine-readable description of every case
+vectors/<name>.nam    a valid input
+vectors/<name>.namz   the reference output — your encode() must produce these exact bytes
+invalid/<name>.namz   malformed — your decode() must reject it (error/empty), never crash
+generate.py           regenerates everything from the reference CLI (see below)
+```
+
+## What a port must check
+
+For every entry in `manifest.json["valid"]`:
+1. **encode** the `input` with the given `shuffle` flag and `set` metadata → must **byte-match** `output`.
+2. **decode** the `output` → the weights must be **bit-exact** float32.
+3. decode→encode must reproduce `output` (idempotence).
+
+For every entry in `manifest.json["invalid"]`:
+- **decode** the file → must be **rejected** (empty/error) and must not crash or hang.
+
+Plus each port should add its own **local property fuzz** (generate N random finite float32, round-trip,
+assert bit-exact) — that part isn't shared bytes, it's a per-language property.
+
+## Byte-match gotchas (why an encode might differ)
+
+- The skeleton is **minified JSON with object keys sorted ascending** (the reference uses nlohmann, which
+  sorts). Match it — Python: `json.dumps(obj, sort_keys=True, separators=(",", ":"))`; JS: `JSON.stringify`
+  does **not** sort, so you need a sorted+compact stringify.
+- Integers are **little-endian**; the float payload is **IEEE-754 little-endian** (numpy:
+  `arr.astype("<f4").tobytes()`).
+- The byte-plane **shuffle**: split each float's 4 bytes into 4 contiguous planes on encode; reverse on
+  decode (see `shuffleInto`/`unshuffleInto` in `include/namz.h`).
+
+If a language genuinely cannot match key order, rely on **decode-bit-exact + idempotence** and document it
+— never edit a golden file to fit a buggy port.
+
+## Regenerating
+
+```bash
+cmake --build build            # builds the reference CLI at build/namz
+python3 conformance/generate.py build/namz
+```
+
+The reference C++ consumer is `tests/conformance.cpp` (run via `ctest -R namz_conformance`).

namz-1.0.0/conformance/generate.py

@@ -0,0 +1,95 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: MIT
+# Generate the namz conformance vectors (the cross-language TCK) using the reference CLI.
+# Usage: python3 conformance/generate.py [path-to-namz-cli]   (default: build/namz)
+#
+# Emits, relative to this file's directory:
+#   vectors/<name>.nam   valid input
+#   vectors/<name>.namz  reference output (from the CLI) — a port's encode must byte-match this
+#   invalid/<name>.namz  malformed — a port's decode must reject it (error, never crash)
+#   manifest.json        machine-readable description every port iterates
+#
+# Commit the outputs. Any language port validates against these files; if it diverges by one byte, it's wrong.
+
+import json, os, struct, subprocess, sys, math
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+CLI = sys.argv[1] if len(sys.argv) > 1 else os.path.join(HERE, "..", "build", "namz")
+VEC = os.path.join(HERE, "vectors")
+INV = os.path.join(HERE, "invalid")
+os.makedirs(VEC, exist_ok=True)
+os.makedirs(INV, exist_ok=True)
+
+def f32(x):  # nearest float32, as a python float (so json emits a value that reparses to the same float32)
+    return struct.unpack("f", struct.pack("f", x))[0]
+
+FLT_MAX = 3.4028234663852886e+38
+SUBNORMAL = 1.401298464324817e-45          # denorm_min
+MIN_NORMAL = 1.1754943508222875e-38
+
+# ---- valid cases: (name, json-object, options) ; options = {"shuffle": bool, "set": {k: v}} -----------
+valid = [
+    ("flat",            {"architecture": "WaveNet", "weights": [0.5, -0.5, 0.25]},                      {"shuffle": True}),
+    ("flat-noshuffle",  {"architecture": "WaveNet", "weights": [0.5, -0.5, 0.25]},                      {"shuffle": False}),
+    ("nested",          {"architecture": "SlimmableContainer", "sample_rate": 48000,
+                         "config": {"submodels": [{"max_value": 0.5,
+                             "model": {"architecture": "WaveNet", "weights": [0.1, -0.25, 12.5]}}]},
+                         "weights": [1.0, -1.0]},                                                        {"shuffle": True}),
+    ("metadata",        {"architecture": "WaveNet", "weights": [0.5]},
+                        {"shuffle": True, "set": {"tone_type": "hi-gain", "boost": "true",
+                                                  "device": "tube:1,pnp:1", "gear_make": "Two Notes"}}),
+    ("no-weights",      {"architecture": "LSTM", "sample_rate": 44100, "metadata": {"loudness": -18.0}}, {"shuffle": True}),
+    ("empty-weights",   {"architecture": "X", "weights": []},                                            {"shuffle": True}),
+    ("edge-floats",     {"architecture": "X", "weights": [0.0, -0.0, f32(SUBNORMAL), f32(MIN_NORMAL),
+                                                          f32(FLT_MAX), -f32(FLT_MAX), f32(1.0/3.0)]},   {"shuffle": True}),
+    ("integer-weights", {"architecture": "X", "weights": [0, 1, -1, 16777216, -16777216]},               {"shuffle": True}),
+    ("degenerate-array", [1, 2, 3],                                                                       {"shuffle": True}),
+]
+
+def run(args):
+    r = subprocess.run(args, capture_output=True, text=True)
+    if r.returncode != 0:
+        sys.exit("CLI failed: %s\n%s" % (" ".join(args), r.stderr))
+
+manifest = {"format": "namz", "note": "Cross-language conformance vectors. Encode a valid input with the "
+            "given options and it must BYTE-MATCH the .namz; decode the .namz and the weights must be "
+            "bit-exact float32. Every invalid .namz must be rejected (empty/error, never crash).",
+            "valid": [], "invalid": []}
+
+for name, obj, opts in valid:
+    nam = os.path.join(VEC, name + ".nam")
+    out = os.path.join(VEC, name + ".namz")
+    with open(nam, "w") as f:
+        json.dump(obj, f, separators=(",", ":"))
+    args = [CLI, "encode", nam, out]
+    if not opts.get("shuffle", True):
+        args.append("--no-shuffle")
+    for k, v in opts.get("set", {}).items():
+        args += ["--set", "%s=%s" % (k, v)]
+    run(args)
+    manifest["valid"].append({"name": name, "input": "vectors/%s.nam" % name,
+                              "output": "vectors/%s.namz" % name,
+                              "shuffle": opts.get("shuffle", True), "set": opts.get("set", {})})
+
+# ---- invalid cases: derive from a valid blob so they're realistic ------------------------------------
+base = open(os.path.join(VEC, "flat.namz"), "rb").read()
+
+def write_invalid(name, blob, why):
+    open(os.path.join(INV, name + ".namz"), "wb").write(blob)
+    manifest["invalid"].append({"name": name, "file": "invalid/%s.namz" % name, "why": why})
+
+write_invalid("bad-magic",     b"XAMZ" + base[4:],                    "magic corrupted")
+write_invalid("bad-version",   base[:4] + bytes([9]) + base[5:],      "formatVersion 9 (> 2) must be refused")
+write_invalid("bad-codec",     base[:5] + bytes([1]) + base[6:],      "codec 1 (deflate, reserved) must be refused")
+write_invalid("bad-dtype",     base[:6] + bytes([1]) + base[7:],      "dtype 1 (float16, reserved) must be refused")
+write_invalid("truncated",     base[:len(base) - 3],                  "body truncated — exact-length check must reject")
+write_invalid("trailing-junk", base + b"junk",                        "extra bytes — exact-length check must reject")
+write_invalid("lying-metalen", base[:8] + b"\xff\xff" + base[10:],    "metaLen far bigger than the buffer")
+write_invalid("empty",         b"",                                   "empty buffer")
+write_invalid("magic-only",    b"NAMZ",                               "header too short")
+
+with open(os.path.join(HERE, "manifest.json"), "w") as f:
+    json.dump(manifest, f, indent=2)
+    f.write("\n")
+
+print("generated %d valid + %d invalid vectors" % (len(manifest["valid"]), len(manifest["invalid"])))

namz-1.0.0/conformance/invalid/magic-only.namz

@@ -0,0 +1 @@
+NAMZ

namz-1.0.0/conformance/manifest.json

@@ -0,0 +1,121 @@
+{
+  "format": "namz",
+  "note": "Cross-language conformance vectors. Encode a valid input with the given options and it must BYTE-MATCH the .namz; decode the .namz and the weights must be bit-exact float32. Every invalid .namz must be rejected (empty/error, never crash).",
+  "valid": [
+    {
+      "name": "flat",
+      "input": "vectors/flat.nam",
+      "output": "vectors/flat.namz",
+      "shuffle": true,
+      "set": {}
+    },
+    {
+      "name": "flat-noshuffle",
+      "input": "vectors/flat-noshuffle.nam",
+      "output": "vectors/flat-noshuffle.namz",
+      "shuffle": false,
+      "set": {}
+    },
+    {
+      "name": "nested",
+      "input": "vectors/nested.nam",
+      "output": "vectors/nested.namz",
+      "shuffle": true,
+      "set": {}
+    },
+    {
+      "name": "metadata",
+      "input": "vectors/metadata.nam",
+      "output": "vectors/metadata.namz",
+      "shuffle": true,
+      "set": {
+        "tone_type": "hi-gain",
+        "boost": "true",
+        "device": "tube:1,pnp:1",
+        "gear_make": "Two Notes"
+      }
+    },
+    {
+      "name": "no-weights",
+      "input": "vectors/no-weights.nam",
+      "output": "vectors/no-weights.namz",
+      "shuffle": true,
+      "set": {}
+    },
+    {
+      "name": "empty-weights",
+      "input": "vectors/empty-weights.nam",
+      "output": "vectors/empty-weights.namz",
+      "shuffle": true,
+      "set": {}
+    },
+    {
+      "name": "edge-floats",
+      "input": "vectors/edge-floats.nam",
+      "output": "vectors/edge-floats.namz",
+      "shuffle": true,
+      "set": {}
+    },
+    {
+      "name": "integer-weights",
+      "input": "vectors/integer-weights.nam",
+      "output": "vectors/integer-weights.namz",
+      "shuffle": true,
+      "set": {}
+    },
+    {
+      "name": "degenerate-array",
+      "input": "vectors/degenerate-array.nam",
+      "output": "vectors/degenerate-array.namz",
+      "shuffle": true,
+      "set": {}
+    }
+  ],
+  "invalid": [
+    {
+      "name": "bad-magic",
+      "file": "invalid/bad-magic.namz",
+      "why": "magic corrupted"
+    },
+    {
+      "name": "bad-version",
+      "file": "invalid/bad-version.namz",
+      "why": "formatVersion 9 (> 2) must be refused"
+    },
+    {
+      "name": "bad-codec",
+      "file": "invalid/bad-codec.namz",
+      "why": "codec 1 (deflate, reserved) must be refused"
+    },
+    {
+      "name": "bad-dtype",
+      "file": "invalid/bad-dtype.namz",
+      "why": "dtype 1 (float16, reserved) must be refused"
+    },
+    {
+      "name": "truncated",
+      "file": "invalid/truncated.namz",
+      "why": "body truncated \u2014 exact-length check must reject"
+    },
+    {
+      "name": "trailing-junk",
+      "file": "invalid/trailing-junk.namz",
+      "why": "extra bytes \u2014 exact-length check must reject"
+    },
+    {
+      "name": "lying-metalen",
+      "file": "invalid/lying-metalen.namz",
+      "why": "metaLen far bigger than the buffer"
+    },
+    {
+      "name": "empty",
+      "file": "invalid/empty.namz",
+      "why": "empty buffer"
+    },
+    {
+      "name": "magic-only",
+      "file": "invalid/magic-only.namz",
+      "why": "header too short"
+    }
+  ]
+}

namz-1.0.0/conformance/vectors/degenerate-array.nam

@@ -0,0 +1 @@
+[1,2,3]

namz-1.0.0/conformance/vectors/edge-floats.nam

@@ -0,0 +1 @@
+{"architecture":"X","weights":[0.0,-0.0,1.401298464324817e-45,1.1754943508222875e-38,3.4028234663852886e+38,-3.4028234663852886e+38,0.3333333432674408]}

namz-1.0.0/conformance/vectors/empty-weights.nam

@@ -0,0 +1 @@
+{"architecture":"X","weights":[]}

namz-1.0.0/conformance/vectors/flat-noshuffle.nam

@@ -0,0 +1 @@
+{"architecture":"WaveNet","weights":[0.5,-0.5,0.25]}

namz-1.0.0/conformance/vectors/flat.nam

@@ -0,0 +1 @@
+{"architecture":"WaveNet","weights":[0.5,-0.5,0.25]}

namz-1.0.0/conformance/vectors/integer-weights.nam

@@ -0,0 +1 @@
+{"architecture":"X","weights":[0,1,-1,16777216,-16777216]}

namz-1.0.0/conformance/vectors/metadata.nam

@@ -0,0 +1 @@
+{"architecture":"WaveNet","weights":[0.5]}

namz-1.0.0/conformance/vectors/nested.nam

@@ -0,0 +1 @@
+{"architecture":"SlimmableContainer","sample_rate":48000,"config":{"submodels":[{"max_value":0.5,"model":{"architecture":"WaveNet","weights":[0.1,-0.25,12.5]}}]},"weights":[1.0,-1.0]}

namz-1.0.0/conformance/vectors/no-weights.nam

@@ -0,0 +1 @@
+{"architecture":"LSTM","sample_rate":44100,"metadata":{"loudness":-18.0}}