docfill 0.1.0__py3-none-any.whl

docfill/__init__.py

@@ -0,0 +1,10 @@
+from importlib.metadata import PackageNotFoundError, version
+
+from .pipeline import fill_workbook
+
+try:
+    __version__ = version("docfill")
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+
+__all__ = ["fill_workbook", "__version__"]

docfill/constants.py

@@ -0,0 +1 @@
+ITEMS_LIST_KEY = "items"

docfill/formulas.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from openpyxl.cell import Cell
+from openpyxl.formula.translate import Translator
+
+
+def is_formula_cell(cell: Cell) -> bool:
+    return cell.data_type == "f" and isinstance(cell.value, str)
+
+
+def translate_formula(formula: str, origin_coord: str, dest_coord: str) -> str:
+    if not formula.startswith("="):
+        formula = "=" + formula
+    return Translator(formula, origin_coord).translate_formula(dest_coord)

docfill/jinja_render.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from typing import Any, Mapping
+
+from jinja2 import Environment, StrictUndefined, TemplateSyntaxError, UndefinedError
+
+
+def build_environment() -> Environment:
+    return Environment(
+        autoescape=False,
+        undefined=StrictUndefined,
+        trim_blocks=True,
+        lstrip_blocks=True,
+    )
+
+
+def template_markers_in_text(s: str) -> bool:
+    return "{{" in s or "{%" in s
+
+
+def render_cell_text(
+    env: Environment,
+    template_str: str,
+    context: Mapping[str, Any],
+    cell_coord: str,
+) -> str:
+    if not template_markers_in_text(template_str):
+        return template_str
+    try:
+        return env.from_string(template_str).render(**context)
+    except UndefinedError as e:
+        raise ValueError(f"{cell_coord}: undefined template variable: {e}") from e
+    except TemplateSyntaxError as e:
+        raise ValueError(f"{cell_coord}: Jinja syntax error: {e}") from e

docfill/pipeline.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Mapping
+
+from jinja2 import Environment
+from openpyxl import load_workbook
+from openpyxl.worksheet.worksheet import Worksheet
+
+from . import jinja_render, row_block
+from .constants import ITEMS_LIST_KEY
+from .row_block import RepeatBlock
+
+
+def _formula_shift_stop_row(
+    blocks_sorted_asc: list[RepeatBlock],
+    block: RepeatBlock,
+) -> int | None:
+    for b in blocks_sorted_asc:
+        if b.template_row > block.template_row:
+            return b.template_row
+    return None
+
+
+def _expand_repeat_blocks(
+    ws: Worksheet,
+    context: Mapping[str, Any],
+    env: Environment,
+    sheet_title: str,
+    blocks: list[RepeatBlock],
+) -> None:
+    blocks_asc = sorted(blocks, key=lambda b: b.template_row)
+    for block in reversed(blocks_asc):
+        raw = context.get(block.list_key)
+        if raw is None:
+            raise ValueError(
+                f"Sheet {sheet_title!r}, row {block.template_row}: template uses list "
+                f"{block.list_key!r}, but context has no such key."
+            )
+        if not isinstance(raw, list):
+            raise TypeError(
+                f"Sheet {sheet_title!r}, context key {block.list_key!r} must be a list, "
+                f"got {type(raw).__name__}"
+            )
+        row_block.expand_template_rows(
+            ws,
+            block.template_row,
+            list(raw),
+            context,
+            block.list_key,
+            env,
+            formula_shift_stop_row_exclusive=_formula_shift_stop_row(blocks_asc, block),
+        )
+
+
+def _expand_auto_items_template(
+    ws: Worksheet,
+    context: Mapping[str, Any],
+    env: Environment,
+    items: list[Any],
+) -> None:
+    try:
+        template_row = row_block.find_template_row(ws)
+    except ValueError:
+        return
+    row_block.expand_template_rows(
+        ws,
+        template_row,
+        list(items),
+        context,
+        ITEMS_LIST_KEY,
+        env,
+    )
+
+
+def _fill_worksheet(ws: Worksheet, context: Mapping[str, Any], env: Environment) -> None:
+    blocks = row_block.find_repeat_blocks(ws)
+    items = context.get(ITEMS_LIST_KEY)
+
+    if blocks:
+        _expand_repeat_blocks(ws, context, env, ws.title, blocks)
+    elif isinstance(items, list) and len(items) > 0:
+        _expand_auto_items_template(ws, context, env, items)
+
+    row_block.render_worksheet_global(ws, context, env)
+
+
+def fill_workbook(
+    template_path: str | Path,
+    output_path: str | Path,
+    context: Mapping[str, Any],
+) -> None:
+    wb = load_workbook(filename=template_path, data_only=False)
+    env = jinja_render.build_environment()
+    for ws in wb.worksheets:
+        _fill_worksheet(ws, context, env)
+    wb.save(output_path)

