aa46e7ad4a
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01BJKMLHdxMwSUeYcdkwqX4W
195 lines
8.4 KiB
Python
195 lines
8.4 KiB
Python
"""Сумма и значение ячейки (шаг 4): `parse_amount` — единственное место, где разбор зависит от источника."""
|
||
|
||
import re
|
||
from dataclasses import dataclass
|
||
from datetime import date
|
||
from decimal import ROUND_HALF_UP, Decimal
|
||
|
||
from arm_statements.codes import code_parts
|
||
from arm_statements.loader import Rules
|
||
from arm_statements.model import Cell, SignForm, Source, StatementValue
|
||
from arm_statements.text import replace_lookalikes
|
||
|
||
MAX_INTEGER_DIGITS = 16
|
||
_CENT = Decimal("0.01")
|
||
_DIGITS = frozenset("0123456789")
|
||
_CORE_START = _DIGITS | frozenset("(-−+")
|
||
_CORE_END = _DIGITS | frozenset(")}]")
|
||
_DASHES = frozenset("-–—−")
|
||
_MINUSES = frozenset("-−")
|
||
_BODY = re.compile(r"[\d\s,.]*")
|
||
_DIGIT_SPACE_RUN = re.compile(r"\d+(?:\s+\d+)+")
|
||
_SPACE_GROUPS = re.compile(r"\d{1,3}(?:\s\d{3})+")
|
||
_COMMA_THOUSANDS = re.compile(r"[1-9]\d{0,2}(?:,\d{3})+")
|
||
_DOT_THOUSANDS = re.compile(r"[1-9]\d*(?:\.\d{3})+")
|
||
_SEPARATORS = ",."
|
||
|
||
|
||
@dataclass(frozen=True, slots=True)
|
||
class AmountParse:
|
||
amount: Decimal | None
|
||
string_value: str | None
|
||
is_recognized: bool
|
||
sign_form: SignForm | None
|
||
|
||
|
||
@dataclass(frozen=True, slots=True)
|
||
class ValueBuild:
|
||
value: StatementValue
|
||
out_of_range: bool
|
||
|
||
|
||
def _quantize(amount: Decimal) -> Decimal:
|
||
return amount.quantize(_CENT, rounding=ROUND_HALF_UP)
|
||
|
||
|
||
def _too_long(amount: Decimal) -> bool:
|
||
return len(str(abs(int(amount)))) > MAX_INTEGER_DIGITS
|
||
|
||
|
||
def _is_blank(text: str) -> bool:
|
||
return all(char.isspace() or char in _DASHES for char in text)
|
||
|
||
|
||
def _strip_edge_bars(text: str) -> tuple[str, bool]:
|
||
"""Крайние `|` (след границы таблицы) — до замены двойников; второй элемент — было ли удаление."""
|
||
stripped = text.strip()
|
||
while stripped.startswith("|"):
|
||
stripped = stripped[1:].strip()
|
||
while stripped.endswith("|"):
|
||
stripped = stripped[:-1].strip()
|
||
return stripped, stripped != text.strip()
|
||
|
||
|
||
def _core_bounds(text: str) -> tuple[int, int] | None:
|
||
starts = [index for index, char in enumerate(text) if char in _CORE_START]
|
||
ends = [index for index, char in enumerate(text) if char in _CORE_END]
|
||
if not starts or not ends or starts[0] > ends[-1]:
|
||
return None
|
||
return starts[0], ends[-1]
|
||
|
||
|
||
def _guess(digits: str, text: str, sign_form: SignForm, *, negative: bool) -> AmountParse:
|
||
"""«Лучшая догадка»: цифры подряд, не длиннее 16, иначе значение не число."""
|
||
if not digits or len(digits) > MAX_INTEGER_DIGITS:
|
||
return AmountParse(None, text, False, sign_form)
|
||
amount = _quantize(Decimal(digits))
|
||
return AmountParse(-amount if negative else amount, None, False, sign_form)
|
||
|
||
|
||
def _split_core(core: str) -> tuple[str, SignForm, bool, bool] | None:
|
||
"""Ядро → (тело без знака и скобок, форма знака, отрицательное ли, исправлена ли скобка) или None."""
|
||
fixed = False
|
||
sign_form = SignForm.UNSIGNED
|
||
negative = False
|
||
if core[0] == "(":
|
||
if len(core) < 2 or core[-1] not in ")}]": # noqa: PLR2004 — скобки в ядре минимум пара
|
||
return None
|
||
fixed = core[-1] != ")"
|
||
core = core[1:-1].strip()
|
||
sign_form, negative = SignForm.PARENTHESES, True
|
||
elif core[0] in "-−+":
|
||
if core[0] in _MINUSES:
|
||
sign_form, negative = SignForm.MINUS, True
|
||
core = core[1:].strip()
|
||
if not core or not _BODY.fullmatch(core) or not core[0].isdigit():
|
||
return None
|
||
return core, sign_form, negative, fixed
|
||
|
||
|
||
def _number(body: str, source: Source, text: str, sign_form: SignForm, *, negative: bool) -> AmountParse:
|
||
"""Стадия 6: разделители. Возвращает догадку с `is_recognized = false` или точный разбор."""
|
||
runs = _DIGIT_SPACE_RUN.findall(body)
|
||
spaces_ok = all(_SPACE_GROUPS.fullmatch(run) for run in runs)
|
||
compact = "".join(body.split())
|
||
digits = compact.replace(",", "").replace(".", "")
|
||
if not spaces_ok:
|
||
return _guess(digits, text, sign_form, negative=negative)
|
||
if source is Source.OCR and _COMMA_THOUSANDS.fullmatch(compact):
|
||
compact = compact.replace(",", "")
|
||
elif source is Source.OCR and _DOT_THOUSANDS.fullmatch(compact):
|
||
compact = compact.replace(".", "")
|
||
separators = [char for char in compact if char in _SEPARATORS]
|
||
if not separators:
|
||
integer, fraction = compact, ""
|
||
elif len(separators) > 1: # смешанные или повторяющиеся разделители
|
||
return _guess(digits, text, sign_form, negative=negative)
|
||
else:
|
||
integer, fraction = compact.replace(",", ".").split(".")
|
||
if source is Source.OCR and len(fraction) >= 3: # noqa: PLR2004 — три знака: не копейки
|
||
return AmountParse(None, text, False, sign_form)
|
||
if len(integer) > MAX_INTEGER_DIGITS:
|
||
return AmountParse(None, text, False, sign_form)
|
||
amount = _quantize(Decimal(f"{integer}.{fraction}" if fraction else integer))
|
||
return AmountParse(-amount if negative else amount, None, True, sign_form)
|
||
|
||
|
||
def parse_amount(text: str | None, source: Source, rules: Rules) -> AmountParse:
|
||
"""Стадии 1–6 шага «значение ячейки»; от источника зависят только десятичный разделитель и тысячи."""
|
||
if text is None or _is_blank(text):
|
||
return AmountParse(None, None, True, None)
|
||
work, fixed = _strip_edge_bars(text)
|
||
replaced = replace_lookalikes(work, rules.lookalikes)
|
||
fixed = fixed or replaced != work
|
||
if not any(char in _DIGITS for char in replaced): # стадия 5
|
||
return AmountParse(None, text, False, None)
|
||
bounds = _core_bounds(replaced)
|
||
if bounds is None:
|
||
return AmountParse(None, text, False, None)
|
||
start, end = bounds
|
||
core = replaced[start : end + 1]
|
||
trash = bool((replaced[:start] + replaced[end + 1 :]).strip())
|
||
split = _split_core(core)
|
||
if split is None:
|
||
return AmountParse(None, text, False, None)
|
||
body, sign_form, negative, bracket_fixed = split
|
||
parsed = _number(body, source, text, sign_form, negative=negative)
|
||
clean = parsed.is_recognized and not (fixed or trash or bracket_fixed)
|
||
return AmountParse(parsed.amount, parsed.string_value, clean, parsed.sign_form)
|
||
|
||
|
||
def sign_form_of(text: str | None, rules: Rules) -> SignForm | None:
|
||
return parse_amount(text, Source.OCR, rules).sign_form
|
||
|
||
|
||
def _plain(cell: Cell, column_index: int, parsed: AmountParse, *, recognized: bool | None = None) -> StatementValue:
|
||
return StatementValue(
|
||
column_index=column_index,
|
||
amount=parsed.amount,
|
||
string_value=parsed.string_value,
|
||
text=cell.text,
|
||
confidence=cell.confidence,
|
||
is_recognized=parsed.is_recognized if recognized is None else recognized,
|
||
)
|
||
|
||
|
||
def build_value(
|
||
cell: Cell | None,
|
||
column_index: int,
|
||
source: Source,
|
||
rules: Rules,
|
||
*,
|
||
split_part: bool = False,
|
||
) -> ValueBuild:
|
||
if cell is None:
|
||
return ValueBuild(StatementValue(column_index, None, None, None, 100.0, True), out_of_range=False)
|
||
text = cell.text
|
||
string_text = text if text.strip() else None
|
||
value = cell.value
|
||
if isinstance(value, Decimal):
|
||
# длину целой части проверяем до квантования: для 1E+30 и нефинитных значений quantize падает
|
||
amount = _quantize(value) if value.is_finite() and value.adjusted() < MAX_INTEGER_DIGITS else None
|
||
if amount is None or _too_long(amount):
|
||
overflow = AmountParse(None, string_text, False, None)
|
||
return ValueBuild(_plain(cell, column_index, overflow), out_of_range=True)
|
||
return ValueBuild(
|
||
_plain(cell, column_index, AmountParse(amount, None, True, None), recognized=not split_part),
|
||
out_of_range=False,
|
||
)
|
||
if isinstance(value, date | bool):
|
||
return ValueBuild(_plain(cell, column_index, AmountParse(None, string_text, False, None)), out_of_range=False)
|
||
if len(code_parts(text)) > 1 and not split_part:
|
||
return ValueBuild(_plain(cell, column_index, AmountParse(None, text, False, None)), out_of_range=False)
|
||
parsed = parse_amount(text, source, rules)
|
||
return ValueBuild(_plain(cell, column_index, parsed, recognized=False if split_part else None), out_of_range=False)
|