pipulate 2.58__tar.gz → 2.60__tar.gz

{pipulate-2.58/pipulate.egg-info → pipulate-2.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipulate
-Version: 2.58
+Version: 2.60
 Summary: The context compiler that helps you prompt well — local-first, Nix-reproducible, replayable. The successor to AI SEO software.
 Author-email: Mike Levin <pipulate@gmail.com>
 License-Expression: AGPL-3.0-or-later

{pipulate-2.58 → pipulate-2.60}/__init__.py

@@ -12,7 +12,7 @@ Usage:
     pipulate
 """
 
-__version__ = "2.58"
+__version__ = "2.60"
 # APOSTROPHES RESTORED (2026-08-04). They were stripped as a workaround for
 # flake.nix's descMatch regex, whose character class excluded ' from the
 # CAPTURE and truncated the banner to "(So)". That regex was fixed in the same
@@ -23,7 +23,7 @@ __version__ = "2.58"
 # is not a property of the system; the regex is. Blast radius is one banner:
 # nothing but flake.nix reads this name -- version_sync.py syncs __version__
 # and __description__, never this. So'wI' chu' -- "engage the cloaking device."
-__version_description__ = "NPvg.org 1st 10 Minutes"
+__version_description__ = "Putting the v in NPvg"
 # SPDX expression, single source of truth, synced into pyproject.toml by
 # scripts/release/version_sync.py. "-or-later" (not bare AGPL-3.0, which is
 # deprecated SPDX) because the header below grants "any later version".

{pipulate-2.58 → pipulate-2.60}/imports/voice_synthesis.py

@@ -15,7 +15,9 @@ import signal
 import sys
 from pathlib import Path
 from typing import Optional, Dict, Any
+import contextlib
 import logging
+import warnings
 
 # Try to import voice synthesis dependencies
 try:
@@ -35,6 +37,42 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
+
+@contextlib.contextmanager
+def _quiet_hub():
+    """Silence the hub for the length of the one download it ever makes.
+
+    THE QUIET WALK (2026-09-18, Mac receipt, deed 1480): the first consent
+    printed a three-line deprecation notice, a token nag and three progress
+    bars between the card and the first spoken step. The hub speaks through
+    two channels, its logger and the warnings module, and draws its bars
+    through its own switch; all three are turned down here and restored on
+    the way out, so nothing outside this block changes. The download itself
+    is announced by one plain line in the caller.
+    """
+    try:
+        from huggingface_hub.utils import (
+            are_progress_bars_disabled,
+            disable_progress_bars,
+            enable_progress_bars,
+        )
+    except ImportError:
+        are_progress_bars_disabled = disable_progress_bars = enable_progress_bars = None
+    hub_logger = logging.getLogger("huggingface_hub")
+    previous_level = hub_logger.level
+    hub_logger.setLevel(logging.ERROR)
+    bars_were_disabled = True if disable_progress_bars is None else are_progress_bars_disabled()
+    if not bars_were_disabled:
+        disable_progress_bars()
+    try:
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            yield
+    finally:
+        hub_logger.setLevel(previous_level)
+        if not bars_were_disabled:
+            enable_progress_bars()
+
 # ---------------------------------------------------------------------------
 # THE VOICE ASKS BEFORE IT SPEAKS (2026-09-17). Two functions, one file.
 # voice_consent() is the BARRIER: every path to sound reads it, fresh, on every
@@ -157,29 +195,35 @@ class ChipVoiceSystem:
             self.model_path = str(local_model_dir / model_path_in_repo)
             self.config_path = str(local_model_dir / config_path_in_repo)
             
+            downloaded = False
             # Download files if they don't exist
             if not os.path.exists(self.model_path):
+                print("Downloading the voice, about 60 MB, once...", flush=True)
                 logger.info(f"🎤 Downloading voice model: {model_path_in_repo}...")
-                hf_hub_download(
-                    repo_id=repo_id, 
-                    filename=model_path_in_repo, 
-                    local_dir=local_model_dir, 
-                    local_dir_use_symlinks=False
-                )
+                with _quiet_hub():
+                    hf_hub_download(
+                        repo_id=repo_id,
+                        filename=model_path_in_repo,
+                        local_dir=local_model_dir,
+                    )
+                downloaded = True
             
             if not os.path.exists(self.config_path):
                 logger.info(f"🎤 Downloading voice config: {config_path_in_repo}...")
-                hf_hub_download(
-                    repo_id=repo_id, 
-                    filename=config_path_in_repo, 
-                    local_dir=local_model_dir, 
-                    local_dir_use_symlinks=False
-                )
+                with _quiet_hub():
+                    hf_hub_download(
+                        repo_id=repo_id,
+                        filename=config_path_in_repo,
+                        local_dir=local_model_dir,
+                    )
+                downloaded = True
             
             # Load the voice model
             self.voice = PiperVoice.load(self.model_path, config_path=self.config_path)
             self.voice_ready = True
             logger.info("🎤 Voice model loaded successfully")
+            if downloaded:
+                print("Voice ready.", flush=True)
             
         except Exception as e:
             logger.error(f"🎤 Failed to setup voice model: {e}")
@@ -197,6 +241,12 @@ class ChipVoiceSystem:
         if not VOICE_SYNTHESIS_AVAILABLE:
             self.last_error = f"voice synthesis not installed: {IMPORT_ERROR}"
             return False
+        # THE PHONEME LINE (TODO of 2026-09-15, discharged 2026-09-18): piper
+        # warns, through a logger nobody configured, about one syllabic mark
+        # in the word "written", and Python's last-resort handler prints the
+        # bare message on every walk. The flake's door-1 greeting already sets
+        # this level; the speaker now sets it for every caller.
+        logging.getLogger("piper").setLevel(logging.ERROR)
         self.setup_voice_model()
         return self.voice_ready
 

{pipulate-2.58 → pipulate-2.60/pipulate.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipulate
-Version: 2.58
+Version: 2.60
 Summary: The context compiler that helps you prompt well — local-first, Nix-reproducible, replayable. The successor to AI SEO software.
 Author-email: Mike Levin <pipulate@gmail.com>
 License-Expression: AGPL-3.0-or-later

{pipulate-2.58 → pipulate-2.60}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "pipulate"
 # VERSION NOTE: Synced from pipulate/__init__.py.__version__ via python version_sync.py
-version = "2.58"
+version = "2.60"
 authors = [
   { name="Mike Levin", email="pipulate@gmail.com" },
 ]

{pipulate-2.58 → pipulate-2.60}/tools/scraper_tools.py

@@ -3,6 +3,7 @@ import asyncio
 import hashlib
 import json
 import os
+import shlex
 import sys
 import shutil
 import tempfile
@@ -21,6 +22,18 @@ from selenium.webdriver.common.by import By
 from tools import auto_tool
 from . import dom_tools
 
+# THE HEAL HAPPENS ONCE PER RUN (2026-09-18, Mac receipt, deed 1480). The
+# flake pins no Chrome on a Mac, so the driver is matched to the host's
+# Chrome at launch: the first uc.Chrome raises on the version mismatch, the
+# window it had opened closes, and the retry below relaunches with
+# version_main set to the browser's major version. That version was thrown
+# away after every stop, so a three-stop walk paid the close-and-reopen at
+# every stop and printed a WARNING three times for the ordinary case. It is
+# remembered here for the life of the process: the next launch passes it in
+# and never mismatches. A dict, not a bare name, so no function needs a
+# global statement to write it.
+_HEAL = {"version_main": None}
+
 async def generate_optics_subprocess(target_dir_path: str):
     """Isolated wrapper to call llm_optics.py as a subprocess, protecting the event loop."""
     script_path = Path(__file__).resolve().parent / "llm_optics.py"
@@ -59,35 +72,38 @@ def _guided_path_component(url: str) -> tuple[str, str]:
 
 
 # --- Optional audio during browser startup ---
-# Forked from stream.py's start_updating_music/stop_updating_music pattern:
-# a marker-tagged shell loop in its OWN process group (os.setsid), killed as
-# a group, with an idempotent pkill backstop keyed to the marker so it can
-# never touch any other aplay pipeline. The wav lives in repo negative space
-# (gitignored) or ~/.local/share/pipulate/; absent file = silent no-op.
+# Operator-owned courtesy sounds live outside the repo. tick.wav loops while
+# the browser is opening; ding.wav plays once when the page-load phase ends.
+# No file means no sound. Linux uses aplay; Darwin uses afplay.
 SCRAPE_MUSIC_MARKER = "pipulate-scrape-music"
+SOUND_DIR = Path.home() / ".local/share/pipulate"
 
 
-def _find_music_file():
-    candidates = [
-        Path(__file__).resolve().parent.parent / "jeopardy.wav",
-        Path.home() / ".local/share/pipulate/jeopardy.wav",
-        Path.home() / ".local/share/honeybot/jeopardy.wav",
-    ]
-    for c in candidates:
-        if c.exists():
-            return c
-    return None
+def _sound_file(name):
+    path = SOUND_DIR / name
+    return path if path.is_file() else None
+
+
+def _player_args(sound):
+    if sound is None:
+        return None
+    if sys.platform == "darwin":
+        player = shutil.which("afplay")
+        return [player, str(sound)] if player else None
+    player = shutil.which("aplay")
+    return [player, "-q", "-D", "default", str(sound)] if player else None
 
 
 def _start_scrape_music(verbose=True):
     import subprocess
-    music = _find_music_file()
-    if not music:
-        return None
 
+    args = _player_args(_sound_file("tick.wav"))
+    if not args:
+        return None
+    command = " ".join(shlex.quote(part) for part in args)
     try:
         return subprocess.Popen(
-            ["sh", "-c", f'while :; do aplay -q -D default "{music}"; done # {SCRAPE_MUSIC_MARKER}'],
+            ["sh", "-c", f"while :; do {command}; done # {SCRAPE_MUSIC_MARKER}"],
             stdout=subprocess.DEVNULL,
             stderr=subprocess.DEVNULL,
             preexec_fn=os.setsid,
@@ -96,18 +112,36 @@ def _start_scrape_music(verbose=True):
         return None
 
 
-def _stop_scrape_music(proc):
+def _stop_scrape_music(proc, ding=False):
     import signal
     import subprocess
+
     if proc is not None:
         try:
             os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
         except Exception:
             pass
     try:
-        subprocess.run(["pkill", "-f", SCRAPE_MUSIC_MARKER], check=False)
+        subprocess.run(
+            ["pkill", "-f", SCRAPE_MUSIC_MARKER],
+            check=False,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
     except Exception:
         pass
+    if ding:
+        args = _player_args(_sound_file("ding.wav"))
+        if args:
+            try:
+                subprocess.run(
+                    args,
+                    check=False,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                )
+            except Exception:
+                pass
 
 
 def _simplify_html_for_llm(html_content, default_title=""):
@@ -223,7 +257,7 @@ def _document_candidates(cdp_events: list, domain: str, final_url: str = "") ->
     return on_host
 
 
-def _capture_checkpoint(stdin=None, stdout=None) -> dict:
+def _capture_checkpoint(stdin=None, stdout=None, before_prompt=None) -> dict:
     """Require an explicit CAPTURE token from the human's keyboard.
 
     /DEV/TTY PREFERENCE (convicted 2026-07-29, public_walk stop 1): the
@@ -265,8 +299,16 @@ def _capture_checkpoint(stdin=None, stdout=None) -> dict:
             }
 
         try:
