standkit 0.3.7__py3-none-any.whl

standkit/__init__.py

@@ -0,0 +1,11 @@
+"""
+standkit — свободное (MIT) ядро управления жизненным циклом стендов BPMSoft.
+
+Пакет не содержит лицензионно-чувствительного контента платформы BPMSoft и не
+зависит от сторонних библиотек (stdlib-only). Полная документация — см. README.md
+и docs/ARCHITECTURE.md в корне репозитория.
+"""
+
+__version__ = "0.3.7"
+
+__all__ = ["__version__"]

standkit/health.py

@@ -0,0 +1,163 @@
+"""
+Health-пробы стенда: жив ли процесс, отвечает ли HTTP, открыт ли TCP-порт
+(используется как поверхностная проверка живости БД/Redis).
+
+Все пробы — быстрые и не требуют сторонних зависимостей (только stdlib:
+``socket``, ``urllib``). Глубокие проверки (реальный SQL-запрос к БД, PING к
+Redis по протоколу) — сознательно вынесены в TODO под опциональный флаг,
+чтобы базовый health-чек оставался лёгким и не тянул psycopg2/pyodbc/redis-py
+в обязательные зависимости ядра.
+"""
+
+from __future__ import annotations
+
+import socket
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+from standkit.models import ProbeState, Stand, StandStatus
+
+
+def process_alive(pidfile: Path) -> bool:
+    """
+    Проверяет, жив ли процесс, чей pid записан в ``pidfile``.
+
+    Если файла нет или он не читается — считается, что процесс не запущен.
+    Импортирует standkit.platform лениво, чтобы health.py можно было
+    использовать и для проверки "чужих" процессов без завязки на lifecycle.
+    """
+    from standkit import platform as _platform  # локальный импорт — избегаем цикла
+
+    if not pidfile.exists():
+        return False
+    try:
+        pid = int(pidfile.read_text(encoding="utf-8").strip())
+    except (ValueError, OSError):
+        return False
+    return _platform.is_alive(pid)
+
+
+def process_running(
+    pidfile: Optional[Path],
+    host: Optional[str] = None,
+    port: Optional[int] = None,
+) -> bool:
+    """
+    Считает процесс стенда "живым", если ЛИБО жив pidfile standkit (стенд
+    поднят самим ядром), ЛИБО слушается TCP-порт стенда (стенд поднят извне
+    standkit — вручную, через IIS/systemd/сторонний скрипт и т.п.).
+
+    Это расширение process_alive: тот проверяет только pidfile, этот —
+    комбинирует обе приметы живости, потому что реальные стенды часто
+    поднимаются не через lifecycle.start().
+    """
+    if pidfile is not None and process_alive(pidfile):
+        return True
+    if host and port:
+        return tcp_open(host, port)
+    return False
+
+
+def http_ok(url: str, *, timeout: float = 3.0) -> bool:
+    """
+    Проверяет, отвечает ли HTTP(S)-эндпоинт (любой код ответа < 500 считается
+    "живым" — стенд может честно отдавать 401/403 до логина, это не авария).
+
+    Сетевые ошибки (отказано в соединении, DNS, таймаут) → False, без исключений
+    наружу — это намеренно проба, а не операция, которая должна падать.
+    """
+    try:
+        req = urllib.request.Request(url, method="GET")
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return resp.status < 500
+    except urllib.error.HTTPError as exc:
+        # Сервер ответил (пусть и ошибкой) — значит, живой.
+        return exc.code < 500
+    except (urllib.error.URLError, TimeoutError, OSError, ValueError):
+        return False
+
+
+def tcp_open(host: str, port: int, *, timeout: float = 2.0) -> bool:
+    """
+    Проверяет, открыт ли TCP-порт (используется как поверхностная liveness-проба
+    БД/Redis — не подменяет полноценный запрос к сервису).
+    """
+    if not host or not port:
+        return False
+    try:
+        with socket.create_connection((host, port), timeout=timeout):
+            return True
+    except (OSError, ValueError):
+        return False
+
+
+def db_deep_check(stand: Stand) -> ProbeState:
+    """
+    TODO(следующая итерация): полноценная проверка БД (реальный SELECT 1 через
+    psycopg2 для postgres / pyodbc для mssql). Требует опциональных
+    зависимостей, которые НЕ должны стать обязательными для ядра — включать
+    только по явному флагу вызывающей стороны.
+
+    Пока — заглушка, всегда возвращающая SKIPPED, чтобы вызывающий код мог
+    отличить "проверка не выполнялась" от "проверка провалилась".
+    """
+    return ProbeState.SKIPPED
+
+
+def redis_deep_check(stand: Stand) -> ProbeState:
+    """TODO(следующая итерация): полноценный PING к Redis (redis-py, опциональная зависимость)."""
+    return ProbeState.SKIPPED
+
+
+def check_stand(
+    stand: Stand,
+    *,
+    pidfile: Optional[Path] = None,
+    http_path: str = "/",
+    deep_db: bool = False,
+    deep_redis: bool = False,
+) -> StandStatus:
+    """
+    Собирает сводный StandStatus по всем доступным быстрым пробам.
+
+    ``pidfile`` — если не передан, процесс-проба пропускается (UNKNOWN) —
+    вызывающая сторона (lifecycle) знает свой путь к pidfile лучше, чем этот
+    модуль по умолчанию.
+    """
+    status = StandStatus(name=stand.name)
+
+    if pidfile is not None or (stand.stand_host and stand.stand_port):
+        is_up = process_running(pidfile, stand.stand_host, stand.stand_port)
+        status.process = ProbeState.OK if is_up else ProbeState.DOWN
+    else:
+        status.process = ProbeState.UNKNOWN
+
+    if stand.stand_host and stand.stand_port:
+        url = f"http://{stand.stand_host}:{stand.stand_port}{http_path}"
+        status.http = ProbeState.OK if http_ok(url) else ProbeState.DOWN
+    else:
+        status.http = ProbeState.UNKNOWN
+
+    if stand.db_host and stand.db_port:
+        status.db = ProbeState.OK if tcp_open(stand.db_host, stand.db_port) else ProbeState.DOWN
+        if deep_db:
+            status.db = db_deep_check(stand)
+    else:
+        status.db = ProbeState.UNKNOWN
+
+    redis_host = stand.extra.get("redis_host")
+    redis_port = stand.extra.get("redis_port")
+    if redis_host and redis_port:
+        status.redis = ProbeState.OK if tcp_open(redis_host, int(redis_port)) else ProbeState.DOWN
+        if deep_redis:
+            status.redis = redis_deep_check(stand)
+    else:
+        status.redis = ProbeState.UNKNOWN
+
+    # TODO: last_deploy — задел на будущее, источник данных пока не определён
+    # (кандидат — метаданные из BPMkit deploy_status/deploy_verify).
+    status.last_deploy = ProbeState.UNKNOWN
+
+    return status

