pydfig 0.1.0__tar.gz

pydfig-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fenglong Li, Siyang Li
+
+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.

pydfig-0.1.0/PKG-INFO

@@ -0,0 +1,154 @@
+Metadata-Version: 2.4
+Name: pydfig
+Version: 0.1.0
+Summary: Self-describing scientific figures (Figure-as-Data): embed exact data in SVG/PNG, decode losslessly to JSON (for AI) and HTML (for humans).
+Author-email: Fenglong Li <15340666394@163.com>, Siyang Li <15340666394@163.com>
+License: MIT
+Project-URL: Homepage, https://pydfig.ai4c/schema
+Keywords: scientific figures,Figure-as-Data,FAIR data,machine-readable,AI4Science,SVG,PNG,metadata
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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 :: Scientific/Engineering :: Visualization
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: matplotlib
+Requires-Dist: matplotlib; extra == "matplotlib"
+Dynamic: license-file
+
+# pydfig — Make your scientific figures carry their own data
+
+A normal chart is just a **picture**. **pydfig** makes the same chart also
+**contain its exact numbers** — so a computer can read them back perfectly,
+without guessing from pixels (no OCR, no digitizing error).
+
+> One sentence: pydfig hides a small JSON with your exact data *inside* the
+> image file. The picture still looks identical; a parser reads the JSON back
+> losslessly.
+
+## Why does this matter?
+
+Scientific figures in papers and PDFs are images. If an AI agent — or a
+colleague — wants the real data points, they usually have to scrape the PDF
+or eyeball the pixels, and both lose precision. pydfig embeds the **exact
+data** inside the figure file itself, invisibly.
+
+## How it works
+
+| Carrier | Where the data lives | Still a normal file? |
+|---------|----------------------|----------------------|
+| **SVG** | the standard `<metadata>` element (renderers ignore it) | ✅ opens in any SVG viewer |
+| **PNG** | a legal private chunk called `dDat` | ✅ opens in any image viewer |
+
+## Two things pydfig does
+
+1. **Encode** — export a PNG or SVG that carries your exact data (from a
+   `payload` dict, or directly from a matplotlib figure).
+2. **Decode** — read a pydfig PNG/SVG and write out:
+   - a **`.json`** file — machine-readable, for AI / data pipelines
+   - an **`.html`** file — human-readable, opens in any browser and shows the
+     data plus a reconstructed plot
+
+## Install
+
+```bash
+pip install pydfig
+# optional: to export directly from a matplotlib figure
+pip install "pydfig[matplotlib]"
+```
+
+The core encode/decode path is **pure Python standard library** — no heavy
+dependencies required.
+
+## Quick start
+
+### Command line
+
+```bash
+# Encode: inject a data JSON into an existing SVG or PNG
+python -m pydfig encode chart.png --payload payload.json -o chart_pydfig.png
+
+# Decode: get back JSON (for AI) + HTML (for humans)
+python -m pydfig decode chart_pydfig.png -o result
+#   result.json  <- exact data, machine-readable
+#   result.html  <- open in a browser to see the data and a reconstructed chart
+```
+
+### In Python
+
+```python
+from pydfig import build_payload, embed_in_svg, inject_png_ddat, decode_any
+
+payload = build_payload(
+    "scatter",
+    points=[{"x": -1.95, "y": 0.42, "material": "NiO"}],
+    axes={"x": {"label": "d-band", "unit": "eV"}},
+    caption="My figure",
+)
+
+svg = embed_in_svg(open("chart.svg").read(), payload)        # data in <metadata>
+png = inject_png_ddat(open("chart.png", "rb").read(), payload)  # data in dDat chunk
+
+data = decode_any("chart_pydfig.png")   # exact, lossless
+```
+
+### From a matplotlib figure (needs the `matplotlib` extra)
+
+```python
+import matplotlib.pyplot as plt
+from pydfig.matplotlib_converter import convert
+
+fig, ax = plt.subplots()
+ax.plot([1, 2, 3], [4, 5, 6])
+ax.set_xlabel("d-band (eV)")
+ax.set_ylabel("E_ads (eV)")
+
+convert(fig, "out.svg", caption="experiment")   # -> out.svg
+convert(fig, "out.png", caption="experiment")   # -> out.png
+```
+
+`convert()` chooses PNG vs SVG automatically from the output file extension.
+
+### Decode to a readable HTML page
+
+```python
+from pydfig import decode_any, write_html
+
+payload = decode_any("out.png")
+write_html(payload, "out.html")   # self-contained, light-theme viewer
+```
+
+## What the embedded data looks like
+
+```json
+{
+  "format": "pydfig",
+  "version": "2.0",
+  "figure_type": "xrd",
+  "caption": "XRD pattern",
+  "axes": {"x": {"label": "2θ", "unit": "degree"}, "y": {"label": "Intensity"}},
+  "points": [{"x": 44.0, "y": 20.0}, {"x": 64.0, "y": 12.0}],
+  "curves": [{"x": [0, 1, 2], "y": [10, 12, 11], "label": "intensity"}]
+}
+```
+
+## Examples
+
+The `examples/` folder ships `demo_volcano`, `demo_xrd`, and `demo_dband` as
+both `.svg` and `.png` — each carrying its exact data. Regenerate them with:
+
+```bash
+python examples/gen_examples.py
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pydfig-0.1.0/README.md

@@ -0,0 +1,128 @@
+# pydfig — Make your scientific figures carry their own data
+
+A normal chart is just a **picture**. **pydfig** makes the same chart also
+**contain its exact numbers** — so a computer can read them back perfectly,
+without guessing from pixels (no OCR, no digitizing error).
+
+> One sentence: pydfig hides a small JSON with your exact data *inside* the
+> image file. The picture still looks identical; a parser reads the JSON back
+> losslessly.
+
+## Why does this matter?
+
+Scientific figures in papers and PDFs are images. If an AI agent — or a
+colleague — wants the real data points, they usually have to scrape the PDF
+or eyeball the pixels, and both lose precision. pydfig embeds the **exact
+data** inside the figure file itself, invisibly.
+
+## How it works
+
+| Carrier | Where the data lives | Still a normal file? |
+|---------|----------------------|----------------------|
+| **SVG** | the standard `<metadata>` element (renderers ignore it) | ✅ opens in any SVG viewer |
+| **PNG** | a legal private chunk called `dDat` | ✅ opens in any image viewer |
+
+## Two things pydfig does
+
+1. **Encode** — export a PNG or SVG that carries your exact data (from a
+   `payload` dict, or directly from a matplotlib figure).
+2. **Decode** — read a pydfig PNG/SVG and write out:
+   - a **`.json`** file — machine-readable, for AI / data pipelines
+   - an **`.html`** file — human-readable, opens in any browser and shows the
+     data plus a reconstructed plot
+
+## Install
+
+```bash
+pip install pydfig
+# optional: to export directly from a matplotlib figure
+pip install "pydfig[matplotlib]"
+```
+
+The core encode/decode path is **pure Python standard library** — no heavy
+dependencies required.
+
+## Quick start
+
+### Command line
+
+```bash
+# Encode: inject a data JSON into an existing SVG or PNG
+python -m pydfig encode chart.png --payload payload.json -o chart_pydfig.png
+
+# Decode: get back JSON (for AI) + HTML (for humans)
+python -m pydfig decode chart_pydfig.png -o result
+#   result.json  <- exact data, machine-readable
+#   result.html  <- open in a browser to see the data and a reconstructed chart
+```
+
+### In Python
+
+```python
+from pydfig import build_payload, embed_in_svg, inject_png_ddat, decode_any
+
+payload = build_payload(
+    "scatter",
+    points=[{"x": -1.95, "y": 0.42, "material": "NiO"}],
+    axes={"x": {"label": "d-band", "unit": "eV"}},
+    caption="My figure",
+)
+
+svg = embed_in_svg(open("chart.svg").read(), payload)        # data in <metadata>
+png = inject_png_ddat(open("chart.png", "rb").read(), payload)  # data in dDat chunk
+
+data = decode_any("chart_pydfig.png")   # exact, lossless
+```
+
+### From a matplotlib figure (needs the `matplotlib` extra)
+
+```python
+import matplotlib.pyplot as plt
+from pydfig.matplotlib_converter import convert
+
+fig, ax = plt.subplots()
+ax.plot([1, 2, 3], [4, 5, 6])
+ax.set_xlabel("d-band (eV)")
+ax.set_ylabel("E_ads (eV)")
+
+convert(fig, "out.svg", caption="experiment")   # -> out.svg
+convert(fig, "out.png", caption="experiment")   # -> out.png
+```
+
+`convert()` chooses PNG vs SVG automatically from the output file extension.
+
+### Decode to a readable HTML page
+
+```python
+from pydfig import decode_any, write_html
+
+payload = decode_any("out.png")
+write_html(payload, "out.html")   # self-contained, light-theme viewer
+```
+
+## What the embedded data looks like
+
+```json
+{
+  "format": "pydfig",
+  "version": "2.0",
+  "figure_type": "xrd",
+  "caption": "XRD pattern",
+  "axes": {"x": {"label": "2θ", "unit": "degree"}, "y": {"label": "Intensity"}},
+  "points": [{"x": 44.0, "y": 20.0}, {"x": 64.0, "y": 12.0}],
+  "curves": [{"x": [0, 1, 2], "y": [10, 12, 11], "label": "intensity"}]
+}
+```
+
+## Examples
+
+The `examples/` folder ships `demo_volcano`, `demo_xrd`, and `demo_dband` as
+both `.svg` and `.png` — each carrying its exact data. Regenerate them with:
+
+```bash
+python examples/gen_examples.py
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