+            if before_prompt is not None:
+                try:
+                    before_prompt()
+                except Exception as exc:
+                    output_stream.write(f"\n(checkpoint narration unavailable: {exc})\n")
+            else:
+                output_stream.write(
+                    "\nWhen the page you want is ready, type CAPTURE and press Enter.\n"
+                )
             output_stream.write(
-                "\nWhen the page you want is ready, type CAPTURE and press Enter.\n"
                 "Any other response aborts without capturing artifacts.\n"
                 "CAPTURE> "
             )
@@ -560,7 +602,8 @@ async def _selenium_capture(params: dict, checkpoint=None) -> dict:
             driver = uc.Chrome(options=options, 
                                user_data_dir=str(profile_path), 
                                browser_executable_path=browser_path,
-                               driver_executable_path=driver_path)
+                               driver_executable_path=driver_path,
+                               version_main=_HEAL["version_main"])
         except Exception as e:
             error_msg = str(e)
             if "Current browser version is" in error_msg:
@@ -568,7 +611,10 @@ async def _selenium_capture(params: dict, checkpoint=None) -> dict:
                 match = re.search(r'Current browser version is (\d+)', error_msg)
                 if match:
                     fallback_version = int(match.group(1))
-                    logger.warning(f"⚠️ Chrome version mismatch detected. Auto-healing with version_main={fallback_version}")
+                    _HEAL["version_main"] = fallback_version
+                    logger.info(f"Chrome {fallback_version}: driver matched; relaunching once for this run")
+                    if verbose:
+                        print(f"Chrome closed and is reopening once while its driver is matched to Chrome {fallback_version}; that is normal.", flush=True)
                     # UC consumes the options object. We must forge a fresh one.
                     fresh_options = uc.ChromeOptions()
                     fresh_options.set_capability("goog:loggingPrefs", {"performance": "ALL"})