standkit/lifecycle.py

@@ -0,0 +1,191 @@
+"""
+Жизненный цикл стенда: start/stop/restart поверх standkit.platform.
+
+Хранит pid запущенного стенда в per-stand pidfile в рабочей папке (по умолчанию
+``<домашняя папка пользователя>/.standkit/run/<имя стенда>.pid``), чтобы между
+разными вызовами (в т.ч. из другого процесса Python — например, из
+standkit_agent) можно было понять, жив ли стенд и как его остановить.
+
+Работает только для ``transport == "local"``. Для ``transport == "agent"``
+вызывающая сторона (GUI/клиент) должна ходить по HTTP к соответствующему
+standkit_agent — этот модуль намеренно не содержит сетевого кода (см.
+standkit_gui.client).
+
+TODO(следующая итерация):
+  - polling готовности после start() (сейчас просто возвращает pid, готовность
+    веб-хоста нужно проверять отдельно через standkit.health.http_ok в цикле);
+  - блокировка pidfile от гонки двух одновременных start() одного стенда;
+  - восстановление после "потерянного" pidfile (процесс с этим pid уже другой —
+    нужна доп. проверка, например по имени командной строки).
+"""
+
+from __future__ import annotations
+
+import shutil
+import time
+from pathlib import Path
+from typing import Optional
+
+from standkit import platform as _platform
+from standkit.models import Stand, Transport
+
+_DEFAULT_RUN_DIR = Path.home() / ".standkit" / "run"
+_DEFAULT_LOG_DIR = Path.home() / ".standkit" / "logs"
+
+# Пауза после spawn_hidden() перед проверкой "жив ли процесс" — типичный
+# симптом "тихого" провала старта: неверный dll/аргументы, .NET-хост пишет
+# ошибку в лог и завершается за доли секунды, а spawn_hidden() успевает
+# вернуть валидный pid до этого момента. Вынесено в параметр start(), чтобы
+# тесты могли передать 0 и не ждать реальное время.
+_DEFAULT_STARTUP_CHECK_DELAY = 0.6
+
+
+class LifecycleError(Exception):
+    """Ошибки управления жизненным циклом стенда."""
+
+
+def pidfile_path(stand: Stand, run_dir: Optional[Path] = None) -> Path:
+    """Путь к pid-файлу стенда (по умолчанию — общая рабочая папка standkit пользователя)."""
+    run_dir = Path(run_dir) if run_dir else _DEFAULT_RUN_DIR
+    return run_dir / f"{stand.name}.pid"
+
+
+def log_path(stand: Stand, log_dir: Optional[Path] = None) -> Path:
+    """Путь к лог-файлу стенда (см. standkit.logs.tail)."""
+    log_dir = Path(log_dir) if log_dir else _DEFAULT_LOG_DIR
+    return log_dir / f"{stand.name}.log"
+
+
+def _read_pid(pf: Path) -> Optional[int]:
+    if not pf.exists():
+        return None
+    try:
+        return int(pf.read_text(encoding="utf-8").strip())
+    except (ValueError, OSError):
+        return None
+
+
+def _write_pid(pf: Path, pid: int) -> None:
+    pf.parent.mkdir(parents=True, exist_ok=True)
+    pf.write_text(str(pid), encoding="utf-8")
+
+
+def _require_local(stand: Stand) -> None:
+    if stand.transport != Transport.LOCAL:
+        raise LifecycleError(
+            f"Стенд '{stand.name}' имеет transport={stand.transport.value!r} — "
+            "управление headless-процессом доступно только для transport='local' "
+            "(для 'agent' используйте HTTP-клиент standkit_gui.client к соответствующему агенту)"
+        )
+
+
+def _resolve_dotnet(dotnet: str) -> str:
+    """
+    Резолвит команду ``dotnet`` записи стенда в конкретный исполняемый путь.
+
+    - Если ``dotnet`` уже указывает на существующий файл (абсолютный или
+      относительный путь) — используется как есть, PATH не требуется.
+    - Иначе (голое имя вроде ``"dotnet"``, дефолт по схеме ``Stand``) ищется
+      в PATH через ``shutil.which``.
+
+    Раньше отсутствие ``dotnet`` в PATH приводило к "тихому" провалу —
+    subprocess.Popen падал где-то внутри spawn_hidden() с малопонятной
+    OSError, либо (на некоторых системах) вообще не поднимал процесс без
+    видимой ошибки в UI хаба. Явная проверка здесь даёт понятный текст ДО
+    попытки спавна.
+    """
+    candidate = Path(dotnet)
+    if candidate.exists():
+        return str(candidate)
+    resolved = shutil.which(dotnet)
+    if resolved is None:
+        raise LifecycleError(
+            f"dotnet не найден в PATH: {dotnet!r} — установите .NET SDK/Runtime "
+            "или укажите полный путь в поле 'dotnet' записи реестра стенда"
+        )
+    return resolved
+
+
+def start(
+    stand: Stand,
+    *,
+    run_dir: Optional[Path] = None,
+    log_dir: Optional[Path] = None,
+    startup_check_delay: float = _DEFAULT_STARTUP_CHECK_DELAY,
+) -> int:
+    """
+    Запускает стенд headless-процессом, если он ещё не запущен.
+
+    Возвращает pid процесса (существующего, если стенд уже был жив, либо
+    только что созданного). Бросает ``LifecycleError`` с понятным текстом,
+    если ``dotnet`` не резолвится (см. ``_resolve_dotnet``) либо процесс
+    завершился сразу после старта (см. проверку ``is_alive`` ниже) — раньше
+    в обоих случаях start() мог тихо "вернуть успех", хотя стенд не поднялся.
+
+    Команда запуска — ``dotnet <stand_dll>`` в ``stand_dir``, БЕЗ аргументов
+    командной строки: BPMSoft.WebHost их не принимает (свой CommandLineParser),
+    адрес/порт берётся из конфига стенда. Доп. окружение (ASPNETCORE_ENVIRONMENT
+    и т.п.) при необходимости — зона расширения следующей итерации.
+    """
+    _require_local(stand)
+
+    pf = pidfile_path(stand, run_dir)
+    existing = _read_pid(pf)
+    if existing and _platform.is_alive(existing):
+        return existing
+
+    stand_dir = Path(stand.stand_dir)
+    if not stand_dir.exists():
+        raise LifecycleError(f"Каталог стенда не найден: {stand_dir}")
+
+    dotnet_path = _resolve_dotnet(stand.dotnet)
+    # BPMSoft.WebHost парсит аргументы СВОИМ CommandLineParser и НЕ понимает
+    # ASP.NET-флаги вроде --urls (ошибка «Verb '--urls' is not recognized»).
+    # Адрес/порт стенд берёт из собственного конфига (appsettings). Поэтому
+    # запускаем без доп. аргументов — просто dotnet <stand_dll> в каталоге
+    # стенда (так же, как это делает сам BPMkit/кит).
+    cmd = [dotnet_path, stand.stand_dll]
+    lp = log_path(stand, log_dir)
+    pid = _platform.spawn_hidden(cmd, cwd=stand_dir, log_path=lp)
+
+    if startup_check_delay > 0:
+        time.sleep(startup_check_delay)
+    if not _platform.is_alive(pid):
+        raise LifecycleError(
+            f"процесс стенда '{stand.name}' завершился сразу после старта — "
+            f"смотрите логи ({lp})"
+        )
+
+    _write_pid(pf, pid)
+    return pid
+
+
+def stop(stand: Stand, *, run_dir: Optional[Path] = None) -> bool:
+    """Останавливает стенд, если он запущен. Возвращает True при успешной остановке."""
+    _require_local(stand)
+
+    pf = pidfile_path(stand, run_dir)
+    pid = _read_pid(pf)
+    if pid is None:
+        return True
+
+    stopped = _platform.stop(pid)
+    if stopped:
+        try:
+            pf.unlink(missing_ok=True)
+        except OSError:
+            pass
+    return stopped
+
+
+def restart(stand: Stand, *, run_dir: Optional[Path] = None, log_dir: Optional[Path] = None) -> int:
+    """Останавливает (если жив) и заново запускает стенд. Возвращает новый pid."""
+    stop(stand, run_dir=run_dir)
+    return start(stand, run_dir=run_dir, log_dir=log_dir)
+
+
+def is_running(stand: Stand, *, run_dir: Optional[Path] = None) -> bool:
+    """Быстрая проверка «жив ли стенд» по pidfile (обёртка над standkit.health.process_alive)."""
+    _require_local(stand)
+    pid = _read_pid(pidfile_path(stand, run_dir))
+    return pid is not None and _platform.is_alive(pid)

