eq-layer 0.2.0__tar.gz → 0.2.2__tar.gz

{eq_layer-0.2.0 → eq_layer-0.2.2}/PKG-INFO

@@ -1,14 +1,16 @@
 Metadata-Version: 2.5
 Name: eq-layer
-Version: 0.2.0
+Version: 0.2.2
 Summary: Inspectable intent, affect, repair, uncertainty, and factored-action control for LLM responses
 Project-URL: Homepage, https://github.com/Furox-Art/eq-layer
 Project-URL: Repository, https://github.com/Furox-Art/eq-layer
+Project-URL: Changelog, https://github.com/Furox-Art/eq-layer/blob/main/CHANGELOG.md
 Project-URL: Issues, https://github.com/Furox-Art/eq-layer/issues
+Project-URL: Security, https://github.com/Furox-Art/eq-layer/blob/main/SECURITY.md
 Author: Furox-Art
 License: MIT
 License-File: LICENSE
-Keywords: affective-computing,agent-skills,agents,dialogue-management,intent-classification,llm,llm-steering
+Keywords: affective-computing,agent-skills,agents,dialogue-management,dialogue-policy,intent-classification,llm,llm-steering,response-quality
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
@@ -17,6 +19,8 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Requires-Python: >=3.10
 Provides-Extra: dev

{eq_layer-0.2.0 → eq_layer-0.2.2}/eq_layer/__init__.py

@@ -1,5 +1,4 @@
-__version__ = "0.2.0"
-
+from ._version import __version__
 from .affect import AffectAdapter, HeuristicAffect, load_cases
 from .auditor import AuditContext, AuditIssue, ResponseAudit, ResponseAuditor, audit_from_generation_metadata
 from .actions import FactoredAction, RealizationControls, compose_action
@@ -8,7 +7,13 @@ from .intent_belief import IntentBelief, IntentRiskDecision, decide_intent_actio
 from .interaction import InteractionQualityState, RepairState, infer_interaction_quality, infer_repair_state
 from .policies import POLICIES, REGISTRY, SUBTEXTS, AffectState, Policy, Register, Selector
 from .preferences import SessionPreferences, infer_session_preferences
-from .response_experiment import CommandModel, FullEQPipeline, generate_pairs, validate_experiment_cases
+from .response_experiment import (
+    CommandModel,
+    FullEQPipeline,
+    ModelCommandTimeout,
+    generate_pairs,
+    validate_experiment_cases,
+)
 from .steer import Steer, aggregate, score_case
 from .trained_affect import DimensionalAffect, TrainedAffect
 from .trained_intent import TrainedIntent