docfill/row_block.py

@@ -0,0 +1,374 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import re
+from typing import Any, Mapping
+
+from jinja2 import Environment
+from openpyxl.cell import Cell
+from openpyxl.utils import get_column_letter
+from openpyxl.worksheet.worksheet import Worksheet
+
+from . import formulas, jinja_render, styles, values
+from .constants import ITEMS_LIST_KEY
+
+_FOR_RE = re.compile(r"{%\s*for\s+([A-Za-z_]\w*)\s+in\s+([A-Za-z_]\w*)\s*%}")
+_ENDFOR_RE = re.compile(r"{%\s*endfor\s*%}")
+
+
+def render_worksheet_global(
+    ws: Worksheet,
+    context: Mapping[str, Any],
+    env: Environment,
+) -> None:
+    if ws.max_row is None:
+        return
+    min_r, max_r = ws.min_row or 1, ws.max_row
+    min_c, max_c = ws.min_column or 1, ws.max_column or 1
+
+    for r in range(min_r, max_r + 1):
+        for c in range(min_c, max_c + 1):
+            cell = ws.cell(row=r, column=c)
+            coord = cell.coordinate
+            if formulas.is_formula_cell(cell):
+                continue
+            if isinstance(cell.value, str) and jinja_render.template_markers_in_text(cell.value):
+                rendered = jinja_render.render_cell_text(env, cell.value, context, coord)
+                cell.value = values.excel_value_from_rendered_string(rendered)
+
+
+@dataclass
+class _CellSnapshot:
+    col: int
+    is_formula: bool
+    formula_text: str | None
+    text_for_jinja: str | None
+    static_value: Any
+
+
+@dataclass
+class _LoopMarkers:
+    loop_var: str
+    list_key: str
+    endfor_row: int
+
+
+@dataclass(frozen=True)
+class RepeatBlock:
+    template_row: int
+    loop_var: str
+    list_key: str
+    endfor_row: int
+
+
+def _classify_cell(cell: Cell) -> _CellSnapshot | None:
+    col = cell.column
+    if formulas.is_formula_cell(cell):
+        return _CellSnapshot(col, True, str(cell.value), None, None)
+    val = cell.value
+    if val is None and not cell.has_style:
+        return None
+    if isinstance(val, str) and jinja_render.template_markers_in_text(val):
+        return _CellSnapshot(col, False, None, val, None)
+    return _CellSnapshot(col, False, None, None, val)
+
+
+def _row_context(global_ctx: Mapping[str, Any], items_key: str, row_item: Mapping[str, Any]) -> dict[str, Any]:
+    base = {k: v for k, v in global_ctx.items() if k != items_key}
+    return {**base, **row_item, "item": row_item}
+
+
+class _RowLoop:
+    __slots__ = ("_env", "_index0", "_items")
+
+    def __init__(self, env: Environment, index0: int, items: list[Any]) -> None:
+        self._env = env
+        self._index0 = index0
+        self._items = items
+
+    @property
+    def length(self) -> int:
+        return len(self._items)
+
+    @property
+    def index(self) -> int:
+        return self._index0 + 1
+
+    @property
+    def index0(self) -> int:
+        return self._index0
+
+    @property
+    def first(self) -> bool:
+        return self._index0 == 0
+
+    @property
+    def last(self) -> bool:
+        return self._index0 == len(self._items) - 1
+
+    @property
+    def revindex(self) -> int:
+        return len(self._items) - self._index0
+
+    @property
+    def revindex0(self) -> int:
+        return len(self._items) - self._index0 - 1
+
+    @property
+    def depth(self) -> int:
+        return 1
+
+    @property
+    def depth0(self) -> int:
+        return 0
+
+    @property
+    def previtem(self) -> Any:
+        if self._index0 == 0:
+            return self._env.undefined(name="loop.previtem")
+        return self._items[self._index0 - 1]
+
+    @property
+    def nextitem(self) -> Any:
+        if self._index0 >= len(self._items) - 1:
+            return self._env.undefined(name="loop.nextitem")
+        return self._items[self._index0 + 1]
+
+
+def _detect_loop_markers(ws: Worksheet, template_row: int) -> _LoopMarkers | None:
+    open_match: re.Match[str] | None = None
+    max_col = ws.max_column or 1
+
+    for col in range(1, max_col + 1):
+        cell = ws.cell(row=template_row, column=col)
+        val = cell.value
+        if isinstance(val, str):
+            m = _FOR_RE.search(val)
+            if m:
+                open_match = m
+                break
+
+    if open_match is None:
+        return None
+
+    max_row = ws.max_row or template_row
+    end_row: int | None = None
+    for row in range(template_row + 1, max_row + 1):
+        for col in range(1, max_col + 1):
+            val = ws.cell(row=row, column=col).value
+            if isinstance(val, str) and _ENDFOR_RE.search(val):
+                end_row = row
+                break
+        if end_row is not None:
+            break
+
+    if end_row is None:
+        raise ValueError(
+            f"A{template_row}: found '{{% for ... %}}' but matching '{{% endfor %}}' was not found"
+        )
+
+    return _LoopMarkers(
+        loop_var=open_match.group(1),
+        list_key=open_match.group(2),
+        endfor_row=end_row,
+    )
+
+
+def parse_repeat_block_at_row(ws: Worksheet, template_row: int) -> RepeatBlock | None:
+    markers = _detect_loop_markers(ws, template_row)
+    if markers is None:
+        return None
+    return RepeatBlock(
+        template_row=template_row,
+        loop_var=markers.loop_var,
+        list_key=markers.list_key,
+        endfor_row=markers.endfor_row,
+    )
+
+
+def find_repeat_blocks(ws: Worksheet) -> list[RepeatBlock]:
+    max_row = ws.max_row or 1
+    max_col = ws.max_column or 1
+    out: list[RepeatBlock] = []
+    for row in range(1, max_row + 1):
+        has_for = False
+        for col in range(1, max_col + 1):
+            val = ws.cell(row=row, column=col).value
+            if isinstance(val, str) and _FOR_RE.search(val):
+                has_for = True
+                break
+        if not has_for:
+            continue
+        blk = parse_repeat_block_at_row(ws, row)
+        if blk is None:
+            continue
+        out.append(blk)
+    return out
+
+
+def find_template_row(ws: Worksheet) -> int:
+    max_row = ws.max_row or 1
+    max_col = ws.max_column or 1
+
+    for row in range(1, max_row + 1):
+        for col in range(1, max_col + 1):
+            val = ws.cell(row=row, column=col).value
+            if isinstance(val, str):
+                m = _FOR_RE.search(val)
+                if m and m.group(2) == ITEMS_LIST_KEY:
+                    return row
+
+    for row in range(1, max_row + 1):
+        for col in range(1, max_col + 1):
+            val = ws.cell(row=row, column=col).value
+            if isinstance(val, str) and "{{ item." in val:
+                return row
+
+    per_row_counts: list[tuple[int, int]] = []
+    for row in range(1, max_row + 1):
+        cnt = 0
+        for col in range(1, max_col + 1):
+            cell = ws.cell(row=row, column=col)
+            v = cell.value
+            if isinstance(v, str) and jinja_render.template_markers_in_text(v) and not formulas.is_formula_cell(cell):
+                cnt += 1
+        per_row_counts.append((row, cnt))
+
+    best_count = max((c for _, c in per_row_counts), default=0)
+    candidates = [r for r, c in per_row_counts if c == best_count and c > 0]
+
+    if not candidates:
+        raise ValueError(
+            f"Could not detect template row for list key {ITEMS_LIST_KEY!r}. "
+            f"Add a row with a for-tag referencing {ITEMS_LIST_KEY!r}, or {{ item.field }} cells, "
+            "or put several {{ ... }} placeholders on the same data row."
+        )
+
+    if best_count == 1 and len(candidates) > 1:
+        raise ValueError(
+            f"Could not detect template row for list key {ITEMS_LIST_KEY!r}: several rows "
+            f"each have a single '{{' placeholder cell (rows {candidates}), which is ambiguous. "
+            "Mark the data row with `{% for ... in ... %}` or `{{ item.field }}`, "
+            "or use only one Jinja row for list expansion."
+        )
+
+    return max(candidates)
+
+
+def _strip_loop_markers_from_template_row(ws: Worksheet, template_row: int) -> None:
+    max_col = ws.max_column or 1
+    for col in range(1, max_col + 1):
+        cell = ws.cell(row=template_row, column=col)
+        val = cell.value
+        if not isinstance(val, str):
+            continue
+        new_val = _FOR_RE.sub("", val)
+        new_val = _ENDFOR_RE.sub("", new_val)
+        if new_val != val:
+            cell.value = new_val.strip()
+
+
+def _shift_formulas_below(
+    ws: Worksheet,
+    start_row: int,
+    delta_rows: int,
+    stop_row_exclusive: int | None = None,
+) -> None:
+    if delta_rows <= 0:
+        return
+    max_row = ws.max_row or start_row
+    max_col = ws.max_column or 1
+    end_row = max_row if stop_row_exclusive is None else min(max_row, stop_row_exclusive - 1)
+    for row in range(start_row, end_row + 1):
+        for col in range(1, max_col + 1):
+            cell = ws.cell(row=row, column=col)
+            if not formulas.is_formula_cell(cell):
+                continue
+            origin = f"{get_column_letter(col)}{row}"
+            shifted_dest = f"{get_column_letter(col)}{row + delta_rows}"
+            try:
+                cell.value = formulas.translate_formula(str(cell.value), origin, shifted_dest)
+            except Exception as e:
+                raise ValueError(f"{origin}: formula translate failed: {e}") from e
+
+
+def expand_template_rows(
+    ws: Worksheet,
+    template_row: int,
+    items: list[dict[str, Any]],
+    global_ctx: Mapping[str, Any],
+    items_key: str,
+    env: Environment,
+    formula_shift_stop_row_exclusive: int | None = None,
+) -> None:
+    markers = _detect_loop_markers(ws, template_row)
+
+    if markers is not None:
+        if markers.list_key != items_key:
+            raise ValueError(
+                f"A{template_row}: template uses 'for {markers.loop_var} in {markers.list_key}', "
+                f"but this expansion uses list key {items_key!r}"
+            )
+        _strip_loop_markers_from_template_row(ws, template_row)
+
+    if not items:
+        if markers is not None:
+            ws.delete_rows(markers.endfor_row, amount=1)
+        return
+    for it in items:
+        if not isinstance(it, Mapping):
+            raise TypeError(f"Each {items_key!r} entry must be a JSON object, got {type(it).__name__}")
+
+    max_col = ws.max_column or 1
+    snapshots: list[_CellSnapshot] = []
+    for col in range(1, max_col + 1):
+        cell = ws.cell(row=template_row, column=col)
+        snap = _classify_cell(cell)
+        if snap is not None:
+            snapshots.append(snap)
+
+    n = len(items)
+    if n > 1:
+        ws.insert_rows(template_row + 1, amount=n - 1)
+
+    template_h = ws.row_dimensions[template_row].height
+    if template_h is not None:
+        for r in range(n):
+            ws.row_dimensions[template_row + r].height = template_h
+
+    for r, item in enumerate(items):
+        row_idx = template_row + r
+        row_ctx = _row_context(global_ctx, items_key, item)
+        if markers is not None:
+            row_ctx[markers.loop_var] = item
+        row_ctx["loop"] = _RowLoop(env, r, items)
+        for snap in snapshots:
+            col = snap.col
+            coord = f"{get_column_letter(col)}{row_idx}"
+            origin_coord = f"{get_column_letter(col)}{template_row}"
+            src_cell = ws.cell(row=template_row, column=col)
+            dst_cell = ws.cell(row=row_idx, column=col)
+            styles.copy_cell_style(src_cell, dst_cell)
+
+            if snap.is_formula:
+                ft = snap.formula_text or "="
+                try:
+                    translated = formulas.translate_formula(ft, origin_coord, coord)
+                except Exception as e:
+                    raise ValueError(f"{coord}: formula translate failed: {e}") from e
+                dst_cell.value = translated
+            elif snap.text_for_jinja is not None:
+                rendered = jinja_render.render_cell_text(env, snap.text_for_jinja, row_ctx, coord)
+                dst_cell.value = values.excel_value_from_rendered_string(rendered)
+            else:
+                dst_cell.value = snap.static_value
+
+    if markers is not None:
+        shifted_endfor_row = markers.endfor_row + (n - 1)
+        ws.delete_rows(shifted_endfor_row, amount=1)
+        _shift_formulas_below(
+            ws,
+            template_row + n,
+            n - 1,
+            stop_row_exclusive=formula_shift_stop_row_exclusive,
+        )