@@ -592,20 +638,25 @@ async def _selenium_capture(params: dict, checkpoint=None) -> dict:
         logger.info(f"Navigating to: {url}")
         driver.get(url)
 
-        try:
-            if verbose: logger.info("Waiting for security challenge to trigger a reload (Stage 1)...")
-            initial_body = driver.find_element(By.TAG_NAME, 'body')
-            WebDriverWait(driver, 20).until(EC.staleness_of(initial_body))
-            if verbose: logger.success("✅ Page reload detected!")
-            
-            if verbose: logger.info("Waiting for main content to appear after reload (Stage 2)...")
-            WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "body")))
-            if verbose: logger.success("✅ Main content located!")
-        except Exception as e:
-            if verbose: logger.info(f"Did not detect a page reload for security challenge. Proceeding anyway.")
+        # A human-guided ride already has the CAPTURE fence as its settle
+        # detector. The 20-second staleness wait exists for unattended sigil
+        # scrapes, where a security interstitial may reload underneath us.
+        if not interactive:
+            try:
+                if verbose: logger.info("Waiting for security challenge to trigger a reload (Stage 1)...")
+                initial_body = driver.find_element(By.TAG_NAME, 'body')
+                WebDriverWait(driver, 20).until(EC.staleness_of(initial_body))
+                if verbose: logger.success("✅ Page reload detected!")
+
+                if verbose: logger.info("Waiting for main content to appear after reload (Stage 2)...")
+                WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "body")))
+                if verbose: logger.success("✅ Main content located!")
+            except Exception:
+                if verbose: logger.info("Did not detect a page reload for security challenge. Proceeding anyway.")
 