@@ -62,6 +67,7 @@ __all__ = [
     "AnnotationStanceResolver",
     "CommandModel",
     "FullEQPipeline",
+    "ModelCommandTimeout",
     "generate_pairs",
     "validate_experiment_cases",
     "score_case",

eq_layer-0.2.2/eq_layer/_version.py

@@ -0,0 +1,57 @@
+"""Single source of truth for the EQ-Layer Python package version.
+
+The editable location is the ``version`` field of the ``[project]`` table in
+``pyproject.toml``. When the distribution is installed, ``importlib.metadata``
+is authoritative; from a source checkout the same field is read from the
+nearest ``pyproject.toml`` so both paths report the identical string instead
+of a hardcoded copy that drifts (audit M4).
+"""
+
+from __future__ import annotations
+
+import re
+from importlib.metadata import PackageNotFoundError, version
+from pathlib import Path
+
+DISTRIBUTION = "eq-layer"
+
+_PROJECT_HEADER = re.compile(r"(?m)^\[project\]\s*$")
+_NEXT_TABLE = re.compile(r"(?m)^\[")
+_VERSION_KEY = re.compile(r'(?m)^version\s*=\s*"([^"]+)"')
+
+
+def _project_table(pyproject_text: str) -> str:
+    """Return the ``[project]`` table body, or "" when absent.
+
+    Scoping the search matters: an unrelated ``version =`` key under another
+    table must not win over the package version.
+    """
+    header = _PROJECT_HEADER.search(pyproject_text)
+    if header is None:
+        return ""
+    rest = pyproject_text[header.end() :]
+    next_table = _NEXT_TABLE.search(rest)
+    return rest[: next_table.start()] if next_table else rest
+
+
+def _source_checkout_version() -> str | None:
+    here = Path(__file__).resolve()
+    for parent in here.parents:
+        pyproject = parent / "pyproject.toml"
+        if not pyproject.is_file():
+            continue
+        match = _VERSION_KEY.search(_project_table(pyproject.read_text(encoding="utf-8")))
+        if match:
+            return match.group(1)
+    return None
+
+
+def detect_version() -> str:
+    try:
+        return version(DISTRIBUTION)
+    except PackageNotFoundError:
+        # Source checkout without an installed distribution.
+        return _source_checkout_version() or "0.0.0+unknown"
+
+
+__version__ = detect_version()

{eq_layer-0.2.0 → eq_layer-0.2.2}/eq_layer/auditor.py

@@ -4,6 +4,8 @@ import re
 from dataclasses import asdict, dataclass
 from difflib import SequenceMatcher
 
+from .textnorm import normalise_light as _normalise
+
 
 ABSOLUTE_PRIVACY_PROMISES = (
     "kimseye söylemem",
@@ -77,10 +79,6 @@ class ResponseAudit:
         }
 
 
-def _normalise(text: str) -> str:
-    return " ".join(text.lower().split())
-
-
 def _sentence_starts(text: str) -> tuple[str, ...]:
     parts = re.split(r"(?<=[.!?])\s+|\n+", _normalise(text))
     return tuple(part.strip(" -—:;,.!?") for part in parts if part.strip())

{eq_layer-0.2.0 → eq_layer-0.2.2}/eq_layer/cli.py

@@ -125,9 +125,11 @@ def _route(args: argparse.Namespace) -> int:
 
 
 def _doctor() -> int:
+    from . import __version__
+
     payload = {
         "package": "eq-layer",
-        "version": "0.2.0",
+        "version": __version__,
         "python": sys.version.split()[0],
         "ml_extra_available": True,
     }

{eq_layer-0.2.0 → eq_layer-0.2.2}/eq_layer/dialogue_reference.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import re
 from dataclasses import dataclass
 
+from .textnorm import normalise_plain
+
 
 @dataclass(frozen=True)
 class GoalCandidate:
@@ -106,8 +108,9 @@ _USER_GOAL_MARKERS = (
 
 
 def _normalise(text: str) -> str:
-    lowered = text.lower().replace("\u0307", "")
-    return " ".join(re.sub(r"[^\w\s]", " ", lowered).split())
+    # Drop the Turkish combining dot above so dotted and dotless spellings of
+    # the same word compare equal before the shared punctuation pass.
+    return normalise_plain(text, drop_combining_dot_above=True)
 
 
 def _excerpt(text: str) -> str:

{eq_layer-0.2.0 → eq_layer-0.2.2}/eq_layer/intent.py

@@ -5,6 +5,7 @@ from dataclasses import dataclass
 from typing import Protocol
 
 from .intent_belief import IntentBelief, IntentRiskDecision
+from .textnorm import normalise_light
 
 
 @dataclass(frozen=True)
@@ -179,7 +180,7 @@ class HeuristicIntent:
         return f'{prefix}: "{request}".{suffix}'
 
     def _normalise(self, text: str) -> str:
-        return " ".join(text.lower().split())
+        return normalise_light(text)
 
     def _first_marker(self, text: str, markers: tuple[str, ...]) -> str | None:
         for marker in markers:

{eq_layer-0.2.0 → eq_layer-0.2.2}/eq_layer/interaction.py

@@ -4,6 +4,7 @@ import re
 from dataclasses import dataclass
 
 from .affect import CORRECTION_MARKERS
+from .textnorm import normalise_plain as _normalise
 
 
 @dataclass(frozen=True)
@@ -42,10 +43,6 @@ class InteractionQualityState:
     evidence: tuple[str, ...] = ()
 
 
-def _normalise(text: str) -> str:
-    return " ".join(re.sub(r"[^\w\s]", " ", text.lower()).split())
-
-
 def _has_correction(text: str) -> bool:
     low = text.lower()
     return any(marker in low for marker in CORRECTION_MARKERS)

{eq_layer-0.2.0 → eq_layer-0.2.2}/eq_layer/preferences.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 import re
 from dataclasses import asdict, dataclass, replace
 
+from .textnorm import normalise_light as _normalise
+
 
 SESSION_SCOPE_PATTERNS = (
     r"\bbundan sonra\b",
@@ -44,10 +46,6 @@ class SessionPreferences:
         return asdict(self)
 
 
-def _normalise(text: str) -> str:
-    return " ".join(text.lower().split())
-
-
 def _session_scoped(text: str) -> bool:
     low = _normalise(text)
     if any(re.search(pattern, low) for pattern in SESSION_SCOPE_PATTERNS):

{eq_layer-0.2.0 → eq_layer-0.2.2}/eq_layer/response_experiment.py

@@ -6,6 +6,7 @@ import random
 import re
 import shlex
 import subprocess
+import threading
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Iterable
@@ -28,6 +29,42 @@ LEAKAGE_FIELDS = {
 }
 
 
+class ModelCommandTimeout(RuntimeError):
+    """A model command failed to answer within its configured timeout.
+
+    Raised for both the one-shot and the persistent command modes so callers
+    (including the A/B generation CLI) can catch one typed error instead of
+    pattern-matching messages. Subclasses ``RuntimeError`` like the other
+    model-command failures.
+    """
+
+
+def _force_kill(process: subprocess.Popen) -> None:
+    """Best-effort hard kill of a wedged child so its pipes close.
+
+    Used by the persistent-command timeout path and as the escalation step of
+    ``CommandModel.close``. Terminate first, then kill if the child ignores
+    it; both are no-ops when the process has already been reaped.
+    """
+    try:
+        process.terminate()
+    except OSError:
+        pass
+    try:
+        process.wait(timeout=5)
+        return
+    except subprocess.TimeoutExpired:
+        pass
+    try:
+        process.kill()
+    except OSError:
+        pass
+    try:
+        process.wait(timeout=5)
+    except subprocess.TimeoutExpired:
+        pass
+
+
 def validate_experiment_cases(cases: list[dict], *, final: bool = False) -> dict:
     errors: list[str] = []
     seen: set[str] = set()
@@ -222,14 +259,20 @@ class CommandModel:
         if self.persistent:
             raw = self._persistent_generate(payload)
         else:
-            completed = subprocess.run(
-                list(self.command),
-                input=json.dumps(payload, ensure_ascii=False),
-                text=True,
-                capture_output=True,
-                timeout=self.timeout_seconds,
-                check=False,
-            )
+            try:
+                completed = subprocess.run(
+                    list(self.command),
+                    input=json.dumps(payload, ensure_ascii=False),
+                    text=True,
+                    capture_output=True,
+                    timeout=self.timeout_seconds,
+                    check=False,
+                )
+            except subprocess.TimeoutExpired as exc:
+                raise ModelCommandTimeout(
+                    f"Model command did not respond within "
+                    f"{self.timeout_seconds} seconds: {' '.join(self.command)}"
+                ) from exc
             if completed.returncode != 0:
                 raise RuntimeError(
                     f"Model command failed ({completed.returncode}): "
@@ -261,7 +304,7 @@ class CommandModel:
 
         process.stdin.write(json.dumps(payload, ensure_ascii=False) + "\n")
         process.stdin.flush()
-        raw = process.stdout.readline().strip()
+        raw = self._read_line(process, self.timeout_seconds)
         if not raw:
             stderr = process.stderr.read().strip() if process.stderr else ""
             raise RuntimeError(
@@ -270,6 +313,40 @@ class CommandModel:
             )
         return raw
 
+    def _read_line(self, process: subprocess.Popen, timeout_seconds: float) -> str:
+        """Read one stdout line from the child under a wall-clock deadline.
+
+        A blocking ``readline()`` on a pipe waits until the child writes a
+        newline, and on Windows a blocked pipe read cannot be interrupted, so
+        the read runs on a daemon reader thread that is joined with the
+        configured timeout. On expiry the child is force-killed: its stdout
+        closes, the blocked read unwinds with EOF, and a wedged model command
+        can never stall the experiment synchronously.
+        """
+        stdout = process.stdout
+        if stdout is None:
+            raise RuntimeError("Persistent model command pipes are unavailable.")
+
+        lines: list[str] = []
+
+        def _read() -> None:
+            lines.append(stdout.readline())
+
+        reader = threading.Thread(
+            target=_read,
+            name="eq-layer-model-reader",
+            daemon=True,
+        )
+        reader.start()
+        reader.join(timeout_seconds)
+        if reader.is_alive():
+            _force_kill(process)
+            raise ModelCommandTimeout(
+                f"Persistent model command produced no response within "
+                f"{timeout_seconds} seconds: {' '.join(self.command)}"
+            )
+        return lines[0].strip() if lines else ""
+
     @staticmethod
     def _decode_response(raw: str) -> str:
         if not raw:
@@ -300,12 +377,7 @@ class CommandModel:
         try:
             process.wait(timeout=10)
         except subprocess.TimeoutExpired:
-            process.terminate()
-            try:
-                process.wait(timeout=5)
-            except subprocess.TimeoutExpired:
-                process.kill()
-                process.wait(timeout=5)
+            _force_kill(process)
 
 
 @dataclass

eq_layer-0.2.2/eq_layer/textnorm.py

@@ -0,0 +1,42 @@
+"""Shared text-normalisation helpers.
+
+Five modules used to carry copy-pasted ``_normalise`` helpers, and the copies
+had already drifted into two behaviours:
+
+* a light form — lowercase and collapse whitespace, punctuation preserved
+  (``auditor``, ``preferences``, ``intent``);
+* a plain form — also replace punctuation runs with spaces (``interaction``),
+  with ``dialogue_reference`` additionally dropping the Turkish combining dot
+  above (U+0307) so dotted and dotless spellings compare equal.
+
+Both behaviours live here, in one place. Callers must keep using the variant
+their matching logic was written against: this consolidation removes the
+duplicated code without silently changing any matcher's semantics.
+"""
+
+from __future__ import annotations
+
+import re
+
+_PUNCTUATION = re.compile(r"[^\w\s]")
+_COMBINING_DOT_ABOVE = "\u0307"
+
+
+def normalise_light(text: str) -> str:
+    """Lowercase and collapse whitespace. Punctuation is preserved."""
+    return " ".join(text.lower().split())
+
+
+def normalise_plain(text: str, *, drop_combining_dot_above: bool = False) -> str:
+    """Lowercase, replace punctuation with spaces, and collapse whitespace.
+
+    ``drop_combining_dot_above`` removes U+0307 before the punctuation pass so
+    that ``i`` + combining dot above normalises like a bare ``i``. This is
+    needed by Turkish dotted/dotless matching in the dialogue-reference
+    matcher; it is off by default so the default behaviour stays identical to
+    the historical copies.
+    """
+    lowered = text.lower()
+    if drop_combining_dot_above:
+        lowered = lowered.replace(_COMBINING_DOT_ABOVE, "")
+    return " ".join(_PUNCTUATION.sub(" ", lowered).split())

{eq_layer-0.2.0 → eq_layer-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "eq-layer"
-version = "0.2.0"
+version = "0.2.2"
 description = "Inspectable intent, affect, repair, uncertainty, and factored-action control for LLM responses"
 readme = "README.md"
 license = { text = "MIT" }
@@ -13,9 +13,11 @@ keywords = [
   "agents",
   "agent-skills",
   "dialogue-management",
+  "dialogue-policy",
   "affective-computing",
   "intent-classification",
   "llm-steering",
+  "response-quality",
 ]
 classifiers = [
   "Development Status :: 3 - Alpha",
@@ -26,6 +28,8 @@ classifiers = [
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Topic :: Scientific/Engineering :: Artificial Intelligence",
 ]
 dependencies = []
@@ -46,7 +50,9 @@ eq-layer = "eq_layer.cli:main"
 [project.urls]
 Homepage = "https://github.com/Furox-Art/eq-layer"
 Repository = "https://github.com/Furox-Art/eq-layer"
+Changelog = "https://github.com/Furox-Art/eq-layer/blob/main/CHANGELOG.md"
 Issues = "https://github.com/Furox-Art/eq-layer/issues"
+Security = "https://github.com/Furox-Art/eq-layer/blob/main/SECURITY.md"
 
 [build-system]
 requires = ["hatchling"]
@@ -63,6 +69,9 @@ include = [
   "/THIRD_PARTY_DATA.md",
 ]
 
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
 [tool.ruff]
 line-length = 100