pydfig-0.1.0/pydfig/__init__.py

@@ -0,0 +1,43 @@
+"""
+pydfig — self-describing scientific figures (Figure-as-Data).
+
+A pydfig figure looks like a normal SVG/PNG in any viewer, but carries its
+exact underlying data as structured JSON that parsers and LLM agents read
+losslessly — no OCR, no pixel digitization, no error.
+
+  * SVG -> JSON payload inside the standard W3C <metadata> element
+          (renderers ignore it; parsers/LLMs read it losslessly),
+          plus per-element `data-*` attribute redundancy.
+  * PNG -> JSON payload inside a private ancillary chunk `dDat`
+          (a legal PNG; any viewer opens it).
+
+Pure standard library for encode/decode; matplotlib is an optional extra for
+the matplotlib export helper.
+"""
+
+from .decoder import (
+    decode_svg,
+    decode_png,
+    decode_any,
+    extract_datapoints,
+)
+from .encoder import (
+    build_payload,
+    embed_in_svg,
+    inject_png_ddat,
+    PYDFIG_NS,
+    SCHEMA_VERSION,
+)
+from .html import render_html, write_html
+from .matplotlib_converter import convert, quick_convert
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "decode_svg", "decode_png", "decode_any", "extract_datapoints",
+    "build_payload", "embed_in_svg", "inject_png_ddat",
+    "PYDFIG_NS", "SCHEMA_VERSION",
+    "render_html", "write_html",
+    "convert", "quick_convert",
+    "__version__",
+]

