kiwi-code 0.0.29__tar.gz → 0.0.30__tar.gz

{kiwi_code-0.0.29 → kiwi_code-0.0.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kiwi-code
-Version: 0.0.29
+Version: 0.0.30
 Summary: A textual-based terminal user interface application
 Project-URL: Homepage, https://meetkiwi.ai
 Project-URL: Repository, https://github.com/jetoslabs/kiwi-code

{kiwi_code-0.0.29 → kiwi_code-0.0.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "kiwi-code"
-version = "0.0.29"
+version = "0.0.30"
 description = "A textual-based terminal user interface application"
 readme = {file = "README.md", content-type = "text/markdown"}
 requires-python = ">=3.11,<4.0"

kiwi_code-0.0.30/src/kiwi_tui/random_words.py

@@ -0,0 +1,9 @@
+from kiwi_tui.status_words import next_status_word
+def random_verb(*, default: str = "Thinking") -> str:
+    """Return a curated "-ing" status word for display (e.g. "Searching")."""
+
+    return next_status_word(default=default)
+
+
+def random_adjective(*, default: str = "Curious") -> str:  # pragma: no cover
+    return default

kiwi_code-0.0.30/src/kiwi_tui/status_words.py

@@ -0,0 +1,481 @@
+from collections import deque
+from dataclasses import dataclass, field
+from functools import lru_cache
+import random
+import threading
+import time
+from typing import Deque, Iterable
+
+
+_STATUS_WORDS_RAW: tuple[str, ...] = (
+    "Thinking",
+    "Working",
+    "Responding",
+    "Reasoning",
+    "Reflecting",
+    "Considering",
+    "Pondering",
+    "Deliberating",
+    "Planning",
+    "Prioritizing",
+    "Organizing",
+    "Outlining",
+    "Strategizing",
+    "Brainstorming",
+    "Ideating",
+    "Envisioning",
+    "Imagining",
+    "Inferring",
+    "Deducing",
+    "Concluding",
+    "Deciding",
+    "Choosing",
+    "Reconsidering",
+    "Reassessing",
+    "Evaluating",
+    "Estimating",
+    "Calculating",
+    "Computing",
+    "Measuring",
+    "Counting",
+    "Timing",
+    "Comparing",
+    "Contrasting",
+    "Weighing",
+    "Balancing",
+    "Aligning",
+    "Centering",
+    "Spacing",
+    "Arranging",
+    "Resizing",
+    "Wrapping",
+    "Rendering",
+    "Styling",
+    "Theming",
+    "Polishing",
+    "Refining",
+    "Improving",
+    "Optimizing",
+    "Tuning",
+    "Simplifying",
+    "Streamlining",
+    "Modernizing",
+    "Upgrading",
+    "Updating",
+    "Reworking",
+    "Rewriting",
+    "Editing",
+    "Proofreading",
+    "Formatting",
+    "Drafting",
+    "Writing",
+    "Summarizing",
+    "Condensing",
+    "Clarifying",
+    "Explaining",
+    "Describing",
+    "Documenting",
+    "Annotating",
+    "Commenting",
+    "Noting",
+    "Labeling",
+    "Tagging",
+    "Indexing",
+    "Cataloging",
+    "Listing",
+    "Sorting",
+    "Grouping",
+    "Filtering",
+    "Selecting",
+    "Collecting",
+    "Gathering",
+    "Compiling",
+    "Assembling",
+    "Combining",
+    "Merging",
+    "Splitting",
+    "Separating",
+    "Isolating",
+    "Narrowing",
+    "Pinpointing",
+    "Investigating",
+    "Inspecting",
+    "Reviewing",
+    "Rereading",
+    "Reading",
+    "Scanning",
+    "Browsing",
+    "Searching",
+    "Exploring",
+    "Discovering",
+    "Observing",
+    "Monitoring",
+    "Tracking",
+    "Tracing",
+    "Logging",
+    "Instrumenting",
+    "Profiling",
+    "Benchmarking",
+    "Testing",
+    "Retesting",
+    "Validating",
+    "Verifying",
+    "Confirming",
+    "Checking",
+    "Crosschecking",
+    "Doublechecking",
+    "Rechecking",
+    "Auditing",
+    "Diagnosing",
+    "Debugging",
+    "Reproducing",
+    "Triaging",
+    "Resolving",
+    "Fixing",
+    "Repairing",
+    "Mitigating",
+    "Preventing",
+    "Safeguarding",
+    "Securing",
+    "Hardening",
+    "Sanitizing",
+    "Normalizing",
+    "Cleaning",
+    "Tidying",
+    "Pruning",
+    "Trimming",
+    "Archiving",
+    "Restoring",
+    "Saving",
+    "Autosaving",
+    "Persisting",
+    "Storing",
+    "Caching",
+    "Preloading",
+    "Loading",
+    "Fetching",
+    "Retrieving",
+    "Downloading",
+    "Uploading",
+    "Syncing",
+    "Synchronizing",
+    "Refreshing",
+    "Connecting",
+    "Reconnecting",
+    "Handshaking",
+    "Authenticating",
+    "Authorizing",
+    "Negotiating",
+    "Provisioning",
+    "Initializing",
+    "Booting",
+    "Starting",
+    "Restarting",
+    "Resuming",
+    "Pausing",
+    "Waiting",
+    "Queueing",
+    "Retrying",
+    "Recovering",
+    "Stabilizing",
+    "Configuring",
+    "Reconfiguring",
+    "Customizing",
+    "Parameterizing",
+    "Templating",
+    "Generating",
+    "Synthesizing",
+    "Deriving",
+    "Transforming",
+    "Parsing",
+    "Tokenizing",
+    "Serializing",
+    "Deserializing",
+    "Encoding",
+    "Decoding",
+    "Compressing",
+    "Decompressing",
+    "Encrypting",
+    "Decrypting",
+    "Migrating",
+    "Seeding",
+    "Backfilling",
+    "Importing",
+    "Exporting",
+    "Consolidating",
+    "Aggregating",
+    "Reconciling",
+    "Harmonizing",
+    "Coordinating",
+    "Collaborating",
+    "Communicating",
+    "Listening",
+    "Asking",
+    "Answering",
+    "Advising",
+    "Suggesting",
+    "Recommending",
+    "Guiding",
+    "Coaching",
+    "Helping",
+    "Assisting",
+    "Supporting",
+    "Sharing",
+    "Notifying",
+    "Reporting",
+    "Presenting",
+    "Approving",
+    "Finalizing",
+    "Launching",
+    "Deploying",
+    "Building",
+    "Bundling",
+    "Packaging",
+    "Releasing",
+    "Shipping",
+    "Installing",
+    "Uninstalling",
+    "Executing",
+    "Running",
+    "Scheduling",
+    "Orchestrating",
+    "Automating",
+    "Scripting",
+    "Branching",
+    "Committing",
+    "Rebasing",
+    "Pushing",
+    "Pulling",
+    "Cloning",
+    "Forking",
+    "Versioning",
+    "Linting",
+    "Refactoring",
+    "Modularizing",
+    "Encapsulating",
+    "Integrating",
+    "Interfacing",
+    "Adapting",
+    "Abstracting",
+    "Decomposing",
+    "Recomposing",
+    "Prototyping",
+    "Sketching",
+    "Tinkering",
+    "Noodling",
+    "Spelunking",
+    "Diagramming",
+    "Visualizing",
+    "Simulating",
+    "Emulating",
+    "Staging",
+    "Navigating",
+    "Traversing",
+    "Examining",
+    "Disambiguating",
+    "Canonicalizing",
+    "Contextualizing",
+    "Operationalizing",
+    "Instrumenting",
+    "Triangulating",
+    "Deobfuscating",
+    "Deinterleaving",
+    "Reparameterizing",
+    "Recontextualizing",
+    "Disentangling",
+    "Deconvoluting",
+    "Corroborating",
+    "Extrapolating",
+    "Interpolating",
+    "Reconceptualizing",
+    "Rationalizing",
+    "Formalizing",
+    "Generalizing",
+    "Specializing",
+    "Particularizing",
+    "Virtualizing",
+    "Containerizing",
+    "Deprovisioning",
+    "Sandboxing",
+    "Backporting",
+    "Forwardporting",
+    "Snapshotting",
+    "Diffing",
+    "Grepping",
+    "Vendoring",
+    "Reindexing",
+    "Rerendering",
+    "Revalidating",
+    "Recalibrating",
+    "Reassociating",
+    "Enumerating",
+    "Assimilating",
+    "Ameliorating",
+    "Interrogating",
+    "Disseminating",
+    "Discretizing",
+    "Denormalizing",
+    "Deprioritizing",
+    "Underprovisioning",
+    "Assimilating",
+    "Scaffolding",
+    "Excavating",
+    "Unearthing",
+    "Deciphering",
+    "Synthesizing",
+    "Converging",
+    "Diverging",
+    "Reticulating",
+    "Transpiling",
+    "Hydrating",
+    "Materializing",
+    "Manifesting",
+    "Crystallizing",
+    "Coalescing",
+    "Distilling",
+    "Ferreting",
+    "Foraging",
+    "Sifting",
+    "Winnowing",
+    "Untangling",
+    "Unraveling",
+    "Threading",
+    "Stitching",
+    "Splicing",
+    "Grafting",
+    "Weaving",
+    "Braiding",
+    "Layering",
+    "Etching",
+    "Carving",
+    "Chiseling",
+    "Sculpting",
+    "Forging",
+    "Tempering",
+    "Annealing",
+    "Calibrating",
+    "Synchronizing",
+    "Sequencing",
+    "Interleaving",
+    "Compacting",
+    "Densifying",
+    "Canonicalizing",
+    "Curating",
+    "Shepherding",
+    "Marshalling",
+    "Funneling",
+    "Grounding",
+    "Anchoring",
+    "Illuminating",
+    "Conjuring",
+    "Juggling",
+    "Wrangling",
+    "Untangling",
+    "Unsnarling",
+    "Puzzling",
+    "Scheming",
+    "Machinating",
+    "Whispering",
+    "Summoning",
+    "Brewing",
+    "Steeping",
+    "Percolating",
+    "Marinating",
+    "Fermenting",
+    "Incubating",
+    "Hatching",
+    "Gobbling",
+    "Nibbling",
+    "Munching",
+    "Chewing",
+    "Digesting",
+    "Rummaging",
+    "Scavenging",
+    "Foraging",
+    "Poking",
+    "Prodding",
+    "Tickling",
+    "Massaging",
+    "Jiggling",
+    "Shimmying",
+    "Scooting",
+    "Zipping",
+    "Zooming",
+    "Whizzing",
+    "Bleeping",
+    "Blooping",
+    "Beeping",
+    "Booping",
+    "Tinkering",
+    "Fiddling",
+    "Doodling",
+    "Noodling",
+    "Goblinizing",
+    "Wizarding",
+    "Enchanting",
+    "Spellcasting",
+    "Alchemizing",
+    "Treasure-hunting",
+    "Dragon-wrangling",
+)
+
+
+def _clean_words(items: Iterable[str]) -> tuple[str, ...]:
+
+    seen: set[str] = set()
+    out: list[str] = []
+    for it in items:
+        w = str(it or "").strip()
+        if not w:
+            continue
+        if " " in w:
+            continue
+        if not w.isalpha():
+            continue
+        if not w.lower().endswith("ing"):
+            continue
+        w = w[0].upper() + w[1:]
+        if w in seen:
+            continue
+        seen.add(w)
+        out.append(w)
+    return tuple(out)
+
+
+STATUS_WORDS: tuple[str, ...] = _clean_words(_STATUS_WORDS_RAW)
+
+if len(STATUS_WORDS) < 50:  # pragma: no cover
+    STATUS_WORDS = ("Thinking", "Working", "Responding")
+
+
+@dataclass
+class _DeckRotator:
+    words: tuple[str, ...]
+    rng: random.Random
+    lock: threading.Lock = field(default_factory=threading.Lock)
+    deck: Deque[str] = field(default_factory=deque)
+
+    def next(self, *, default: str = "Thinking") -> str:
+        if not self.words:
+            return default
+
+        with self.lock:
+            if not self.deck:
+                items = list(self.words)
+                self.rng.shuffle(items)
+                self.deck.extend(items)
+
+            try:
+                return self.deck.popleft()
+            except Exception:
+                return default
+
+
+@lru_cache(maxsize=1)
+def _rotator() -> _DeckRotator:
+    seed = time.time_ns() & 0xFFFFFFFF
+    return _DeckRotator(words=STATUS_WORDS, rng=random.Random(seed))
+
+
+def next_status_word(*, default: str = "Thinking") -> str:
+    return _rotator().next(default=default)

{kiwi_code-0.0.29 → kiwi_code-0.0.30}/uv.lock

@@ -397,7 +397,7 @@ wheels = [
 
 [[package]]
 name = "kiwi-code"
-version = "0.0.29"
+version = "0.0.30"
 source = { editable = "." }
 dependencies = [
     { name = "autobots-client" },

kiwi_code-0.0.29/src/kiwi_tui/random_words.py

@@ -1,80 +0,0 @@
-from functools import lru_cache
-
-
-@lru_cache(maxsize=1)
-def _ww() -> object | None:
-    try:
-        from wonderwords import RandomWord  # type: ignore
-
-        return RandomWord()
-    except Exception:
-        return None
-
-
-def _to_present_participle(verb: str) -> str:
-    v = (verb or "").strip()
-    if not v:
-        return ""
-    w = v.lower()
-
-    # Common irregulars / spelling rules that a simple suffix approach misses.
-    irregular = {
-        "be": "being",
-        "see": "seeing",
-        "flee": "fleeing",
-        "knee": "kneeing",
-        "die": "dying",
-        "tie": "tying",
-        "lie": "lying",
-    }
-    if w in irregular:
-        return irregular[w].capitalize()
-
-    # ie -> ying (die -> dying).
-    if w.endswith("ie") and len(w) > 2:
-        return (w[:-2] + "ying").capitalize()
-
-    # Drop trailing e (make -> making), but keep ee/ye/oe (see -> seeing).
-    if w.endswith("e") and not w.endswith(("ee", "ye", "oe")) and len(w) > 1:
-        return (w[:-1] + "ing").capitalize()
-
-    # Verbs ending in 'ic' often add 'k' (panic -> panicking).
-    if w.endswith("ic") and len(w) > 2:
-        return (w + "king").capitalize()
-
-    vowels = set("aeiou")
-    # Double final consonant for short CVC words with a/i/o/u vowel (run -> running).
-    if (
-        3 <= len(w) <= 4
-        and w[-1] not in vowels
-        and w[-1] not in "wxy"
-        and w[-2] in vowels
-        and w[-2] != "e"
-        and w[-3] not in vowels
-    ):
-        return (w + w[-1] + "ing").capitalize()
-
-    return (w + "ing").capitalize()
-
-
-def random_verb(*, default: str = "Thinking") -> str:
-    """Return a random present-participle verb for display (e.g. "Searching")."""
-    rw = _ww()
-    if rw is None:
-        return default
-
-    try:
-        # wonderwords supports parts_of_speech filtering.
-        word = rw.word(include_parts_of_speech=["verbs"])  # type: ignore[attr-defined]
-        word = str(word or "").strip()
-        if not word:
-            return default
-        ing = _to_present_participle(word)
-        return ing if ing else default
-    except Exception:
-        return default
-
-
-# Backward-compat alias (older code used adjectives).
-def random_adjective(*, default: str = "Curious") -> str:  # pragma: no cover
-    return default