-        # The wait is over one way or the other: cut the think-music sharply.
-        _stop_scrape_music(music_proc)
+        # The page-load phase is over: stop ticking and, if the operator
+        # supplied one, play the ready sound exactly once.
+        _stop_scrape_music(music_proc, ding=True)
         music_proc = None
 
         if checkpoint is not None:
@@ -737,8 +788,8 @@ async def _selenium_capture(params: dict, checkpoint=None) -> dict:
             # ledger-only so it can be replayed offline over any cached capture.
             #
             # [-1] SURVIVES, and its rationale is still UNWITNESSED: the
-            # staleness_of() wait above exists because a security challenge
-            # serves an interstitial Document and then reloads, making the LAST
+            # non-interactive staleness_of() wait above exists because a security
+            # challenge serves an interstitial Document and then reloads, making the LAST
             # candidate the real page. No capture on this machine has ever been
             # challenged -- every scrape logs "Did not detect a page reload."
             # The reasoning is sound from the code and has no receipt behind it.
@@ -956,7 +1007,7 @@ async def selenium_automation(params: dict) -> dict:
     return await _selenium_capture(params)
 
 
-async def guided_browser_capture(params: dict, stdin=None, stdout=None) -> dict:
+async def guided_browser_capture(params: dict, stdin=None, stdout=None, before_prompt=None) -> dict:
     """Capture one human-guided page through one visible persistent driver."""
     if not isinstance(params, dict):
         return {
@@ -1029,5 +1080,6 @@ async def guided_browser_capture(params: dict, stdin=None, stdout=None) -> dict:
         checkpoint=lambda: _capture_checkpoint(
             stdin=input_stream,
             stdout=stdout,
+            before_prompt=before_prompt,
         ),
     )