abstractcore 2.26.0__tar.gz → 2.26.3__tar.gz

{abstractcore-2.26.0 → abstractcore-2.26.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.26.0
+Version: 2.26.3
 Summary: Unified interface to all LLM providers with essential infrastructure for tool calling, streaming, and model management
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 Maintainer-email: Laurent-Philippe Albou <contact@abstractcore.ai>

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/apps/deepsearch.py

@@ -348,6 +348,9 @@ def print_report(report, format_type: str) -> None:
 
 def main():
     """Main CLI function"""
+    from abstractcore.utils.stdio import safe_stdio
+
+    safe_stdio()
     parser = argparse.ArgumentParser(
         description="AbstractCore Deep Search - Autonomous research agent",
         formatter_class=argparse.RawDescriptionHelpFormatter,

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/apps/extractor.py

@@ -145,6 +145,9 @@ def parse_extraction_length(length_str: Optional[str]) -> str:
 
 def main():
     """Main CLI function"""
+    from abstractcore.utils.stdio import safe_stdio
+
+    safe_stdio()
     parser = argparse.ArgumentParser(
         description="AbstractCore Entity & Relationship Extractor - Default: qwen3:4b-instruct-2507-q4_K_M (requires Ollama)",
         formatter_class=argparse.RawDescriptionHelpFormatter,

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/apps/intent.py

@@ -344,6 +344,9 @@ def _format_single_analysis_plain(analysis, analysis_time: float = None) -> list
 
 def main():
     """Main CLI function"""
+    from abstractcore.utils.stdio import safe_stdio
+
+    safe_stdio()
     parser = argparse.ArgumentParser(
         description="AbstractCore Intent Analyzer - Identify and analyze intents behind text",
         formatter_class=argparse.RawDescriptionHelpFormatter,

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/apps/judge.py

@@ -283,6 +283,9 @@ def format_assessment_plain(assessment: dict) -> str:
 
 def main():
     """Main CLI function"""
+    from abstractcore.utils.stdio import safe_stdio
+
+    safe_stdio()
     parser = argparse.ArgumentParser(
         description="AbstractCore Basic Judge - LLM-as-a-judge for objective evaluation (Default: qwen3:4b-instruct-2507-q4_K_M)",
         formatter_class=argparse.RawDescriptionHelpFormatter,

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/apps/summarizer.py

@@ -207,6 +207,9 @@ def format_summary_output(result) -> str:
 
 def main():
     """Main CLI function"""
+    from abstractcore.utils.stdio import safe_stdio
+
+    safe_stdio()
     parser = argparse.ArgumentParser(
         description="AbstractCore Document Summarizer - Default: gemma3:1b-it-qat (requires Ollama)",
         formatter_class=argparse.RawDescriptionHelpFormatter,

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/capabilities/vision_catalog.py

@@ -308,6 +308,8 @@ def _default_lmstudio_model_dirs() -> list[Path]:
 
     sysname = platform.system().lower()
     home = Path.home()
+    # LM Studio 0.3+ keeps its models in ~/.lmstudio/models on every OS (as utils/model_cache).
+    dirs.append(str(home / ".lmstudio" / "models"))
     if sysname == "darwin":
         dirs.append(str(home / "Library" / "Application Support" / "LM Studio" / "models"))
     elif sysname == "linux":

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/config/main.py

@@ -3122,6 +3122,9 @@ _CONFIG_SUBCOMMANDS = {
 
 def main(argv: List[str] = None):
     """Main CLI entry point."""
+    from abstractcore.utils.stdio import safe_stdio
+
+    safe_stdio()
     if argv is None:
         argv = sys.argv[1:]
 

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/config/model_materializer.py

@@ -3170,8 +3170,11 @@ def _hf_marker_unfinished(repo_dir: Path) -> Optional[int]:
         etag = entry.get("etag") if isinstance(entry, dict) else None
         size = entry.get("size") if isinstance(entry, dict) else None
         blob = repo_dir / "blobs" / str(etag or "")
+        name = entry.get("name") if isinstance(entry, dict) else None
         try:
             whole = bool(etag) and blob.is_file() and (not isinstance(size, int) or blob.stat().st_size == size)
+            if not whole and etag and isinstance(name, str):
+                whole = _hf_snapshot_copy_size(repo_dir, name, size if isinstance(size, int) else None) is not None
         except Exception:
             whole = False
         if not whole:
@@ -3389,8 +3392,37 @@ def repair_hf_refs(*, apply: bool = False, cache_dirs: Optional[Iterable[Path]]
     return {"apply": bool(apply), "cache_dirs": [str(d) for d in dirs], "rows": rows, "counts": counts}
 
 
+def _hf_snapshot_copy_size(repo_dir: Path, name: str, size: Optional[int]) -> Optional[int]:
+    """The size of a whole COPY of `name` in a snapshot folder, else None.
+
+    Where the cache cannot hold symbolic links (Windows without Developer Mode),
+    huggingface_hub downloads into `blobs/<etag>.incomplete` and then MOVES the
+    file into `snapshots/<rev>/<name>`: no blob is left behind, and the snapshot
+    entry is a regular file, not a link to a blob. A copy of the planned size
+    (any size when the plan has none) is that file, whole."""
+
+    if not name:
+        return None
+    try:
+        snaps = [d for d in (repo_dir / "snapshots").iterdir() if d.is_dir()]
+    except Exception:
+        return None
+    for snap in snaps:
+        path = snap / name
+        try:
+            if path.is_symlink() or not path.is_file():
+                continue
+            found = path.stat().st_size
+        except Exception:
+            continue
+        if not isinstance(size, int) or found == size:
+            return found
+    return None
+
+
 class _HfBlobWatcher:
-    """Per-file progress from `blobs/<etag>(.incomplete)` sizes."""
+    """Per-file progress from `blobs/<etag>(.incomplete)` sizes, or from the
+    snapshot copy when the cache holds no links (`_hf_snapshot_copy_size`)."""
 
     def __init__(self, repo_dir: Path, plan: Optional[List[Dict[str, Any]]], emit: ProgressCallback, repo_id: str):
         self.repo_dir = repo_dir
@@ -3435,6 +3467,11 @@ class _HfBlobWatcher:
                     row["bytes_done"] = whole.stat().st_size
                     row["state"] = "done"
                     continue
+                copied = _hf_snapshot_copy_size(self.repo_dir, str(row.get("name") or ""), row.get("bytes_total"))
+                if copied is not None and not _hf_partials(self.blobs, str(etag)):
+                    row["bytes_done"] = copied
+                    row["state"] = "done"
+                    continue
                 partial = _hf_partial_size(self.blobs, str(etag))
                 if partial is not None:
                     row["bytes_done"] = partial
@@ -3560,10 +3597,26 @@ import json, os, sys, threading, time
 # The owner passes its pid (argv[2]): reading getppid() here could already
 # see the re-parented value if the owner died during this interpreter's start.
 _owner = int(sys.argv[2]) if len(sys.argv) > 2 else os.getppid()
+def _owner_gone_check():
+    if os.name != "nt":
+        return lambda: os.getppid() != _owner
+    # Windows: a venv's python.exe is a launcher that starts the real
+    # interpreter as ITS child, so getppid() is the launcher, never the owner.
+    # Hold a handle on the owner instead (a handle pins the identity, unlike a
+    # pid number) and ask whether that process has exited.
+    import ctypes
+    k32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    k32.OpenProcess.restype = ctypes.c_void_p
+    k32.WaitForSingleObject.argtypes = [ctypes.c_void_p, ctypes.c_uint32]
+    handle = k32.OpenProcess(0x00100000, False, _owner)  # SYNCHRONIZE
+    if not handle:
+        return lambda: True
+    return lambda: k32.WaitForSingleObject(handle, 0) == 0  # WAIT_OBJECT_0: exited
+_owner_gone = _owner_gone_check()
 def _watch_owner():
     while True:
         time.sleep(1.0)
-        if os.getppid() != _owner:
+        if _owner_gone():
             os._exit(75)  # no goodbye line: the owner's end of the pipe is gone
 threading.Thread(target=_watch_owner, daemon=True).start()
 from huggingface_hub import snapshot_download

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/endpoint/app.py

@@ -1172,6 +1172,9 @@ def _parse_args(argv: Optional[List[str]] = None) -> EndpointConfig:
 
 
 def main(argv: Optional[List[str]] = None) -> None:
+    from abstractcore.utils.stdio import safe_stdio
+
+    safe_stdio()
     cfg = _parse_args(argv)
     app = create_app(provider_name=cfg.provider, model=cfg.model)
     import uvicorn

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/providers/huggingface_provider.py

@@ -4531,8 +4531,19 @@ class HuggingFaceProvider(BaseProvider):
                 )
             return False
 
+        # `crop(n)` with a positive `n` (keep n tokens) was deprecated and is gone in
+        # transformers 5.20; a negative `n` (drop |n| tokens) works on every version.
+        keep = int(keep_tokens)
         try:
-            crop(int(keep_tokens))
+            lengths = self._transformers_layer_seq_lengths(cache)
+        except Exception:
+            lengths = []
+        current = max(lengths) if lengths else None
+        try:
+            if current is None:
+                crop(keep)  # length unknown: the legacy form is the only one available
+            elif current > keep:
+                crop(keep - current)
         except Exception:
             return False
 

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/tools/process_tree.py

@@ -71,13 +71,23 @@ def hard_kill_tree(proc: "subprocess.Popen") -> None:
     POSIX: enumerate descendants first (while the tree is intact), kill the
     worker's own group, then SIGKILL each descendant's process group and the
     descendant itself — so a `setsid()`'d grandchild's group and its children
-    die too. Windows: `proc.kill()` (no group-escape there; best-effort).
+    die too. Windows: `taskkill /T /F` ends the worker and every process it started
+    (a browser driver's Chrome, a shell's children), then `proc.kill()` as the backstop.
 
     Guarded throughout: a descendant reaped between enumeration and kill (or a
     `getpgid` on a dead pid) must never raise — the point is to leave nothing
     alive, not to account for every pid.
     """
     if os.name != "posix":
+        if os.name == "nt":
+            try:
+                subprocess.run(
+                    ["taskkill", "/T", "/F", "/PID", str(proc.pid)],
+                    stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, timeout=15,
+                    creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0),
+                )
+            except Exception:
+                pass
         try:
             proc.kill()
         except Exception:

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/tools/sandbox.py

@@ -507,7 +507,10 @@ def macos_profile(spec: SandboxSpec) -> str:
         while parent and parent != "/":
             if parent not in ancestors:
                 ancestors.append(parent)
-            parent = os.path.dirname(parent)
+            up = os.path.dirname(parent)
+            if up == parent:  # a filesystem root that is not "/" (C:\ on Windows)
+                break
+            parent = up
     if xcrun_rule and xcrun_tmp:
         # Creating the cache file looks up its folder: metadata of the folder and its
         # ancestors only (never a listing or a read of anything else in the temp root).
@@ -515,7 +518,10 @@ def macos_profile(spec: SandboxSpec) -> str:
         while parent and parent != "/":
             if parent not in ancestors:
                 ancestors.append(parent)
-            parent = os.path.dirname(parent)
+            up = os.path.dirname(parent)
+            if up == parent:
+                break
+            parent = up
     if ancestors:
         lines.append("(allow file-read-metadata " + " ".join(f"(literal {_sbpl_str(a)})" for a in ancestors) + ")")
     return "\n".join(lines) + "\n"

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/utils/cli.py

@@ -2671,6 +2671,9 @@ class SimpleCLI:
 
 
 def main():
+    from abstractcore.utils.stdio import safe_stdio
+
+    safe_stdio()
     parser = argparse.ArgumentParser(
         description="Simplified CLI REPL for AbstractCore",
         formatter_class=argparse.RawDescriptionHelpFormatter,

abstractcore-2.26.3/abstractcore/utils/stdio.py

@@ -0,0 +1,29 @@
+"""Console output that never crashes on a character the terminal's code page lacks.
+
+Windows sends a redirected or piped stream (``> file``, ``| Select-String``, CI logs) through
+the ANSI code page, often cp1252, which has no emoji, arrows or box-drawing characters; a
+print of one raised ``UnicodeEncodeError`` and ended the command. The command-line entry
+points call `safe_stdio()` first: an encoding error then writes a replacement character.
+Interactive consoles (UTF-16 through the console API) and UTF-8 streams are left as they are.
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def safe_stdio() -> None:
+    """Make stdout/stderr replace characters their encoding cannot represent."""
+
+    for name in ("stdout", "stderr"):
+        stream = getattr(sys, name, None)
+        reconfigure = getattr(stream, "reconfigure", None)
+        if reconfigure is None:
+            continue
+        encoding = str(getattr(stream, "encoding", "") or "").lower().replace("_", "-")
+        if encoding in {"utf-8", "utf8", "utf-8-sig"}:
+            continue
+        try:
+            reconfigure(errors="replace")
+        except Exception:  # a stream that cannot be reconfigured keeps its behavior
+            pass

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore/utils/version.py

@@ -10,4 +10,4 @@ including when the package is installed from PyPI where pyproject.toml is not av
 """
 
 # Package version - update this when releasing new versions
-__version__ = "2.26.0"
+__version__ = "2.26.3"

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: abstractcore
-Version: 2.26.0
+Version: 2.26.3
 Summary: Unified interface to all LLM providers with essential infrastructure for tool calling, streaming, and model management
 Author-email: Laurent-Philippe Albou <contact@abstractcore.ai>
 Maintainer-email: Laurent-Philippe Albou <contact@abstractcore.ai>

{abstractcore-2.26.0 → abstractcore-2.26.3}/abstractcore.egg-info/SOURCES.txt

@@ -253,6 +253,7 @@ abstractcore/utils/model_cache.py
 abstractcore/utils/model_fit.py
 abstractcore/utils/residency.py
 abstractcore/utils/self_fixes.py
+abstractcore/utils/stdio.py
 abstractcore/utils/structured_logging.py
 abstractcore/utils/token_utils.py
 abstractcore/utils/trace_export.py
@@ -330,4 +331,5 @@ tests/test_structured_output_truncation_retry.py
 tests/test_text_only_model_experience.py
 tests/test_unload_memory.py
 tests/test_user_scenario_validation.py
-tests/test_voice_host_credentials.py
+tests/test_voice_host_credentials.py
+tests/test_windows_host_fixes.py

abstractcore-2.26.3/tests/test_windows_host_fixes.py

@@ -0,0 +1,176 @@
+"""Windows host behavior: console output, process trees and LM Studio's model folder."""
+
+from __future__ import annotations
+
+import io
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import pytest
+
+from abstractcore.utils.stdio import safe_stdio
+
+
+def test_safe_stdio_replaces_what_a_cp1252_stream_cannot_encode(monkeypatch) -> None:
+    raw = io.BytesIO()
+    stream = io.TextIOWrapper(raw, encoding="cp1252", errors="strict")
+    monkeypatch.setattr(sys, "stdout", stream)
+    safe_stdio()
+    print("\U0001f4cb status → ok │", file=sys.stdout)
+    sys.stdout.flush()
+    assert raw.getvalue().decode("cp1252").strip() == "? status ? ok ?"
+
+
+def test_safe_stdio_leaves_a_utf8_stream_as_it_is(monkeypatch) -> None:
+    raw = io.BytesIO()
+    stream = io.TextIOWrapper(raw, encoding="utf-8", errors="strict")
+    monkeypatch.setattr(sys, "stdout", stream)
+    safe_stdio()
+    assert sys.stdout.errors == "strict"
+    print("→", file=sys.stdout)
+    sys.stdout.flush()
+    assert raw.getvalue().decode("utf-8").strip() == "→"
+
+
+def test_safe_stdio_tolerates_streams_without_reconfigure(monkeypatch) -> None:
+    monkeypatch.setattr(sys, "stdout", io.StringIO())
+    monkeypatch.setattr(sys, "stderr", None)
+    safe_stdio()
+
+
+@pytest.mark.parametrize(
+    "module",
+    ["abstractcore.config.main", "abstractcore.utils.cli", "abstractcore.endpoint.app", "abstractcore.apps.summarizer",
+     "abstractcore.apps.extractor", "abstractcore.apps.judge", "abstractcore.apps.intent", "abstractcore.apps.deepsearch"],
+)
+def test_every_console_entry_point_makes_stdio_safe_first(module) -> None:
+    import importlib.util
+    import inspect
+
+    spec = importlib.util.find_spec(module)
+    source = Path(spec.origin).read_text(encoding="utf-8")
+    body = source[source.index("\ndef main("):]
+    assert "safe_stdio()" in body.split("\ndef ", 2)[1], f"{module}.main does not call safe_stdio()"
+
+
+def _alive(pid: int) -> bool:
+    out = subprocess.run(["tasklist", "/FI", f"PID eq {pid}", "/NH"], capture_output=True, text=True).stdout
+    return str(pid) in out
+
+
+@pytest.mark.skipif(os.name != "nt", reason="Windows process tree")
+def test_hard_kill_tree_ends_a_windows_workers_children() -> None:
+    from abstractcore.tools.process_tree import hard_kill_tree
+
+    code = ("import subprocess, sys, time; "
+            "p = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(60)']); "
+            "print(p.pid, flush=True); time.sleep(60)")
+    proc = subprocess.Popen([sys.executable, "-c", code], stdout=subprocess.PIPE, text=True)
+    grandchild = int(proc.stdout.readline())
+    assert _alive(proc.pid) and _alive(grandchild)
+    hard_kill_tree(proc)
+    deadline = time.time() + 10
+    while time.time() < deadline and (_alive(proc.pid) or _alive(grandchild)):
+        time.sleep(0.2)
+    assert not _alive(proc.pid) and not _alive(grandchild)
+
+
+@pytest.mark.parametrize("system", ["Windows", "Darwin", "Linux"])
+def test_lm_studio_models_in_the_home_folder_are_found_on_every_os(tmp_path, monkeypatch, system) -> None:
+    from abstractcore.capabilities import vision_catalog
+
+    models = tmp_path / ".lmstudio" / "models"
+    models.mkdir(parents=True)
+    monkeypatch.setattr(vision_catalog.platform, "system", lambda: system)
+    monkeypatch.setattr(vision_catalog.Path, "home", classmethod(lambda cls: tmp_path))
+    for key in ("LMSTUDIO_MODELS_DIR", "LMSTUDIO_MODEL_DIR", "LM_STUDIO_MODELS_DIR", "LOCALAPPDATA", "APPDATA"):
+        monkeypatch.delenv(key, raising=False)
+    assert models in vision_catalog._default_lmstudio_model_dirs()
+
+
+def _copy_cache(tmp_path: Path) -> tuple[Path, list]:
+    """A Hugging Face cache without links (Windows without Developer Mode): huggingface_hub moved
+    each finished file from blobs/ into snapshots/<rev>/ and left no blob behind."""
+    repo = tmp_path / "models--org--tiny"
+    snap = repo / "snapshots" / "abc123"
+    snap.mkdir(parents=True)
+    (repo / "blobs").mkdir()
+    (snap / "config.json").write_bytes(b"{}" * 10)
+    (snap / "model.safetensors").write_bytes(b"\0" * 300)
+    plan = [{"name": "config.json", "size": 20, "etag": "e1"}, {"name": "model.safetensors", "size": 300, "etag": "e2"}]
+    return repo, plan
+
+
+def test_a_download_into_a_cache_without_links_is_whole(tmp_path) -> None:
+    from abstractcore.config import model_materializer as mm
+
+    repo, plan = _copy_cache(tmp_path)
+    watcher = mm._HfBlobWatcher(repo, plan, lambda *_a, **_k: None, "org/tiny")
+    assert watcher.missing() == []
+    assert watcher.bytes_done() == 320
+
+
+def test_a_snapshot_copy_of_the_wrong_size_is_not_whole(tmp_path) -> None:
+    from abstractcore.config import model_materializer as mm
+
+    repo, plan = _copy_cache(tmp_path)
+    (repo / "snapshots" / "abc123" / "model.safetensors").write_bytes(b"\0" * 10)
+    watcher = mm._HfBlobWatcher(repo, plan, lambda *_a, **_k: None, "org/tiny")
+    assert watcher.missing() == ["model.safetensors"]
+
+
+def test_the_download_marker_counts_snapshot_copies_as_whole(tmp_path) -> None:
+    import json
+    from abstractcore.config import model_materializer as mm
+
+    repo, plan = _copy_cache(tmp_path)
+    (repo / mm._HF_MARKER).write_text(json.dumps({"files": plan}), encoding="utf-8")
+    assert mm._hf_marker_unfinished(repo) == 0
+
+
+def test_a_blob_layout_is_read_as_before(tmp_path) -> None:
+    from abstractcore.config import model_materializer as mm
+
+    repo = tmp_path / "models--org--tiny"
+    (repo / "blobs").mkdir(parents=True)
+    (repo / "snapshots" / "abc123").mkdir(parents=True)
+    (repo / "blobs" / "e1").write_bytes(b"x" * 20)
+    plan = [{"name": "config.json", "size": 20, "etag": "e1"}, {"name": "model.safetensors", "size": 300, "etag": "e2"}]
+    watcher = mm._HfBlobWatcher(repo, plan, lambda *_a, **_k: None, "org/tiny")
+    assert watcher.missing() == ["model.safetensors"]
+
+
+def _owner_watch_header() -> str:
+    from abstractcore.config.model_materializer import _HF_CHILD
+
+    head, sep, _ = _HF_CHILD.partition("from huggingface_hub import snapshot_download")
+    assert sep, "the download child no longer has the expected shape"
+    return head
+
+
+def test_the_download_child_keeps_running_while_its_owner_lives() -> None:
+    # On Windows sys.executable in a venv is a launcher: the child's parent pid is the
+    # launcher, not the owner. The child must not take that for a dead owner.
+    code = _owner_watch_header() + "time.sleep(3.5)\nprint('alive', flush=True)\n"
+    out = subprocess.run(
+        [sys.executable, "-c", code, "{}", str(os.getpid())],
+        capture_output=True, text=True, timeout=60,
+    )
+    assert out.returncode == 0, (out.returncode, out.stderr)
+    assert out.stdout.strip() == "alive"
+
+
+def test_the_download_child_stops_when_its_owner_exits() -> None:
+    owner = subprocess.Popen([sys.executable, "-c", "import time; time.sleep(1.5)"])
+    code = _owner_watch_header() + "time.sleep(30)\nprint('outlived', flush=True)\n"
+    started = time.monotonic()
+    out = subprocess.run(
+        [sys.executable, "-c", code, "{}", str(owner.pid)],
+        capture_output=True, text=True, timeout=60,
+    )
+    owner.wait(timeout=30)
+    assert out.returncode == 75, (out.returncode, out.stdout, out.stderr)
+    assert time.monotonic() - started < 20