pydfig-0.1.0/pydfig/__main__.py

@@ -0,0 +1,7 @@
+"""Enable ``python -m pydfig ...``."""
+import sys
+
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

pydfig-0.1.0/pydfig/cli.py

@@ -0,0 +1,88 @@
+"""
+pydfig.cli — command line interface.
+
+Usage:
+    python -m pydfig encode <file.svg|file.png> --payload P.json [-o OUT]
+        inject a pydfig payload into an SVG or PNG file.
+
+    python -m pydfig decode <file.svg|file.png> [-o OUT_BASE]
+        decode the payload and write two files:
+          OUT_BASE.json  — machine-readable JSON for AI / pipelines
+          OUT_BASE.html  — human-friendly HTML view of the data
+"""
+
+import argparse
+import json
+import os
+import sys
+
+from .decoder import decode_any
+from .encoder import embed_in_svg, inject_png_ddat
+
+
+def _info(payload):
+    ft = payload.get("figure_type", "?")
+    n_pts = len(payload.get("points", []))
+    n_curves = len(payload.get("curves", []))
+    return f"type={ft}  points={n_pts}  curves={n_curves}"
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(prog="pydfig", description="pydfig self-describing figure toolkit")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p_enc = sub.add_parser("encode", help="inject a pydfig payload into an SVG or PNG")
+    p_enc.add_argument("file", help="input SVG or PNG file")
+    p_enc.add_argument("--payload", required=True, help="JSON file with the pydfig payload")
+    p_enc.add_argument("-o", "--out", default=None, help="output file (default: <input>_pydfig.<ext>)")
+
+    p_dec = sub.add_parser("decode", help="decode payload -> JSON (AI) + HTML (human)")
+    p_dec.add_argument("file", help="input SVG or PNG file")
+    p_dec.add_argument("-o", "--out", default=None, help="output base name (default: <input>_pydfig)")
+
+    args = ap.parse_args(argv)
+
+    if args.cmd == "encode":
+        with open(args.payload, encoding="utf-8") as f:
+            payload = json.load(f)
+        ext = os.path.splitext(args.file)[1].lower()
+        if ext == ".svg":
+            with open(args.file, "r", encoding="utf-8") as f:
+                svg_text = f.read()
+            out = args.out or (os.path.splitext(args.file)[0] + "_pydfig.svg")
+            with open(out, "w", encoding="utf-8") as f:
+                f.write(embed_in_svg(svg_text, payload))
+        elif ext == ".png":
+            with open(args.file, "rb") as f:
+                png_bytes = f.read()
+            out = args.out or (os.path.splitext(args.file)[0] + "_pydfig.png")
+            with open(out, "wb") as f:
+                f.write(inject_png_ddat(png_bytes, payload))
+        else:
+            print("unsupported input extension; use .svg or .png", file=sys.stderr)
+            return 1
+        print("pydfig payload injected ->", out)
+        return 0
+
+    if args.cmd == "decode":
+        payload = decode_any(args.file)
+        if payload is None:
+            print("no pydfig payload found in", args.file, file=sys.stderr)
+            return 1
+        base = args.out or (os.path.splitext(args.file)[0] + "_pydfig")
+        json_path = base + ".json"
+        html_path = base + ".html"
+        with open(json_path, "w", encoding="utf-8") as f:
+            json.dump(payload, f, ensure_ascii=False, indent=2)
+        from .html import write_html
+        write_html(payload, html_path)
+        print("decoded:", _info(payload))
+        print("  ->", json_path, "(machine-readable JSON)")
+        print("  ->", html_path, "(human-friendly HTML)")
+        return 0
+
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

