Initial Helpomatica source.
This commit is contained in:
@@ -0,0 +1,625 @@
|
||||
"""Stream-scan InMark-style logs without loading the whole file into RAM."""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import gzip
|
||||
import re
|
||||
from collections import Counter
|
||||
from datetime import datetime
|
||||
from pathlib import Path
|
||||
from typing import Any, Callable, Iterable
|
||||
|
||||
ProgressCb = Callable[[dict[str, Any]], None]
|
||||
|
||||
LOG_JOB_HINTS = re.compile(
|
||||
r"job[_\s]?id|заказ|расхожден|error\s*6[45]|промежутк|частот|"
|
||||
r"plc_errors|line_u|задани[еюя]|маркиров|отбраков|лог[аиов]?\b|"
|
||||
r"histogram|ошибк|gap|код[аыов]?\b|смен[аыеу]",
|
||||
re.IGNORECASE,
|
||||
)
|
||||
JOB_ID_RE = re.compile(
|
||||
r"(?:job(?:[_\s-]?id)?|заказ(?:а|у|ом)?|задани[еюя]|jobid)\s*[:=#№]?\s*(\d{3,8})",
|
||||
re.IGNORECASE,
|
||||
)
|
||||
STANDALONE_JOB_RE = re.compile(r"\b(\d{4,6})\b")
|
||||
DATE_ISO_RE = re.compile(r"\b(20\d{2}-\d{2}-\d{2})\b")
|
||||
DATE_RU_RE = re.compile(r"\b(\d{1,2})[./](\d{1,2})[./](20\d{2}|\d{2})\b")
|
||||
TS_ISO_RE = re.compile(r"(20\d{2}-\d{2}-\d{2})[ T](\d{2}:\d{2}:\d{2})")
|
||||
TS_RU_RE = re.compile(r"(\d{2}\.\d{2}\.20\d{2})[ T](\d{2}:\d{2}:\d{2})")
|
||||
SOURCE_BRACKET_RE = re.compile(r"\[([A-Za-zА-Яа-яЁё0-9_./-]{2,40})\]")
|
||||
SOURCE_FIELD_RE = re.compile(
|
||||
r"\b(?:source|src|sender|from|channel|канал)\s*[=:]\s*([^\s,;\]=]+)",
|
||||
re.IGNORECASE,
|
||||
)
|
||||
ERROR_RE = re.compile(r"\b(?:Error|error_?)\s*(\d{1,3})\b")
|
||||
ERROR64_RE = re.compile(r"\b(?:Error|error_?)\s*64\b", re.IGNORECASE)
|
||||
ERROR65_RE = re.compile(r"\b(?:Error|error_?)\s*65\b", re.IGNORECASE)
|
||||
JOB_IN_LINE_RE = re.compile(
|
||||
r"(?:job(?:[_\s-]?id)?|заказ|JobId)\s*[=:#]?\s*(\d{3,8})",
|
||||
re.IGNORECASE,
|
||||
)
|
||||
CODE_RE = re.compile(
|
||||
r"\b(?:01\d{14}21[A-Za-z0-9]{1,24}|[A-F0-9]{24,44}|\d{20,32})\b"
|
||||
)
|
||||
LOG_NAME_RE = re.compile(r"\.log(\.\d+)?(\.gz)?$", re.IGNORECASE)
|
||||
|
||||
PREFERRED_LOG_NAMES = (
|
||||
"line_u_codes.log",
|
||||
"plc_errors.log",
|
||||
"line_u.log",
|
||||
"line.log",
|
||||
)
|
||||
|
||||
GAP_SECONDS = 30
|
||||
MAX_UNIQUE_CODES = 20_000
|
||||
MAX_ERROR64_HITS = 80
|
||||
MAX_GAPS = 25
|
||||
MAX_SAMPLE_LINES = 12
|
||||
MAX_PREANALYSIS_CHARS = 70_000
|
||||
READ_CHUNK = 256 * 1024
|
||||
|
||||
|
||||
def looks_like_log_job(query: str, log_file_names: Iterable[str] | None = None) -> bool:
|
||||
text = str(query or "")
|
||||
if LOG_JOB_HINTS.search(text):
|
||||
return True
|
||||
names = [str(name or "") for name in (log_file_names or [])]
|
||||
if names and (JOB_ID_RE.search(text) or DATE_ISO_RE.search(text) or DATE_RU_RE.search(text)):
|
||||
return True
|
||||
return False
|
||||
|
||||
|
||||
def is_log_filename(name: str) -> bool:
|
||||
lower = str(name or "").lower()
|
||||
if LOG_NAME_RE.search(lower):
|
||||
return True
|
||||
return ".log." in lower or lower.endswith(".log")
|
||||
|
||||
|
||||
def detect_job_id(query: str) -> str | None:
|
||||
text = str(query or "")
|
||||
match = JOB_ID_RE.search(text)
|
||||
if match:
|
||||
return match.group(1)
|
||||
hinted = LOG_JOB_HINTS.search(text)
|
||||
if hinted:
|
||||
standalone = STANDALONE_JOB_RE.search(text)
|
||||
if standalone:
|
||||
return standalone.group(1)
|
||||
return None
|
||||
|
||||
|
||||
def detect_shift_date(query: str) -> str | None:
|
||||
text = str(query or "")
|
||||
iso = DATE_ISO_RE.search(text)
|
||||
if iso:
|
||||
return iso.group(1)
|
||||
ru = DATE_RU_RE.search(text)
|
||||
if not ru:
|
||||
return None
|
||||
day, month, year = ru.group(1), ru.group(2), ru.group(3)
|
||||
if len(year) == 2:
|
||||
year = f"20{year}"
|
||||
try:
|
||||
return datetime(int(year), int(month), int(day)).strftime("%Y-%m-%d")
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def detect_log_encoding(path: Path) -> str:
|
||||
try:
|
||||
raw = path.open("rb").read(65536)
|
||||
except OSError:
|
||||
return "utf-8"
|
||||
if raw.startswith(b"\xef\xbb\xbf"):
|
||||
return "utf-8-sig"
|
||||
for encoding in ("utf-8", "cp1251"):
|
||||
try:
|
||||
raw.decode(encoding)
|
||||
return encoding
|
||||
except UnicodeDecodeError:
|
||||
continue
|
||||
return "cp1251"
|
||||
|
||||
|
||||
def _parse_timestamp(line: str) -> datetime | None:
|
||||
match = TS_ISO_RE.search(line)
|
||||
if match:
|
||||
try:
|
||||
return datetime.strptime(
|
||||
f"{match.group(1)} {match.group(2)}", "%Y-%m-%d %H:%M:%S"
|
||||
)
|
||||
except ValueError:
|
||||
return None
|
||||
match = TS_RU_RE.search(line)
|
||||
if not match:
|
||||
return None
|
||||
try:
|
||||
return datetime.strptime(
|
||||
f"{match.group(1)} {match.group(2)}", "%d.%m.%Y %H:%M:%S"
|
||||
)
|
||||
except ValueError:
|
||||
return None
|
||||
|
||||
|
||||
def _source_of(line: str, fallback: str) -> str:
|
||||
field = SOURCE_FIELD_RE.search(line)
|
||||
if field:
|
||||
return field.group(1)[:40]
|
||||
bracket = SOURCE_BRACKET_RE.search(line)
|
||||
if bracket:
|
||||
token = bracket.group(1)
|
||||
if not re.fullmatch(r"\d{1,2}:\d{2}:\d{2}.*", token):
|
||||
return token[:40]
|
||||
return fallback
|
||||
|
||||
|
||||
def _open_log_binary(path: Path):
|
||||
name = path.name.lower()
|
||||
handle = path.open("rb")
|
||||
if name.endswith(".gz"):
|
||||
return gzip.GzipFile(fileobj=handle, mode="rb"), handle
|
||||
return handle, handle
|
||||
|
||||
|
||||
def iter_log_lines(path: Path, encoding: str):
|
||||
"""Yield (line_no, text, bytes_read, total_bytes) without loading the file."""
|
||||
size = 0
|
||||
try:
|
||||
size = path.stat().st_size
|
||||
except OSError:
|
||||
size = 0
|
||||
stream, raw = _open_log_binary(path)
|
||||
try:
|
||||
leftover = b""
|
||||
line_no = 0
|
||||
bytes_read = 0
|
||||
while True:
|
||||
chunk = stream.read(READ_CHUNK)
|
||||
if not chunk:
|
||||
break
|
||||
bytes_read += len(chunk)
|
||||
data = leftover + chunk
|
||||
parts = data.split(b"\n")
|
||||
leftover = parts.pop()
|
||||
for part in parts:
|
||||
line_no += 1
|
||||
text = part.rstrip(b"\r").decode(encoding, errors="replace")
|
||||
yield line_no, text, min(bytes_read, size) if size else bytes_read, size
|
||||
if leftover:
|
||||
line_no += 1
|
||||
text = leftover.rstrip(b"\r").decode(encoding, errors="replace")
|
||||
yield line_no, text, size or bytes_read, size
|
||||
finally:
|
||||
try:
|
||||
stream.close()
|
||||
except Exception: # noqa: BLE001
|
||||
pass
|
||||
if raw is not stream:
|
||||
try:
|
||||
raw.close()
|
||||
except Exception: # noqa: BLE001
|
||||
pass
|
||||
|
||||
|
||||
def rank_log_files(entries: list[dict]) -> list[dict]:
|
||||
def score(entry: dict) -> tuple:
|
||||
name = str(entry.get("name") or "").lower()
|
||||
preferred = 0
|
||||
for index, prefix in enumerate(PREFERRED_LOG_NAMES):
|
||||
if name.startswith(prefix) or prefix in name:
|
||||
preferred = 10 - index
|
||||
break
|
||||
size = int(entry.get("size") or 0)
|
||||
return (preferred, 1 if is_log_filename(name) else 0, min(size, 10**12))
|
||||
|
||||
logs = [entry for entry in entries if is_log_filename(str(entry.get("name") or ""))]
|
||||
logs.sort(key=score, reverse=True)
|
||||
return logs[:6]
|
||||
|
||||
|
||||
def _emit_progress(
|
||||
on_progress: ProgressCb | None,
|
||||
*,
|
||||
phase: str,
|
||||
message: str,
|
||||
percent: int | None,
|
||||
file: str = "",
|
||||
) -> None:
|
||||
if not on_progress:
|
||||
return
|
||||
payload: dict[str, Any] = {
|
||||
"phase": phase,
|
||||
"message": message,
|
||||
"percent": percent,
|
||||
}
|
||||
if file:
|
||||
payload["file"] = file
|
||||
on_progress(payload)
|
||||
|
||||
|
||||
def _scan_one_file(
|
||||
path: Path,
|
||||
display_name: str,
|
||||
job_id: str | None,
|
||||
shift_date: str | None,
|
||||
*,
|
||||
on_progress: ProgressCb | None = None,
|
||||
overall_offset: int = 0,
|
||||
overall_total: int = 1,
|
||||
cancel: Callable[[], bool] | None = None,
|
||||
) -> dict[str, Any]:
|
||||
encoding = detect_log_encoding(path)
|
||||
sources: Counter[str] = Counter()
|
||||
errors: Counter[str] = Counter()
|
||||
hours: Counter[str] = Counter()
|
||||
unique_codes: set[str] = set()
|
||||
unique_capped = False
|
||||
code_events = 0
|
||||
error64: list[dict[str, Any]] = []
|
||||
error65: list[dict[str, Any]] = []
|
||||
gaps: list[dict[str, Any]] = []
|
||||
samples: list[dict[str, Any]] = []
|
||||
first_ts: datetime | None = None
|
||||
last_ts: datetime | None = None
|
||||
prev_ts: datetime | None = None
|
||||
prev_line = 0
|
||||
line_count = 0
|
||||
job_lines = 0
|
||||
shift_lines = 0
|
||||
last_pct = -1
|
||||
|
||||
def maybe_sample(line_no: int, line: str, reason: str) -> None:
|
||||
if len(samples) >= MAX_SAMPLE_LINES:
|
||||
return
|
||||
samples.append(
|
||||
{
|
||||
"file": display_name,
|
||||
"line": line_no,
|
||||
"text": line[:240],
|
||||
"reason": reason,
|
||||
}
|
||||
)
|
||||
|
||||
for line_no, line, bytes_read, total in iter_log_lines(path, encoding):
|
||||
if cancel and cancel():
|
||||
break
|
||||
line_count = line_no
|
||||
if overall_total:
|
||||
local = (bytes_read / total) if total else 1.0
|
||||
overall = overall_offset + local * (total or 0)
|
||||
pct = min(99, int(100 * overall / overall_total))
|
||||
if pct >= last_pct + 2:
|
||||
last_pct = pct
|
||||
_emit_progress(
|
||||
on_progress,
|
||||
phase="scan",
|
||||
message=f"Читаю лог… {pct}%",
|
||||
percent=pct,
|
||||
file=display_name,
|
||||
)
|
||||
|
||||
ts = _parse_timestamp(line)
|
||||
if ts:
|
||||
if first_ts is None:
|
||||
first_ts = ts
|
||||
maybe_sample(line_no, line, "first")
|
||||
last_ts = ts
|
||||
hours[ts.strftime("%Y-%m-%d %H:00")] += 1
|
||||
if prev_ts is not None:
|
||||
delta = (ts - prev_ts).total_seconds()
|
||||
if delta >= GAP_SECONDS:
|
||||
gaps.append(
|
||||
{
|
||||
"file": display_name,
|
||||
"from_line": prev_line,
|
||||
"to_line": line_no,
|
||||
"from_ts": prev_ts.isoformat(sep=" ", timespec="seconds"),
|
||||
"to_ts": ts.isoformat(sep=" ", timespec="seconds"),
|
||||
"seconds": int(delta),
|
||||
}
|
||||
)
|
||||
prev_ts = ts
|
||||
prev_line = line_no
|
||||
|
||||
in_shift = True
|
||||
if shift_date and ts:
|
||||
in_shift = ts.strftime("%Y-%m-%d") == shift_date
|
||||
elif shift_date and shift_date in line:
|
||||
in_shift = True
|
||||
elif shift_date:
|
||||
in_shift = False
|
||||
if in_shift:
|
||||
shift_lines += 1
|
||||
|
||||
job_hit = JOB_IN_LINE_RE.search(line)
|
||||
if job_id and (job_id in line or (job_hit and job_hit.group(1) == job_id)):
|
||||
job_lines += 1
|
||||
elif job_hit:
|
||||
job_lines += 0
|
||||
|
||||
sources[_source_of(line, display_name)] += 1
|
||||
|
||||
for err in ERROR_RE.findall(line):
|
||||
if in_shift or not shift_date:
|
||||
errors[err] += 1
|
||||
|
||||
if ERROR64_RE.search(line) and len(error64) < MAX_ERROR64_HITS:
|
||||
error64.append(
|
||||
{
|
||||
"file": display_name,
|
||||
"line": line_no,
|
||||
"ts": ts.isoformat(sep=" ", timespec="seconds") if ts else "",
|
||||
"text": line[:220],
|
||||
}
|
||||
)
|
||||
maybe_sample(line_no, line, "Error64")
|
||||
if ERROR65_RE.search(line) and len(error65) < MAX_ERROR64_HITS:
|
||||
error65.append(
|
||||
{
|
||||
"file": display_name,
|
||||
"line": line_no,
|
||||
"ts": ts.isoformat(sep=" ", timespec="seconds") if ts else "",
|
||||
"text": line[:220],
|
||||
}
|
||||
)
|
||||
maybe_sample(line_no, line, "Error65")
|
||||
|
||||
for code in CODE_RE.findall(line):
|
||||
code_events += 1
|
||||
if not unique_capped:
|
||||
unique_codes.add(code)
|
||||
if len(unique_codes) >= MAX_UNIQUE_CODES:
|
||||
unique_capped = True
|
||||
|
||||
if last_ts and line_count:
|
||||
maybe_sample(line_count, "", "last")
|
||||
if samples and samples[-1]["reason"] == "last" and not samples[-1]["text"]:
|
||||
samples.pop()
|
||||
|
||||
gaps.sort(key=lambda item: int(item.get("seconds") or 0), reverse=True)
|
||||
gaps = gaps[:MAX_GAPS]
|
||||
|
||||
return {
|
||||
"file": display_name,
|
||||
"path": str(path),
|
||||
"encoding": encoding,
|
||||
"lines": line_count,
|
||||
"job_lines": job_lines,
|
||||
"shift_lines": shift_lines,
|
||||
"first_ts": first_ts.isoformat(sep=" ", timespec="seconds") if first_ts else "",
|
||||
"last_ts": last_ts.isoformat(sep=" ", timespec="seconds") if last_ts else "",
|
||||
"sources": sources.most_common(30),
|
||||
"errors": errors.most_common(25),
|
||||
"hours": hours.most_common(24),
|
||||
"unique_codes": len(unique_codes),
|
||||
"unique_capped": unique_capped,
|
||||
"code_events": code_events,
|
||||
"error64": error64,
|
||||
"error65": error65,
|
||||
"gaps": gaps,
|
||||
"samples": samples,
|
||||
}
|
||||
|
||||
|
||||
def _format_duration(seconds: int) -> str:
|
||||
value = max(0, int(seconds))
|
||||
if value < 60:
|
||||
return f"{value} с"
|
||||
minutes, rest = divmod(value, 60)
|
||||
if minutes < 60:
|
||||
return f"{minutes} мин {rest} с" if rest else f"{minutes} мин"
|
||||
hours, minutes = divmod(minutes, 60)
|
||||
return f"{hours} ч {minutes} мин"
|
||||
|
||||
|
||||
def render_preanalysis_markdown(report: dict[str, Any]) -> str:
|
||||
job_id = report.get("job_id") or "не найден в вопросе"
|
||||
shift = report.get("shift_date") or "не указана"
|
||||
lines: list[str] = [
|
||||
"# PREANALYSIS",
|
||||
"",
|
||||
"Сервер уже просканировал логи **одним проходом**. "
|
||||
"Используй этот файл первым. Не читай логи целиком заново, "
|
||||
"если цифры выглядят правдоподобно. Для проверки бери фрагмент "
|
||||
"по номеру строки (`:15231:line_u_codes.log.1` или "
|
||||
"`::log:line_u_codes.log.1:15231::`).",
|
||||
"",
|
||||
f"- Job id: `{job_id}`",
|
||||
f"- Дата смены (из вопроса): `{shift}`",
|
||||
f"- Файлов просканировано: {len(report.get('files') or [])}",
|
||||
"",
|
||||
]
|
||||
|
||||
for item in report.get("files") or []:
|
||||
name = item.get("file") or "log"
|
||||
lines.extend(
|
||||
[
|
||||
f"## {name}",
|
||||
"",
|
||||
f"- Кодировка: `{item.get('encoding')}`",
|
||||
f"- Строк: {item.get('lines')}",
|
||||
f"- Строк с job id: {item.get('job_lines')}",
|
||||
f"- Строк за смену: {item.get('shift_lines')}",
|
||||
f"- Интервал: {item.get('first_ts') or '—'} → {item.get('last_ts') or '—'}",
|
||||
f"- Событий с кодами: {item.get('code_events')}",
|
||||
f"- Уникальных кодов: {item.get('unique_codes')}"
|
||||
+ (" (учёт ограничен) " if item.get("unique_capped") else ""),
|
||||
"",
|
||||
"### Источники",
|
||||
"",
|
||||
]
|
||||
)
|
||||
sources = item.get("sources") or []
|
||||
if sources:
|
||||
for src, count in sources:
|
||||
lines.append(f"- `{src}`: {count}")
|
||||
else:
|
||||
lines.append("- (нет)")
|
||||
lines.extend(["", "### Ошибки за смену (гистограмма)", ""])
|
||||
errors = item.get("errors") or []
|
||||
if errors:
|
||||
for code, count in errors:
|
||||
lines.append(f"- Error {code}: {count}")
|
||||
else:
|
||||
lines.append("- (нет совпадений Error N)")
|
||||
lines.extend(["", "### Частота по часам (топ)", ""])
|
||||
hours = item.get("hours") or []
|
||||
if hours:
|
||||
for hour, count in hours[:16]:
|
||||
lines.append(f"- {hour}: {count}")
|
||||
else:
|
||||
lines.append("- (нет меток времени)")
|
||||
lines.extend(["", "### Длинные промежутки (≥ 30 с)", ""])
|
||||
gaps = item.get("gaps") or []
|
||||
if gaps:
|
||||
for gap in gaps:
|
||||
lines.append(
|
||||
f"- {_format_duration(int(gap.get('seconds') or 0))}: "
|
||||
f"{gap.get('from_ts')} → {gap.get('to_ts')} "
|
||||
f"(`:{gap.get('from_line')}:{name}` … `:{gap.get('to_line')}:{name}`)"
|
||||
)
|
||||
else:
|
||||
lines.append("- нет промежутков ≥ 30 с")
|
||||
lines.extend(["", "### Error64", ""])
|
||||
hits64 = item.get("error64") or []
|
||||
if hits64:
|
||||
for hit in hits64[:40]:
|
||||
ts = hit.get("ts") or "—"
|
||||
lines.append(
|
||||
f"- {ts} `:{hit.get('line')}:{name}` — {hit.get('text')}"
|
||||
)
|
||||
else:
|
||||
lines.append("- нет")
|
||||
lines.extend(["", "### Error65", ""])
|
||||
hits65 = item.get("error65") or []
|
||||
if hits65:
|
||||
for hit in hits65[:40]:
|
||||
ts = hit.get("ts") or "—"
|
||||
lines.append(
|
||||
f"- {ts} `:{hit.get('line')}:{name}` — {hit.get('text')}"
|
||||
)
|
||||
else:
|
||||
lines.append("- нет")
|
||||
lines.extend(["", "### Примеры строк", ""])
|
||||
for sample in item.get("samples") or []:
|
||||
text = str(sample.get("text") or "").strip()
|
||||
if not text:
|
||||
continue
|
||||
lines.append(
|
||||
f"- `:{sample.get('line')}:{name}` ({sample.get('reason')}): `{text}`"
|
||||
)
|
||||
lines.append("")
|
||||
|
||||
text = "\n".join(lines).strip() + "\n"
|
||||
if len(text) > MAX_PREANALYSIS_CHARS:
|
||||
text = text[:MAX_PREANALYSIS_CHARS].rstrip() + "\n\n…\n"
|
||||
return text
|
||||
|
||||
|
||||
def preanalyze_logs(
|
||||
files: list[tuple[Path, str]],
|
||||
query: str,
|
||||
*,
|
||||
on_progress: ProgressCb | None = None,
|
||||
cancel: Callable[[], bool] | None = None,
|
||||
) -> dict[str, Any]:
|
||||
job_id = detect_job_id(query)
|
||||
shift_date = detect_shift_date(query)
|
||||
existing = [(path, name) for path, name in files if path.exists() and path.is_file()]
|
||||
total_bytes = 0
|
||||
for path, _name in existing:
|
||||
try:
|
||||
total_bytes += path.stat().st_size
|
||||
except OSError:
|
||||
pass
|
||||
total_bytes = max(total_bytes, 1)
|
||||
offset = 0
|
||||
scanned: list[dict[str, Any]] = []
|
||||
_emit_progress(
|
||||
on_progress,
|
||||
phase="scan",
|
||||
message="Читаю лог… 0%",
|
||||
percent=0,
|
||||
)
|
||||
for path, name in existing:
|
||||
size = 0
|
||||
try:
|
||||
size = path.stat().st_size
|
||||
except OSError:
|
||||
size = 0
|
||||
item = _scan_one_file(
|
||||
path,
|
||||
name,
|
||||
job_id,
|
||||
shift_date,
|
||||
on_progress=on_progress,
|
||||
overall_offset=offset,
|
||||
overall_total=total_bytes,
|
||||
cancel=cancel,
|
||||
)
|
||||
scanned.append(item)
|
||||
offset += size
|
||||
if cancel and cancel():
|
||||
break
|
||||
_emit_progress(
|
||||
on_progress,
|
||||
phase="scan",
|
||||
message="Читаю лог… 100%",
|
||||
percent=100,
|
||||
)
|
||||
report = {
|
||||
"job_id": job_id or "",
|
||||
"shift_date": shift_date or "",
|
||||
"files": scanned,
|
||||
}
|
||||
report["markdown"] = render_preanalysis_markdown(report)
|
||||
report["summary"] = _short_summary(report)
|
||||
return report
|
||||
|
||||
|
||||
def _short_summary(report: dict[str, Any]) -> str:
|
||||
bits = []
|
||||
if report.get("job_id"):
|
||||
bits.append(f"job {report['job_id']}")
|
||||
if report.get("shift_date"):
|
||||
bits.append(report["shift_date"])
|
||||
for item in report.get("files") or []:
|
||||
bits.append(
|
||||
f"{item.get('file')}: {item.get('lines')} строк, "
|
||||
f"Error64×{len(item.get('error64') or [])}, "
|
||||
f"промежутков {len(item.get('gaps') or [])}"
|
||||
)
|
||||
return "; ".join(bits) if bits else "логи просканированы"
|
||||
|
||||
|
||||
def excerpt_lines(
|
||||
path: Path,
|
||||
start: int,
|
||||
end: int,
|
||||
encoding: str | None = None,
|
||||
) -> tuple[str, str]:
|
||||
"""Return (text, encoding) for 1-indexed inclusive line range."""
|
||||
start = max(1, int(start))
|
||||
end = max(start, int(end))
|
||||
encoding = encoding or detect_log_encoding(path)
|
||||
collected: list[str] = []
|
||||
for line_no, text, _read, _total in iter_log_lines(path, encoding):
|
||||
if line_no < start:
|
||||
continue
|
||||
if line_no > end:
|
||||
break
|
||||
collected.append(f"{line_no}\t{text}")
|
||||
return "\n".join(collected) + ("\n" if collected else ""), encoding
|
||||
|
||||
|
||||
def write_preanalysis_md(workspace: Path, markdown: str) -> Path:
|
||||
target = Path(workspace) / "PREANALYSIS.md"
|
||||
target.write_text(markdown, encoding="utf-8")
|
||||
listing = Path(workspace) / "PROJECT_FILES.md"
|
||||
if listing.exists():
|
||||
extra = "\n- ./PREANALYSIS.md — server-side log scan; read this first\n"
|
||||
text = listing.read_text(encoding="utf-8")
|
||||
if "PREANALYSIS.md" not in text:
|
||||
listing.write_text(text.rstrip() + extra, encoding="utf-8")
|
||||
return target
|
||||
Reference in New Issue
Block a user