standkit/logs.py

@@ -0,0 +1,221 @@
+"""
+Работа с per-stand лог-файлом: tail последних N строк и генератор "follow"
+(аналог ``tail -f``) для стрим-панели GUI/агента.
+
+Читает файл КАК БАЙТЫ и декодирует "умным" перебором кодировок (см.
+``_decode_bytes``), а не строго как UTF-8: дочерний .NET-процесс стенда на
+Windows нередко пишет консольный вывод в системной однобайтовой кодировке
+(cp1251/cp866), а не в UTF-8 — строгий "utf-8"-декод в этом случае бил
+кириллицу в "◇" вместо того, чтобы показать её как есть.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Iterator, Optional
+
+# Однобайтовые кандидаты для скоринга (см. ``_decode_bytes``). UTF-8/UTF-8-BOM
+# сюда не входят — они проверяются отдельно, СТРОГО, до скоринга (см. ниже).
+_SINGLE_BYTE_CANDIDATES = ("cp1251", "cp866")
+
+# --- скоринг "читаемости" декодированного текста ---
+#
+# cp1251 и cp866 — обе однобайтовые кодировки: почти ЛЮБАЯ байтовая
+# последовательность декодируется ими БЕЗ ОШИБОК (за редкими исключениями
+# вроде байта 0x98 в cp1251), поэтому раньше "первая, что декодировалась без
+# ошибок" почти всегда отдавала предпочтение cp1251 (она была в списке
+# кандидатов раньше cp866) — даже когда файл был на самом деле в cp866, что
+# давало мойибаке на кириллице. Вместо "первая успешная" — декодируем ОБЕИМИ
+# кандидатными кодировками (``errors="replace"``, чтобы не падать) и выбираем
+# ту, чей результат "читаемее" по эвристической оценке:
+#   + печатные ASCII, \r\n\t, кириллица (U+0400-04FF), типичная пунктуация
+#     (кавычки-ёлочки, тире, обычные знаки препинания) — увеличивают оценку;
+#   - символ-заменитель (U+FFFD, недекодируемый байт), control-символы C1
+#     (U+0080-009F), псевдографика box-drawing (U+2500-257F) и прочие редкие
+#     latin-1-символы (U+00A0-00FF вне кириллицы) — уменьшают оценку (это
+#     типичный "мусор", который получается при декоде байт НЕ той однобайтовой
+#     кодировкой).
+_GOOD_PUNCTUATION = set("«»—-.,!?;:()[]{}'\"/\\%$#@&*+=_~`")
+
+
+def _readability_score(text: str) -> int:
+    """Эвристическая оценка "читаемости" текста — см. пояснение выше модуля."""
+    score = 0
+    for ch in text:
+        cp = ord(ch)
+        if ch in "\r\n\t":
+            score += 1
+        elif 0x20 <= cp <= 0x7E:
+            score += 1
+        elif 0x0400 <= cp <= 0x04FF:
+            score += 2
+        elif ch in _GOOD_PUNCTUATION:
+            score += 1
+        elif ch == "�":
+            score -= 6
+        elif 0x80 <= cp <= 0x9F:
+            score -= 6
+        elif 0x2500 <= cp <= 0x257F:
+            score -= 5
+        elif 0xA0 <= cp <= 0xFF:
+            score -= 2
+        else:
+            score -= 1
+    return score
+
+
+def _decode_single_byte_best(data: bytes) -> str:
+    """
+    Декодирует байты каждой однобайтовой кандидатной кодировкой (см.
+    ``_SINGLE_BYTE_CANDIDATES``, ``errors="replace"`` — эти кодировки
+    практически никогда не бросают исключение сами по себе) и возвращает
+    результат кодировки с НАИБОЛЬШЕЙ оценкой читаемости (``_readability_score``).
+    При равной оценке побеждает первый кандидат по порядку списка (детерминизм).
+    """
+    best_text: Optional[str] = None
+    best_score: Optional[int] = None
+    for encoding in _SINGLE_BYTE_CANDIDATES:
+        decoded = data.decode(encoding, errors="replace")
+        sc = _readability_score(decoded)
+        if best_score is None or sc > best_score:
+            best_text, best_score = decoded, sc
+    assert best_text is not None  # список кандидатов непуст
+    return best_text
+
+
+def _decode_bytes(data: bytes) -> str:
+    """
+    Декодирует байты лога:
+
+    (a) если байты — валидный UTF-8/UTF-8 с BOM (``errors="strict"``) —
+        возвращает его как есть (UTF-8 в приоритете, если он строго валиден:
+        однобайтовые кодировки почти никогда не бракуют произвольные байты,
+        поэтому им нельзя доверять раньше строгой UTF-8-проверки);
+    (b) иначе — скоринг читаемости между cp1251 и cp866 (см.
+        ``_decode_single_byte_best``), кодировка с большей оценкой побеждает;
+    (c) если это тоже не помогло (не должно происходить — (b) всегда
+        возвращает строку) — фолбэк на UTF-8 с ``errors="replace"``, чтобы
+        никогда не падать на бинарном мусоре.
+    """
+    for encoding in ("utf-8-sig", "utf-8"):
+        try:
+            return data.decode(encoding, errors="strict")
+        except UnicodeDecodeError:
+            continue
+    try:
+        return _decode_single_byte_best(data)
+    except Exception:
+        return data.decode("utf-8", errors="replace")
+
+
+def tail(log_path: Path, n: int = 100) -> list[str]:
+    """
+    Возвращает последние ``n`` строк файла лога (без завершающих переводов строк).
+
+    Если файла ещё нет (стенд ни разу не запускался) — возвращает пустой список,
+    а не бросает исключение: отсутствие лога — обычное состояние свежей записи
+    реестра.
+
+    Реализация читает файл целиком (байтами, с "умным" декодом — см.
+    ``_decode_bytes``) — для типичных per-stand логов (десятки МБ) этого
+    достаточно; TODO(следующая итерация): постраничное чтение с конца файла
+    для очень больших логов (сотни МБ и больше), чтобы не держать в памяти
+    файл целиком.
+    """
+    p = Path(log_path)
+    if not p.exists():
+        return []
+    data = p.read_bytes()
+    text = _decode_bytes(data)
+    lines = text.splitlines()
+    return lines[-n:] if n > 0 else []
+
+
+_SESSION_START_MARKER = "=== START pid="
+_APP_STARTING_MARKER = "Application starting"
+
+
+def extract_current_session(text: str) -> str:
+    """
+    Обрезает текст лога до ТЕКУЩЕЙ (последней) сессии стенда — панель
+    "Текущее состояние" в хабе не должна показывать хвост со ВСЕМИ прошлыми
+    запусками (десятки блоков "=== START pid=…"/"Application starting…"), а
+    только вывод с начала последнего запуска.
+
+    Границы сессии ищутся с КОНЦА текста (побеждает последнее вхождение), в
+    порядке приоритета:
+      1. строка, содержащая ``"=== START pid="`` — маркер, который standkit
+         пишет в лог при старте процесса стенда (формат
+         ``=== START pid=NNNN ts=<ISO> ===``);
+      2. если такой строки нет — строка, содержащая ``"Application starting"``
+         (типичная первая строка вывода .NET-хоста стенда при холодном
+         старте — используется как fallback для логов, которые ведёт не сам
+         standkit, а сам стенд/сторонний раннер, без маркера ``START pid=``).
+
+    Если ни одна граница не найдена — возвращает текст без изменений (лог
+    короткий/не содержит распознаваемых маркеров, обрезать нечего).
+
+    Найденная граничная строка ВКЛЮЧАЕТСЯ в результат (сессия показывается
+    с "=== START pid=…" или "Application starting…" включительно).
+    """
+    if not text:
+        return text
+
+    lines = text.split("\n")
+
+    start_idx: Optional[int] = None
+    for i in range(len(lines) - 1, -1, -1):
+        if _SESSION_START_MARKER in lines[i]:
+            start_idx = i
+            break
+
+    if start_idx is None:
+        for i in range(len(lines) - 1, -1, -1):
+            if _APP_STARTING_MARKER in lines[i]:
+                start_idx = i
+                break
+
+    if start_idx is None:
+        return text
+
+    return "\n".join(lines[start_idx:])
+
+
+def follow(log_path: Path, *, poll_interval: float = 0.5) -> Iterator[str]:
+    """
+    Генератор, отдающий новые строки лога по мере их появления (аналог ``tail -f``).
+
+    Блокирующий: между появлениями новых строк "спит" ``poll_interval`` секунд.
+    Предназначен для использования в отдельном потоке/соединении (например,
+    long-poll или SSE-эндпоинт агента) — вызывающая сторона сама решает, когда
+    остановить итерацию (просто перестать тянуть значения из генератора).
+
+    Читает файл в байтовом режиме и декодирует каждую завершённую строку через
+    ``_decode_bytes`` — тот же "умный" перебор кодировок, что и в ``tail``,
+    построчно (буферизуя неполный "хвост" до следующего перевода строки),
+    чтобы не резать многобайтовые последовательности пополам между двумя
+    опросами.
+
+    TODO(следующая итерация): обработка ротации лог-файла (например, через
+    logrotate) — сейчас при пересоздании файла с тем же именем позиция чтения
+    может "уехать" за пределы нового файла и follow() перестанет отдавать строки
+    до следующего перезапуска процесса-читателя.
+    """
+    p = Path(log_path)
+    # Ждём появления файла, если стенд ещё не успел его создать.
+    while not p.exists():
+        time.sleep(poll_interval)
+
+    with p.open("rb") as f:
+        f.seek(0, 2)  # сразу к концу файла — follow не показывает историю
+        buffer = b""
+        while True:
+            chunk = f.read()
+            if chunk:
+                buffer += chunk
+                while b"\n" in buffer:
+                    raw_line, buffer = buffer.split(b"\n", 1)
+                    yield _decode_bytes(raw_line).rstrip("\r")
+            else:
+                time.sleep(poll_interval)