pydfig-0.1.0/pydfig/decoder.py

@@ -0,0 +1,109 @@
+"""
+pydfig.decoder — read pydfig payloads from SVG / PNG files.
+
+Two embedding channels are supported:
+
+1. SVG ``<metadata>`` JSON payload (primary channel).
+2. SVG per-element ``data-*`` attributes (redundancy channel; useful for
+   spot-checking and as a fallback when the metadata block is stripped).
+3. PNG private ancillary chunk ``dDat``.
+"""
+
+import json
+import re
+import struct
+
+_PNG_SIG = b"\x89PNG\r\n\x1a\n"
+
+
+def _read_text(source):
+    """Accept a filesystem path, raw text, or bytes; return text."""
+    if isinstance(source, (bytes, bytearray)):
+        return bytes(source).decode("utf-8")
+    if isinstance(source, str) and source.lstrip().startswith("<"):
+        return source
+    with open(source, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+def decode_svg(source):
+    """Extract the pydfig JSON payload from an SVG file/string.
+
+    Returns the payload dict, or None if no <metadata> payload is present.
+    """
+    text = _read_text(source)
+    m = re.search(r"<metadata>(.*?)</metadata>", text, re.S)
+    if not m:
+        return None
+    inner = m.group(1)
+    cdata = re.search(r"<!\[CDATA\[(.*?)\]\]>", inner, re.S)
+    js = cdata.group(1) if cdata else re.sub(r"<[^>]+>", "", inner)
+    return json.loads(js)
+
+
+def extract_datapoints(source):
+    """Extract per-element ``data-*`` attributes (the redundancy channel).
+
+    Every graphical element a pydfig encoder produces carries its own copy of
+    the underlying values, e.g. ``<circle ... data-x="-1.95" data-y="0.42"
+    data-material="NiO"/>``. This function collects them all.
+
+    Returns a list of dicts; numeric-looking values are converted to float.
+    """
+    text = _read_text(source)
+    out = []
+    for m in re.finditer(r"<(circle|rect|path|line|polyline|text)\b[^>]*>", text):
+        tag = m.group(0)
+        attrs = dict(re.findall(r'(data-[\w-]+)="([^"]*)"', tag))
+        if not attrs:
+            continue
+        rec = {}
+        for k, v in attrs.items():
+            key = k[len("data-"):]
+            try:
+                rec[key] = float(v)
+            except ValueError:
+                rec[key] = v
+        out.append(rec)
+    return out
+
+
+def decode_png(source):
+    """Extract the JSON payload from a PNG ``dDat`` private chunk.
+
+    Accepts a path or raw PNG bytes. Returns the payload dict or None.
+    """
+    if isinstance(source, (bytes, bytearray)):
+        data = bytes(source)
+    else:
+        with open(source, "rb") as f:
+            data = f.read()
+    if data[:8] != _PNG_SIG:
+        raise ValueError("not a PNG/pydfig file")
+    i = 8
+    while i < len(data):
+        length = struct.unpack(">I", data[i:i + 4])[0]
+        ctype = data[i + 4:i + 8]
+        cdata = data[i + 8:i + 8 + length]
+        if ctype == b"dDat":
+            return json.loads(cdata.decode("utf-8"))
+        i += 12 + length
+    return None
+
+
+def decode_any(source):
+    """Auto-detect the container and decode the payload.
+
+    Dispatch order: PNG signature -> SVG text probe.
+    Returns the payload dict or None.
+    """
+    if isinstance(source, (bytes, bytearray)) and bytes(source)[:8] == _PNG_SIG:
+        return decode_png(source)
+    if isinstance(source, str):
+        if source.lstrip().startswith("<"):
+            return decode_svg(source)
+        with open(source, "rb") as f:
+            head = f.read(8)
+        if head == _PNG_SIG:
+            return decode_png(source)
+    return decode_svg(source)

pydfig-0.1.0/pydfig/encoder.py

@@ -0,0 +1,103 @@
+"""
+pydfig.encoder — minimal pydfig writer (pure standard library).
+
+Embedding primitives:
+
+  * ``embed_in_svg``   : insert a <metadata> JSON payload into existing SVG text
+  * ``inject_png_ddat``: insert a `dDat` private chunk into existing PNG bytes
+
+A pydfig figure looks identical to a normal SVG/PNG in any viewer, but carries
+its exact underlying data as structured JSON that parsers and LLM agents read
+losslessly.
+"""
+
+import json
+import re
+import struct
+import zlib
+from datetime import datetime, timezone
+
+PYDFIG_NS = "https://pydfig.ai4c/schema"
+SCHEMA_VERSION = "2.0"
+
+_PNG_SIG = b"\x89PNG\r\n\x1a\n"
+
+
+def build_payload(figure_type, points=None, curves=None, axes=None,
+                  provenance=None, extra=None, caption=None, version=SCHEMA_VERSION):
+    """Construct a pydfig metadata payload.
+
+    Parameters
+    ----------
+    figure_type : str   Semantic figure type (scatter, line, xrd, volcano, ...).
+    points      : list  Exact data points (dicts with numeric x, y).
+    curves      : list  Continuous curves as {"x": [...], "y": [...], "label": ...}.
+    axes        : dict  {"x": {"label", "unit", "range"}, "y": {...}}.
+    provenance  : dict  Free-form domain/technique/method/project metadata.
+    extra       : dict  Domain-specific extension fields.
+    caption     : str   Human-readable figure caption.
+    """
+    payload = {
+        "format": "pydfig",
+        "version": version,
+        "generated_at": datetime.now(timezone.utc).isoformat(),
+        "figure_type": figure_type,
+        "caption": caption or "",
+        "axes": axes or {},
+        "points": points or [],
+        "curves": curves or [],
+        "provenance": provenance or {},
+    }
+    if extra:
+        payload["extra"] = extra
+    return payload
+
+
+def metadata_block(payload):
+    """Render the payload as an SVG <metadata> block (JSON inside CDATA)."""
+    js = json.dumps(payload, ensure_ascii=False, indent=2)
+    return (
+        "<metadata>\n"
+        f'  <pydfig:payload xmlns:pydfig="{PYDFIG_NS}" format="pydfig" '
+        f'version="{payload.get("version", SCHEMA_VERSION)}">\n'
+        f"  <![CDATA[\n{js}\n]]>\n"
+        "  </pydfig:payload>\n"
+        "</metadata>\n"
+    )
+
+
+def embed_in_svg(svg_text, payload):
+    """Insert a pydfig <metadata> block right after the root <svg ...> tag.
+
+    The visual content is untouched: every compliant SVG renderer ignores
+    <metadata>, so the figure looks identical while becoming machine-readable.
+    """
+    if "<metadata>" in svg_text:
+        raise ValueError("SVG already contains a <metadata> block; refusing to duplicate")
+    m = re.search(r"<svg\b[^>]*>", svg_text)
+    if m is None:
+        raise ValueError("no root <svg> tag found")
+    insert_at = m.end()
+    return svg_text[:insert_at] + metadata_block(payload) + svg_text[insert_at:]
+
+
+def _chunk(chunk_type, data):
+    return (struct.pack(">I", len(data)) + chunk_type + data
+            + struct.pack(">I", zlib.crc32(chunk_type + data) & 0xFFFFFFFF))
+
+
+def inject_png_ddat(png_bytes, payload):
+    """Insert a `dDat` private chunk (JSON payload) before IEND; return new PNG bytes.
+
+    `dDat` is a legal ancillary/private PNG chunk (lowercase second letter),
+    so the result remains a valid PNG that any viewer can open.
+    """
+    png_bytes = bytes(png_bytes)
+    if png_bytes[:8] != _PNG_SIG:
+        raise ValueError("not a PNG file")
+    idx = png_bytes.rfind(b"IEND")
+    if idx < 4:
+        raise ValueError("PNG has no IEND chunk")
+    chunk_start = idx - 4  # step back to the IEND length field
+    ddat = _chunk(b"dDat", json.dumps(payload, ensure_ascii=False).encode("utf-8"))
+    return png_bytes[:chunk_start] + ddat + png_bytes[chunk_start:]