docfill/styles.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from copy import copy
+
+from openpyxl.cell import Cell
+
+
+def copy_cell_style(src: Cell, dst: Cell) -> None:
+    if not src.has_style:
+        return
+    dst.font = copy(src.font)
+    dst.border = copy(src.border)
+    dst.fill = copy(src.fill)
+    dst.number_format = copy(src.number_format)
+    dst.protection = copy(src.protection)
+    dst.alignment = copy(src.alignment)

docfill/values.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+_INT_RE = re.compile(r"^-?\d+$")
+_FLOAT_DOT_RE = re.compile(r"^-?\d+\.\d+$")
+_FLOAT_COMMA_RE = re.compile(r"^-?\d+,\d+$")
+
+
+def excel_value_from_rendered_string(s: str) -> Any:
+    t = s.strip()
+    if not t:
+        return s
+    if _INT_RE.match(t):
+        return int(t)
+    if _FLOAT_DOT_RE.match(t):
+        return float(t)
+    if _FLOAT_COMMA_RE.match(t):
+        return float(t.replace(",", "."))
+    return s

docfill-0.1.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: docfill
+Version: 0.1.0
+Summary: Library: fill Excel (.xlsx) templates with Jinja2 and optional row expansion from a context dict
+Author: docfill contributors
+License-Expression: MIT
+Project-URL: Homepage, https://pypi.org/project/docfill/
+Keywords: excel,xlsx,openpyxl,jinja2,template,report
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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 :: Office/Business :: Financial :: Spreadsheet
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: openpyxl>=3.1.0
+Requires-Dist: jinja2>=3.1.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Provides-Extra: publish
+Requires-Dist: build>=1.0.0; extra == "publish"
+Requires-Dist: twine>=5.0.0; extra == "publish"
+Dynamic: license-file
+
+# docfill
+
+Заполнение шаблонов Excel (`.xlsx`) через **Jinja2** и опциональное размножение **строки-шаблона** по списку из JSON.
+
+## Установка
+
+```bash
+pip install -e .
+pip install -e ".[dev]"   # опционально: pytest
+```
+
+Тесты без pytest (stdlib):
+
+```bash
+set PYTHONPATH=src
+python -m unittest discover -s tests -p "test_*.py" -v
+```
+
+## Шаблон и контекст
+
+- **Все листы** книги обрабатываются подряд **одним** контекстом; лист без размеченной строки под список и без блоков `{% for %}` получает только глобальный Jinja (если в контексте есть непустой `items`, авторазвёртывание на таком листе **пропускается**, чтобы не падать на пустых листах).
+- **Несколько таблиц на листе:** для каждой пары `{% for var in listKey %}` … `{% endfor %}` в контексте должен быть список `listKey` (например `items`, `items2`). Блоки обрабатываются **снизу вверх**, чтобы вставка строк не сдвигала нижележащие шаблоны. Сдвиг формул под верхней таблицей **не затрагивает** строки нижней (до начала её блока `for`).
+- Если на листе **нет** тегов `{% for %}`, но в контексте есть непустой список по ключу **`items`**, строка-шаблон ищется автоматически: сначала строка с `{{ item.`, иначе строка с **наибольшим** числом ячеек с `{{` (при равенстве — нижняя). Если максимум **1** ячейка и таких строк **несколько** (например шапка «Customer» / «Date» в разных строках), авторазвёртывание **не делается** — только глобальный Jinja; таблицу пометьте `{% for %}` или `{{ item.... }}` на строке данных.
+- Для каждого элемента списка контекст строки = глобальный контекст без этого списка + поля элемента (плоское объединение) + `item` (тот же объект). Работают и `{{ name }}`, и `{{ item.name }}`.
+- Поддерживается шаблон с маркерами цикла в Excel: в строке-шаблоне можно использовать `{% for item in items %}...`, а в следующей строке `{% endfor %}`. Эти служебные маркеры удаляются в результате. В ячейках строки данных доступен объект **`loop`** (как в Jinja): `loop.index`, `loop.index0`, `loop.first` / `loop.last`, `loop.length`, `loop.revindex` / `loop.revindex0`, `loop.previtem` / `loop.nextitem`.
+- Формулы ниже блока цикла (например строка `Итого`) автоматически сдвигаются по относительным ссылкам на число добавленных строк.
+- Значения вида `2`, `10`, `3.5` после Jinja записываются как **числа**, а не текст — иначе `SUM` и другие формулы дают 0.
+- После размножения строк выполняется второй проход по листу: подставляются глобальные плейсхолдеры вне строки-шаблона (например `{{ customer_name }}` в шапке).
+- Формулы в строке-шаблоне копируются со сдвигом относительных ссылок (`openpyxl` `Translator`), как при протягивании в Excel. **Накопительный итог** в колонке (running total): в шаблоне первая строка данных, например строка 2, задайте `=SUM($E$2:E2)` или локально `=СУММ($E$2:E2)` — начало диапазона с **двумя** долларами у строки (`$E$2`). Вариант `=SUM($E2:E2)` после копирования вниз даст `=SUM($E3:E3)` и посчитает только текущую строку; это не ошибка листа или docfill, а формула шаблона.
+- Ячейки-**формулы** Jinja не обрабатывает (только обычный текст в ячейках).
+
+## Библиотека
+
+Установка: `pip install .` из корня репозитория или `pip install -e .` для разработки. Пакет следует [PEP 517](https://peps.python.org/pep-0517/) (`python -m build` при наличии `build`).
+
+```python
+from docfill import fill_workbook
+
+ctx = {"title": "Отчёт", "items": [{"name": "A", "qty": 1}]}
+fill_workbook("template.xlsx", "out.xlsx", ctx)
+```
+
+Контекст всегда передаётся **словарём** (или иным `Mapping`). Прочитать JSON из файла — на стороне вызывающего кода, например `json.loads(Path("context.json").read_text(encoding="utf-8"))`.
+
+## Публикация на PyPI
+
+1. Зарегистрируйте аккаунт на [pypi.org](https://pypi.org). Загрузка **с GitHub Actions** идёт через [trusted publishing](https://docs.pypi.org/trusted-publishers/) (OIDC): в настройках проекта на PyPI добавьте publisher с вашим `owner/repo`, workflow **`publish.yml`**, окружение **`pypi`**. Отдельный API token для CI не нужен. Для ручной загрузки через `twine` можно создать [API token](https://pypi.org/manage/account/token/).
+2. Имя пакета **`docfill`** должно быть свободно на PyPI; при занятости смените `name` в `pyproject.toml`.
+3. При желании добавьте в `pyproject.toml` в `[project.urls]` поля **Repository** и **Issues** (рядом с `Homepage`).
+4. **Версия** в `pyproject.toml` должна совпадать с релизом: при каждом GitHub Release поднимайте `version` иначе PyPI отклонит повтор той же версии.
+5. Сборка и проверка дистрибутивов вручную:
+
+```bash
+pip install -e ".[publish]"
+python -m build
+twine check dist/*
+```
+
+6. Загрузка вручную (тестовый индекс [TestPyPI](https://test.pypi.org) или основной PyPI):
+
+```bash
+twine upload dist/*
+```
+
+Для TestPyPI: `twine upload --repository testpypi dist/*` и установка проверки: `pip install -i https://test.pypi.org/simple/ docfill`.
+
+Лицензия: **MIT** (файл `LICENSE`). Версию перед релизом поднимайте в `pyproject.toml` и синхронно в запасном значении в `docfill/__init__.py` (`PackageNotFoundError`).
+
+## Ограничения
+
+- Нет пересчёта формул при сохранении — результат пересчитает Excel при открытии.
+- Объединённые ячейки в строке-шаблона не поддерживаются.
+- Rich text в ячейке не разбирается как шаблон.

docfill-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+docfill/__init__.py,sha256=wc7XaKPtVxhQsDeqzqcpQULotJNikxN7kKaInFwBpDQ,240
+docfill/constants.py,sha256=R6Xx1vQIVSVVdaxzd8vR1UOZbxDZSfH_3kQmq5TndaU,25
+docfill/formulas.py,sha256=kcl0vQLdTLF6wFPBXfdc03uTFtTxczPX-bsosNPAWWI,450
+docfill/jinja_render.py,sha256=nWMT93kYpxtt4uiNLTTanElnqyzmVF4pLfKJB-eMr8Q,932
+docfill/pipeline.py,sha256=d6i7NqxoSiQtfHYB0jHBJ6SMTFjnBE1IwXglpvNzI7c,2743
+docfill/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+docfill/row_block.py,sha256=sHq8MkFf5wsz7qD_xgAnNqSsfKfSbpWLqyDDFS8WxLo,12088
+docfill/styles.py,sha256=_a22ZsCPpjIc2H3NWZEJKRSqbc90-SRNBYsNb67ymPk,408
+docfill/values.py,sha256=BHd63cLBFx2kg2Ob8WjXC8kPTw8lrRfIHGf3BPTOCx8,487
+docfill-0.1.0.dist-info/licenses/LICENSE,sha256=J0HmzZ1R9_3Ak59wzaxTHLzew86UrwAHOYIl9P0dq64,1077
+docfill-0.1.0.dist-info/METADATA,sha256=U4sMSiuQQFXEawXzakB_x6NGr6Uy2hELrSAWAN4NoXQ,8920
+docfill-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+docfill-0.1.0.dist-info/top_level.txt,sha256=FcapyHjsLhqVv9ZYH7Fqln8i7C7w2Oz6kncuGvJAB7A,8
+docfill-0.1.0.dist-info/RECORD,,

docfill-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

docfill-0.1.0.dist-info/licenses/LICENSE

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

docfill-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+docfill