344 lines
14 KiB
Python
344 lines
14 KiB
Python
"""Загрузчик резервов ЦСВ/ЦСК Водоканала ЕКБ из docx-раскрытия (#2119).
|
||
|
||
Две страницы водоканалекб.рф (водоснабжение / водоотведение) публикуют docx с
|
||
таблицами свободной мощности ЦСВ (центр. система водоснабжения) / ЦСК (центр.
|
||
система водоотведения). UPSERT-ит в ``water_supply_reserves``.
|
||
|
||
Источник ГЕО-БЛОКИРУЕТ non-RU IP → РАБОТАЕТ НА ПРОДЕ (Celery / docker exec).
|
||
Punycode-host обязателен (водоканалекб.рф → xn--80aadbki6adhshb.xn--p1ai).
|
||
|
||
CRITICAL: колонка имени системы использует ВЕРТИКАЛЬНЫЙ MERGE (vMerge) — значение
|
||
задано в первой строке блока, дальше идут <w:vMerge/> без restart → forward-fill.
|
||
Колонка примечания тоже мержится. Парсим таблицы через stdlib (zipfile +
|
||
ElementTree по word/document.xml) — это надёжнее python-docx для vMerge-детекта
|
||
и тривиально тестируется на синтетическом xml-фрагменте.
|
||
|
||
Резерв бывает ОТРИЦАТЕЛЬНЫМ (дефицит, напр. −168,5) — знак сохраняем, запятая-
|
||
десятичный → float. period инферится из имени файла (1kv.-2026 → '2026-Q1').
|
||
"""
|
||
|
||
import io
|
||
import logging
|
||
import re
|
||
import zipfile
|
||
from xml.etree import ElementTree as ET
|
||
|
||
import httpx
|
||
from sqlalchemy import text
|
||
from sqlalchemy.orm import Session
|
||
|
||
from app.core.db import SessionLocal
|
||
|
||
logger = logging.getLogger(__name__)
|
||
|
||
# WordprocessingML namespace.
|
||
_W = "http://schemas.openxmlformats.org/wordprocessingml/2006/main"
|
||
_NS = {"w": _W}
|
||
|
||
# Punycode-host обязателен (водоканалекб.рф). xn--80aadbki6adhshb.xn--p1ai.
|
||
_BASE = "https://xn--80aadbki6adhshb.xn--p1ai"
|
||
PAGES: dict[str, str] = {
|
||
"water": f"{_BASE}/info/vodosnabzhenie/",
|
||
"sewerage": f"{_BASE}/info/vodotvedenie/",
|
||
}
|
||
|
||
_HTTP_TIMEOUT = 60
|
||
|
||
# docx-ссылка «для сайта»: dlya-sajta-*.docx.
|
||
_DOCX_HREF_RE = re.compile(r'href=["\']([^"\']*dlya-sajta-[^"\']*\.docx)["\']', re.IGNORECASE)
|
||
# Дата в имени файла для выбора свежайшего.
|
||
_FILE_DATE_RE = re.compile(r"(\d{4})|(\d{1,2})[.\-](\d{4})")
|
||
# Период вида «1kv.-2026» / «1кв-2026» / «1 квартал 2026».
|
||
_PERIOD_RE = re.compile(r"(\d)\s*(?:kv|кв)\w*[.\s-]*(\d{4})", re.IGNORECASE)
|
||
|
||
_NODATA_TOKENS = frozenset({"", "н/д", "нд", "n/a", "-", "—", "–", "нет данных", "х", "x"})
|
||
|
||
|
||
def parse_water_number(value: str | None) -> float | None:
|
||
"""Числовая ячейка резерва тыс. м³/сут → float. Сохраняет знак (дефицит <0).
|
||
|
||
Запятая-десятичный → точка, минусы всех видов (−/–/-) нормализуются.
|
||
«н/д»/пусто → None.
|
||
"""
|
||
if value is None:
|
||
return None
|
||
s = str(value).strip().lower()
|
||
if s in _NODATA_TOKENS:
|
||
return None
|
||
s = s.replace("\xa0", "").replace(" ", "").replace(",", ".")
|
||
# Нормализуем юникод-минусы к ASCII '-'.
|
||
s = s.replace("−", "-").replace("–", "-").replace("—", "-")
|
||
m = re.search(r"-?\d+(?:\.\d+)?", s)
|
||
if not m:
|
||
return None
|
||
try:
|
||
return float(m.group())
|
||
except ValueError:
|
||
return None
|
||
|
||
|
||
def infer_period(filename: str) -> str | None:
|
||
"""Инферит период отчёта из имени файла: «1kv.-2026» → '2026-Q1'. None — нет."""
|
||
m = _PERIOD_RE.search(filename)
|
||
if not m:
|
||
return None
|
||
quarter, year = m.group(1), m.group(2)
|
||
return f"{year}-Q{quarter}"
|
||
|
||
|
||
def _cell_text(tc: ET.Element) -> str:
|
||
"""Весь текст ячейки таблицы (<w:tc>) — конкатенация всех <w:t>."""
|
||
parts = [t.text or "" for t in tc.iter(f"{{{_W}}}t")]
|
||
return "".join(parts).strip()
|
||
|
||
|
||
def _vmerge_state(tc: ET.Element) -> str:
|
||
"""Состояние вертикального merge ячейки: 'restart' | 'continue' | 'none'.
|
||
|
||
<w:vMerge w:val="restart"/> — начало блока (значение здесь).
|
||
<w:vMerge/> (без val или val='continue') — продолжение (forward-fill сверху).
|
||
Нет <w:vMerge> — обычная ячейка.
|
||
"""
|
||
tc_pr = tc.find(f"{{{_W}}}tcPr")
|
||
if tc_pr is None:
|
||
return "none"
|
||
vmerge = tc_pr.find(f"{{{_W}}}vMerge")
|
||
if vmerge is None:
|
||
return "none"
|
||
val = vmerge.get(f"{{{_W}}}val")
|
||
return "restart" if val == "restart" else "continue"
|
||
|
||
|
||
def parse_docx_table_rows(document_xml: bytes) -> list[list[str]]:
|
||
"""Парсит ПЕРВУЮ таблицу document.xml → list строк (list ячеек-строк).
|
||
|
||
Forward-fill по вертикальному merge: ячейка в состоянии 'continue' наследует
|
||
текст ячейки той же колонки из предыдущей строки (system-name + note мержатся).
|
||
Возвращает матрицу текстов [row][col]. Пусто → [].
|
||
"""
|
||
root = ET.fromstring(document_xml)
|
||
tables = root.iter(f"{{{_W}}}tbl")
|
||
tbl = next(tables, None)
|
||
if tbl is None:
|
||
return []
|
||
|
||
matrix: list[list[str]] = []
|
||
prev_row: list[str] = []
|
||
for tr in tbl.findall(f"{{{_W}}}tr"):
|
||
cells = tr.findall(f"{{{_W}}}tc")
|
||
row: list[str] = []
|
||
for col_idx, tc in enumerate(cells):
|
||
state = _vmerge_state(tc)
|
||
if state == "continue":
|
||
# forward-fill из той же колонки предыдущей строки.
|
||
filled = prev_row[col_idx] if col_idx < len(prev_row) else ""
|
||
row.append(filled)
|
||
else:
|
||
row.append(_cell_text(tc))
|
||
matrix.append(row)
|
||
prev_row = row
|
||
return matrix
|
||
|
||
|
||
def _looks_numeric(s: str) -> bool:
|
||
"""Строка похожа на число (для отсева заголовочных строк)?"""
|
||
return parse_water_number(s) is not None
|
||
|
||
|
||
def extract_water_rows(matrix: list[list[str]]) -> list[dict]:
|
||
"""Из forward-filled матрицы вытаскивает записи ЦСВ/ЦСК.
|
||
|
||
Эвристика колонок (структура docx стабильна, но защищаемся): первая непустая
|
||
текстовая колонка = system_name; первая числовая колонка = reserve; далее
|
||
ищем заявки/отказы (целые) если есть; note — последняя длинная текстовая.
|
||
Заголовочные строки (без числового резерва) пропускаются.
|
||
"""
|
||
records: list[dict] = []
|
||
for row in matrix:
|
||
if not any(c.strip() for c in row):
|
||
continue
|
||
# system_name — первая непустая текстовая (не число) ячейка.
|
||
name = ""
|
||
reserve_idx = -1
|
||
for idx, cell in enumerate(row):
|
||
cell = cell.strip()
|
||
if not cell:
|
||
continue
|
||
if not name and not _looks_numeric(cell):
|
||
name = cell
|
||
if reserve_idx < 0 and _looks_numeric(cell):
|
||
reserve_idx = idx
|
||
if not name or reserve_idx < 0:
|
||
continue # заголовок / служебная строка без резерва
|
||
|
||
reserve = parse_water_number(row[reserve_idx])
|
||
|
||
# заявки/отказы — целочисленные значения ПОСЛЕ колонки резерва.
|
||
requested: int | None = None
|
||
refused: int | None = None
|
||
ints_after: list[int] = []
|
||
for cell in row[reserve_idx + 1 :]:
|
||
n = parse_water_number(cell)
|
||
if n is not None and float(n).is_integer() and n >= 0:
|
||
ints_after.append(int(n))
|
||
if len(ints_after) >= 1:
|
||
requested = ints_after[0]
|
||
if len(ints_after) >= 2:
|
||
refused = ints_after[1]
|
||
|
||
# note — последняя текстовая ячейка (не имя, не число).
|
||
note = ""
|
||
for cell in reversed(row):
|
||
cell = cell.strip()
|
||
if cell and not _looks_numeric(cell) and cell != name:
|
||
note = cell
|
||
break
|
||
|
||
records.append(
|
||
{
|
||
"system_name": name,
|
||
"reserve_thousand_m3_day": reserve,
|
||
"connections_requested": requested,
|
||
"connections_refused": refused,
|
||
"note": note or None,
|
||
}
|
||
)
|
||
return records
|
||
|
||
|
||
def fetch_docx_link(page_url: str) -> str:
|
||
"""Скрейпит страницу → ссылка на СВЕЖАЙШИЙ dlya-sajta-*.docx. '' если нет.
|
||
|
||
RUN-ON-PROD (гео-блок). GET follow_redirects, regex по href.
|
||
"""
|
||
resp = httpx.get(page_url, timeout=_HTTP_TIMEOUT, follow_redirects=True)
|
||
resp.raise_for_status()
|
||
hrefs = _DOCX_HREF_RE.findall(resp.text)
|
||
if not hrefs:
|
||
return ""
|
||
|
||
def _key(h: str) -> tuple:
|
||
years = [int(y) for grp in _FILE_DATE_RE.findall(h) for y in grp if y]
|
||
return (max(years) if years else 0, h)
|
||
|
||
best = max(hrefs, key=_key)
|
||
return best if best.startswith("http") else _BASE + best
|
||
|
||
|
||
def _upsert_water_rows(
|
||
db: Session,
|
||
system_kind: str,
|
||
records: list[dict],
|
||
period: str | None,
|
||
source_url: str,
|
||
) -> dict[str, int]:
|
||
"""UPSERT записей ЦСВ/ЦСК в water_supply_reserves. Per-row SAVEPOINT."""
|
||
inserted = 0
|
||
updated = 0
|
||
skipped = 0
|
||
for rec in records:
|
||
params = {
|
||
"system_kind": system_kind,
|
||
"system_name": rec["system_name"],
|
||
"reserve": rec["reserve_thousand_m3_day"],
|
||
"requested": rec["connections_requested"],
|
||
"refused": rec["connections_refused"],
|
||
"note": rec["note"],
|
||
"period": period,
|
||
"source_url": source_url,
|
||
}
|
||
try:
|
||
with db.begin_nested(): # SAVEPOINT — битая строка не валит батч
|
||
result = db.execute(
|
||
text("""
|
||
INSERT INTO water_supply_reserves
|
||
(system_kind, system_name, reserve_thousand_m3_day,
|
||
connections_requested, connections_refused, note,
|
||
period, source_url, fetched_at)
|
||
VALUES (
|
||
:system_kind, :system_name, :reserve,
|
||
:requested, :refused, :note,
|
||
:period, :source_url, NOW()
|
||
)
|
||
ON CONFLICT (system_kind, system_name, period) DO UPDATE
|
||
SET reserve_thousand_m3_day = EXCLUDED.reserve_thousand_m3_day,
|
||
connections_requested = EXCLUDED.connections_requested,
|
||
connections_refused = EXCLUDED.connections_refused,
|
||
note = EXCLUDED.note,
|
||
source_url = EXCLUDED.source_url,
|
||
fetched_at = NOW()
|
||
RETURNING (xmax = 0) AS is_insert
|
||
"""),
|
||
params,
|
||
).scalar()
|
||
if result:
|
||
inserted += 1
|
||
else:
|
||
updated += 1
|
||
except Exception as e:
|
||
logger.warning("water_reserve upsert failed for %r: %s", rec["system_name"], e)
|
||
skipped += 1
|
||
return {"inserted": inserted, "updated": updated, "skipped": skipped}
|
||
|
||
|
||
def load_water_reserves_from_docx(
|
||
db: Session,
|
||
system_kind: str,
|
||
docx_bytes: bytes,
|
||
source_url: str = "",
|
||
) -> dict[str, int]:
|
||
"""Парсит docx-байты → UPSERT ЦСВ/ЦСК в water_supply_reserves.
|
||
|
||
Выделено из load_water_reserves для юнит-теста на синтетическом docx.
|
||
Читает word/document.xml из zip, forward-fill vMerge, извлечение записей.
|
||
"""
|
||
with zipfile.ZipFile(io.BytesIO(docx_bytes)) as zf:
|
||
document_xml = zf.read("word/document.xml")
|
||
matrix = parse_docx_table_rows(document_xml)
|
||
records = extract_water_rows(matrix)
|
||
period = infer_period(source_url)
|
||
|
||
try:
|
||
counts = _upsert_water_rows(db, system_kind, records, period, source_url)
|
||
db.commit()
|
||
except Exception as e:
|
||
db.rollback()
|
||
logger.exception("load_water_reserves_from_docx: outer tx rolled back: %s", e)
|
||
raise
|
||
|
||
result = {"records": len(records), **counts, "period": period} # type: ignore[dict-item]
|
||
logger.info("water_reserves[%s] done: %s", system_kind, result)
|
||
return {k: v for k, v in result.items() if isinstance(v, int)}
|
||
|
||
|
||
def load_water_reserves(db: Session | None = None) -> dict[str, dict]:
|
||
"""Полный прогон: обе страницы (водоснабжение/водоотведение) → UPSERT.
|
||
|
||
RUN-ON-PROD. Каждая страница graceful: сбой одной не валит другую.
|
||
Returns: {"water": {...}, "sewerage": {...}}.
|
||
"""
|
||
owns_session = db is None
|
||
if db is None:
|
||
db = SessionLocal()
|
||
|
||
out: dict[str, dict] = {}
|
||
try:
|
||
with httpx.Client(timeout=_HTTP_TIMEOUT, follow_redirects=True) as client:
|
||
for kind, page_url in PAGES.items():
|
||
try:
|
||
link = fetch_docx_link(page_url)
|
||
if not link:
|
||
out[kind] = {"error": "no docx link found"}
|
||
continue
|
||
r = client.get(link)
|
||
r.raise_for_status()
|
||
out[kind] = load_water_reserves_from_docx(db, kind, r.content, link)
|
||
except Exception as e:
|
||
logger.exception("load_water_reserves: %s failed: %s", kind, e)
|
||
out[kind] = {"error": str(e)}
|
||
finally:
|
||
if owns_session:
|
||
db.close()
|
||
|
||
logger.info("load_water_reserves done: %s", out)
|
||
return out
|