kctl-lib 0.8.0__tar.gz → 0.8.2__tar.gz

{kctl_lib-0.8.0 → kctl_lib-0.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kctl-lib
-Version: 0.8.0
+Version: 0.8.2
 Summary: Shared core library for kctl-* CLI tools
 Requires-Python: >=3.12
 Requires-Dist: httpx>=0.28.0

{kctl_lib-0.8.0 → kctl_lib-0.8.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "kctl-lib"
-version = "0.8.0"
+version = "0.8.2"
 description = "Shared core library for kctl-* CLI tools"
 requires-python = ">=3.12"
 dependencies = [

{kctl_lib-0.8.0 → kctl_lib-0.8.2}/src/kctl_lib/__init__.py

@@ -24,7 +24,7 @@ Public API:
     - tui: Textual TUI (add_tui_command)
 """
 
-__version__ = "0.8.0"
+__version__ = "0.8.2"
 
 from kctl_lib.api_client import APIClient
 from kctl_lib.async_api_client import AsyncAPIClient

kctl_lib-0.8.2/src/kctl_lib/logging_utils.py

@@ -0,0 +1,141 @@
+"""Shared helpers for log filtering and parsing."""
+
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Callable, Iterable, Iterator, Mapping
+from dataclasses import dataclass
+from typing import cast
+
+DEFAULT_ERROR_KEYWORDS = ("ERROR", "CRITICAL", "FATAL", "EXCEPTION", "TRACEBACK")
+
+LEVEL_RANKS = {
+    "DEBUG": 10,
+    "INFO": 20,
+    "NOTICE": 25,
+    "WARN": 30,
+    "WARNING": 30,
+    "ERROR": 40,
+    "CRITICAL": 50,
+    "FATAL": 50,
+}
+
+
+def compile_grep(pattern: str | None) -> re.Pattern[str] | None:
+    """Compile a case-insensitive grep regex and normalize invalid patterns."""
+    if not pattern:
+        return None
+    try:
+        return re.compile(pattern, re.IGNORECASE)
+    except re.error as exc:
+        raise ValueError(f"Invalid grep pattern: {exc}") from exc
+
+
+def is_error_line(line: str, keywords: Iterable[str] = DEFAULT_ERROR_KEYWORDS) -> bool:
+    """Return true when a log line contains a standard error indicator."""
+    upper_line = line.upper()
+    return any(keyword.upper() in upper_line for keyword in keywords)
+
+
+def extract_json_payload(line: str) -> dict[str, object] | None:
+    """Extract the first JSON object embedded in a log line."""
+    start = line.find("{")
+    if start == -1:
+        return None
+
+    try:
+        value, _ = json.JSONDecoder().raw_decode(line[start:])
+    except json.JSONDecodeError:
+        return None
+
+    if not isinstance(value, dict):
+        return None
+    return cast(dict[str, object], value)
+
+
+def _level_rank(level: str | None) -> int | None:
+    if level is None:
+        return None
+    return LEVEL_RANKS.get(level.upper())
+
+
+@dataclass(frozen=True)
+class LogFilter:
+    """Reusable predicate for common log filtering options."""
+
+    min_level: str | None = None
+    grep: re.Pattern[str] | None = None
+    event: str | None = None
+    logger: str | None = None
+
+    def matches(
+        self,
+        line: str,
+        *,
+        level: str | None = None,
+        logger: str | None = None,
+        message: str | None = None,
+        payload: Mapping[str, object] | None = None,
+    ) -> bool:
+        if not self._level_matches(level):
+            return False
+
+        effective_logger = logger
+        effective_event: str | None = None
+        if payload is not None:
+            payload_logger = payload.get("logger")
+            payload_event = payload.get("event")
+            effective_logger = effective_logger or (payload_logger if isinstance(payload_logger, str) else None)
+            effective_event = payload_event if isinstance(payload_event, str) else None
+
+        if self.logger is not None and effective_logger != self.logger:
+            return False
+        if self.event is not None and effective_event != self.event:
+            return False
+
+        if self.grep is None:
+            return True
+
+        haystack = "\n".join(part for part in (line, message, effective_logger, effective_event) if part)
+        return bool(self.grep.search(haystack))
+
+    def _level_matches(self, level: str | None) -> bool:
+        if self.min_level is None:
+            return True
+        min_rank = _level_rank(self.min_level)
+        if min_rank is None:
+            return False
+        rank = _level_rank(level)
+        return rank is not None and rank >= min_rank
+
+
+def iter_sticky_blocks(
+    lines: Iterable[str],
+    *,
+    is_match: Callable[[str], bool],
+    header_regex: re.Pattern[str],
+) -> Iterator[str]:
+    """Yield matching lines while preserving continuation lines after matching headers."""
+    keep_continuation = False
+
+    for line in lines:
+        if header_regex.match(line):
+            keep_continuation = is_match(line)
+            if keep_continuation:
+                yield line
+            continue
+
+        if keep_continuation or is_match(line):
+            keep_continuation = True
+            yield line
+
+
+def filter_sticky_blocks(
+    lines: Iterable[str],
+    *,
+    is_match: Callable[[str], bool],
+    header_regex: re.Pattern[str],
+) -> list[str]:
+    """Filter lines while preserving continuation lines after matching headers."""
+    return list(iter_sticky_blocks(lines, is_match=is_match, header_regex=header_regex))

kctl_lib-0.8.2/src/kctl_lib/py.typed

@@ -0,0 +1 @@
+

{kctl_lib-0.8.0 → kctl_lib-0.8.2}/tests/conftest.py

@@ -26,3 +26,11 @@ def _isolate_user_config(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, reques
     target = tmp_path / "config.yaml"
     monkeypatch.setattr("kctl_lib.config.CONFIG_FILE", target, raising=False)
     monkeypatch.setattr("kctl_lib.config.CONFIG_DIR", tmp_path, raising=False)
+
+
+@pytest.fixture(autouse=True)
+def _isolate_schema_registry(monkeypatch: pytest.MonkeyPatch) -> None:
+    """Keep service-schema registration tests from leaking across packages."""
+    import kctl_lib.schemas as schemas
+
+    monkeypatch.setattr(schemas, "_REGISTRY", dict(schemas._REGISTRY), raising=False)

kctl_lib-0.8.2/tests/test_logging_utils.py

@@ -0,0 +1,70 @@
+"""Tests for shared log parsing/filtering helpers."""
+
+from __future__ import annotations
+
+import re
+
+import pytest
+
+from kctl_lib.logging_utils import (
+    DEFAULT_ERROR_KEYWORDS,
+    LogFilter,
+    compile_grep,
+    extract_json_payload,
+    filter_sticky_blocks,
+    is_error_line,
+)
+
+HEADER_RE = re.compile(r"^\d{4}-\d{2}-\d{2} (?P<level>INFO|WARNING|ERROR|CRITICAL) ")
+
+
+def test_is_error_line_uses_standard_keywords() -> None:
+    assert "TRACEBACK" in DEFAULT_ERROR_KEYWORDS
+    assert is_error_line("worker CRITICAL failed")
+    assert is_error_line("Traceback (most recent call last):")
+    assert not is_error_line("INFO healthy")
+
+
+def test_compile_grep_reports_invalid_regex() -> None:
+    with pytest.raises(ValueError):
+        compile_grep("[")
+
+
+def test_extract_json_payload_from_prefixed_log_line() -> None:
+    assert extract_json_payload('api-1 | {"level":"error","event":"failed"}') == {
+        "level": "error",
+        "event": "failed",
+    }
+    assert extract_json_payload("plain text") is None
+
+
+def test_filter_sticky_blocks_preserves_traceback_continuations() -> None:
+    lines = [
+        "2026-05-17 INFO startup ok\n",
+        "2026-05-17 ERROR request failed\n",
+        "Traceback (most recent call last):\n",
+        '  File "app.py", line 1\n',
+        "ValueError: boom\n",
+        "2026-05-17 INFO next request ok\n",
+    ]
+
+    result = filter_sticky_blocks(lines, is_match=is_error_line, header_regex=HEADER_RE)
+
+    assert result == lines[1:5]
+
+
+def test_log_filter_combines_level_and_grep() -> None:
+    filt = LogFilter(min_level="WARNING", grep=compile_grep("account"))
+
+    assert filt.matches(
+        "2026-05-17 ERROR account.move: failed",
+        level="ERROR",
+        logger="odoo.addons.account",
+        message="account.move failed",
+    )
+    assert not filt.matches(
+        "2026-05-17 INFO account.move: ok",
+        level="INFO",
+        logger="odoo.addons.account",
+        message="account.move ok",
+    )