MProcs 8.8.2__tar.gz → 8.8.3__tar.gz

{mprocs-8.8.2 → mprocs-8.8.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MProcs
-Version: 8.8.2
+Version: 8.8.3
 Summary: MProcs - derived from NeonBunny
 Author-email: tderk <usvu.tech@gmail.com>
 License: MIT

{mprocs-8.8.2 → mprocs-8.8.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "MProcs"
-version = "8.8.2"
+version = "8.8.3"
 description = "MProcs - derived from NeonBunny"
 requires-python = ">=3.8"
 readme = "README.md"
@@ -18,6 +18,7 @@ MProcs = "MProcs.scripts.main:run"
 mprocs = "MProcs.scripts.main:run"
 lpro = "MProcs.scripts.lpro:main"
 lpro-s = "MProcs.scripts.lpro_s:main"
+gwf = "MProcs.scripts.gwf:run"
 
 [tool.setuptools]
 package-dir = {"" = "src"}

mprocs-8.8.3/src/MProcs/scripts/gwf.py

@@ -0,0 +1,309 @@
+import random
+import string
+import sys
+import threading
+import time
+
+PACKAGE_NAME = "GWF"
+PACKAGE_VERSION = "6.0.0"
+GWF_TITLE = "Granular WireFrame"
+
+_TAG_CHARS = 'ABCDEFGHJKLMNPQRSTUVWXYZ0123456789'
+_MATRIX_CHARS = ('アイウエオカキクケコサシスセソタチツテトナニヌネノ'
+                 '0123456789ABCDEFabcdef+-*/=<>#$%&@')
+
+_GREEN = '\x1b[32m'
+_GREEN_HI = '\x1b[1;32m'
+_GREEN_DIM = '\x1b[2;32m'
+_CYAN = '\x1b[1;36m'
+_YELLOW = '\x1b[1;33m'
+_MAGENTA = '\x1b[1;35m'
+_RED = '\x1b[1;31m'
+_WHITE = '\x1b[1;37m'
+_RESET = '\x1b[0m'
+
+_BLIP_COLORS = [_CYAN, _YELLOW, _MAGENTA, _RED, _WHITE]
+
+
+class Blip:
+    def __init__(self, w, h):
+        self.x = random.uniform(2, max(5, w - 4))
+        self.y = random.uniform(1, max(3, h - 2))
+        self.w = w
+        self.h = h
+        self.tag = ''.join(random.sample(_TAG_CHARS, 2))
+        self.value = random.choice([
+            str(random.randint(0, 99)),
+            '0x%02X' % random.randint(0, 255),
+            '%d%%' % random.randint(0, 100),
+            '%.1f' % random.uniform(0, 9.9),
+            'sig%02d' % random.randint(0, 99),
+        ])
+        self.color = random.choice(_BLIP_COLORS)
+        self.kind = random.choice(['persistent', 'flicker', 'transient', 'transient'])
+        self.vx = random.uniform(-0.5, 0.5)
+        self.vy = random.uniform(-0.3, 0.3)
+        self.life = random.uniform(1.5, 4.0)
+        self.age = 0.0
+        self.visible = True
+        self.blink = random.uniform(0.2, 0.8)
+
+    def update(self, dt):
+        self.age += dt
+        if self.kind == 'persistent':
+            self.x += self.vx * dt
+            self.y += self.vy * dt
+            self.visible = True
+        elif self.kind == 'flicker':
+            self.x += self.vx * dt
+            self.y += self.vy * dt
+            if int(self.age / self.blink) % 2 == 0:
+                self.visible = not self.visible
+        elif self.kind == 'transient':
+            self.visible = self.age < self.life
+        if self.visible:
+            if self.x < 2 or self.x >= self.w - 2:
+                self.vx *= -1
+            if self.y < 1 or self.y >= self.h - 1:
+                self.vy *= -1
+
+
+class Matrix:
+    def __init__(self, w, h):
+        self.w = w
+        self.h = h
+        self.cells = None
+        self.blips = []
+        self.new_instance()
+
+    def _make_blip(self):
+        b = Blip(self.w, self.h)
+        while any(b.tag == o.tag for o in self.blips):
+            b.tag = ''.join(random.sample(_TAG_CHARS, 2))
+        return b
+
+    def new_instance(self):
+        self.cells = [[(0, ' ') for _ in range(self.w)] for _ in range(self.h)]
+        self.blips = []
+        for _ in range(random.randint(8, 16)):
+            self.blips.append(self._make_blip())
+        self.pulse = 0.0
+        self._next_blip_change = 0.0
+        self._rain_acc = 0.0
+
+    def update_rain(self, dt):
+        self.pulse += dt
+        self._rain_acc += dt
+        step = 0.016
+        while self._rain_acc >= step:
+            self._rain_acc -= step
+            for c in range(self.w):
+                for r in range(self.h):
+                    if self.cells[r][c][0] > 0:
+                        self.cells[r][c] = (self.cells[r][c][0] - 1, self.cells[r][c][1])
+                if random.random() < 0.55:
+                    head = 0
+                    while head < self.h and self.cells[head][c][0] > 0:
+                        head += 1
+                    if head < self.h:
+                        self.cells[head][c] = (5, random.choice(_MATRIX_CHARS))
+
+    def update_blips(self, dt):
+        for b in self.blips:
+            b.update(dt)
+        for b in self.blips:
+            if b.kind == 'transient' and not b.visible and random.random() < 0.3:
+                b.x = random.uniform(2, max(5, self.w - 4))
+                b.y = random.uniform(1, max(3, self.h - 2))
+                b.age = 0.0
+        if self.pulse >= self._next_blip_change:
+            self._next_blip_change = self.pulse + random.uniform(1.0, 3.0)
+            if self.blips and random.random() < 0.4:
+                self.blips.pop(random.randrange(len(self.blips)))
+            else:
+                self.blips.append(self._make_blip())
+
+    def update(self, dt):
+        self.update_rain(dt)
+        self.update_blips(dt)
+
+
+class GWF:
+    def __init__(self, tui=None):
+        self.tui = tui
+        self.running = True
+        self._paused = False
+        self._green_paused = False
+        self._speed = 1.0
+        self.matrix = None
+        self.new_instance()
+
+    def _vwidth(self, ch):
+        o = ord(ch)
+        if o < 0x1100:
+            return 1
+        if 0x2E80 <= o <= 0xA4CF or 0xAC00 <= o <= 0xD7A3 or \
+           0xF900 <= o <= 0xFAFF or 0xFF00 <= o <= 0xFF60 or \
+           0x3000 <= o <= 0x303F:
+            return 2
+        return 1
+
+    def _dims(self):
+        if self.tui is not None:
+            width = max(20, getattr(self.tui, 'width', 80) - 2)
+            height = max(6, getattr(self.tui, 'height', 24))
+        else:
+            try:
+                import shutil
+                width, height = shutil.get_terminal_size((80, 24))
+            except Exception:
+                width, height = 80, 24
+            height = max(6, height - 3)
+        return width, height
+
+    def new_instance(self):
+        width, height = self._dims()
+        self.matrix = Matrix(width, height)
+
+    def _frame_rows(self, width, height):
+        m = self.matrix
+        grid = [[None for _ in range(width)] for _ in range(height)]
+        for r in range(min(m.h, height)):
+            c = 0
+            for cc in range(min(m.w, width * 2)):
+                if c >= width:
+                    break
+                power, ch = m.cells[r][cc]
+                if power >= 4:
+                    grid[r][c] = (ch, _GREEN_HI)
+                elif power >= 2:
+                    grid[r][c] = (ch, _GREEN)
+                elif power >= 1:
+                    grid[r][c] = (ch, _GREEN_DIM)
+                c += 1
+        for b in m.blips:
+            if not b.visible:
+                continue
+            x = int(b.x)
+            y = int(b.y)
+            if 0 <= y < height and 0 <= x < width - 2:
+                grid[y][x] = (b.tag[0], b.color)
+                if x + 1 < width:
+                    grid[y][x + 1] = (b.tag[1], b.color)
+                for i, ch in enumerate(b.value):
+                    if x + 3 + i < width:
+                        grid[y][x + 3 + i] = (ch, b.color)
+        rows = []
+        for r in range(height):
+            cells = []
+            for c in range(width):
+                if grid[r][c] is None:
+                    cells.append((' ', ''))
+                else:
+                    cells.append(grid[r][c])
+            # collapse to visual width <= width
+            line = ''
+            prev = ''
+            vw = 0
+            for ch, color in cells:
+                cw = self._vwidth(ch)
+                if vw + cw > width:
+                    break
+                if color != prev:
+                    line += color
+                    prev = color
+                line += ch
+                vw += cw
+            rows.append(line + _RESET)
+        return rows
+
+    def _status_line(self, width):
+        green = 'green ON' if not self._green_paused else 'green OFF'
+        state = 'paused' if self._paused else 'running'
+        blips = len(self.matrix.blips)
+        return _YELLOW + ('  %s  %s  blips:%d  speed:x%.1f'
+                          % (green, state, blips, self._speed)).ljust(width) + _RESET
+
+    def _draw_info(self, width, height):
+        count = max(4, height - 4)
+        rows = self._frame_rows(width, count)
+        title = _CYAN + (' %s - %s ' % (PACKAGE_NAME, GWF_TITLE)).ljust(width) + _RESET
+        keys = _YELLOW + (' [g] pause green  [n] new instance  [p] pause all  [+/-] speed  [q] quit ').ljust(width) + _RESET
+        status = self._status_line(width)
+        body = '\n'.join(rows[:max(1, count - 3)])
+        print('\x1b[2J' + title + '\n' + body + '\n' + status + '\n' + keys + '\n', end='', flush=True)
+
+    def _animate(self, stop):
+        try:
+            last = time.monotonic()
+            while not stop['v']:
+                now = time.monotonic()
+                dt = min(0.1, now - last)
+                last = now
+                if not self._paused:
+                    if not self._green_paused:
+                        self.matrix.update_rain(dt * self._speed)
+                    self.matrix.update_blips(dt * self._speed)
+                    width, height = self._dims()
+                    if width != self.matrix.w or height != self.matrix.h:
+                        self.matrix.w = width
+                        self.matrix.h = height
+                    self._draw_info(width, height)
+                time.sleep(0.05)
+        except BaseException:
+            pass
+
+    def _on_key(self, key):
+        if isinstance(key, str):
+            k = key.lower()
+            if k == 'g':
+                self._green_paused = not self._green_paused
+                return True
+            if k == 'n':
+                self.new_instance()
+                return True
+            if k == 'p':
+                self._paused = not self._paused
+                return True
+            if k == '+':
+                self._speed = min(8.0, self._speed * 1.5)
+                return True
+            if k == '-':
+                self._speed = max(0.05, self._speed / 1.5)
+                return True
+            if k == 'q':
+                self.running = False
+                return True
+        return False
+
+    def run_wrapper(self, tui, lpro, lpro_s, session_usr='zeta', active='s', first=True):
+        self.tui = tui
+        try:
+            from . import tui as tui_mod
+            return_to_menu = tui_mod._ReturnToMenu
+        except ImportError:
+            return_to_menu = None
+        tui.set_app_key_handler(self._on_key)
+        width, height = self._dims()
+        self._draw_info(width, height)
+        stop = {'v': False}
+        thread = threading.Thread(target=self._animate, args=(stop,), daemon=True)
+        thread.start()
+        try:
+            while not tui.exit_requested and self.running:
+                time.sleep(0.1)
+        finally:
+            stop['v'] = True
+            thread.join(timeout=0.5)
+            tui.set_app_key_handler(None)
+        if return_to_menu is not None:
+            raise return_to_menu()
+
+
+def run():
+    app = GWF()
+    app.run_wrapper(None, None, None)
+
+
+if __name__ == '__main__':
+    run()

{mprocs-8.8.2 → mprocs-8.8.3}/src/MProcs/scripts/tui.py

@@ -288,6 +288,10 @@ class MProcsTUI:
         self._stdscr = None
         self._dirty = True
         self._last_clock = None
+        self.app_key_handler = None
+
+    def set_app_key_handler(self, handler):
+        self.app_key_handler = handler
 
     def _emit(self, text):
         self._out_q.put(text)
@@ -514,6 +518,13 @@ class MProcsTUI:
         if self.menu_mode:
             self._handle_menu_key(key)
             return
+        if not self.input_active and self.app_key_handler is not None:
+            try:
+                if self.app_key_handler(key):
+                    self._dirty = True
+                    return
+            except Exception:
+                pass
         if key in (curses.KEY_PPAGE, curses.KEY_NPAGE):
             page = max(3, self.height - 4)
             self._scroll_by(-page if key == curses.KEY_PPAGE else page)

{mprocs-8.8.2 → mprocs-8.8.3}/src/MProcs/scripts/version_checker.py

@@ -13,7 +13,7 @@ try:
     import importlib.metadata
     PACKAGE_VERSION = importlib.metadata.version(PACKAGE_NAME)
 except Exception:
-    PACKAGE_VERSION = "8.8.2"
+    PACKAGE_VERSION = "8.8.3"
 
 _latest_version = None
 _update_available = False

{mprocs-8.8.2 → mprocs-8.8.3}/src/MProcs/scripts/wrappers.py

@@ -122,6 +122,15 @@ class VanillaWrapper(AppWrapper):
     package = 'MProcs'
 
 
+class GwfWrapper(AppWrapper):
+    name = 'GWF'
+    package = 'MProcs'
+
+    def _run_app(self, tui, lpro, lpro_s, first=True):
+        import gwf
+        gwf.GWF(tui).run_wrapper(tui, None, None)
+
+
 ALL_APPS = [
     MdcciWrapper(),
     NeonBunnyWrapper(),
@@ -132,4 +141,5 @@ ALL_APPS = [
     MornWrapper(),
     DestinyWrapper(),
     VanillaWrapper(),
+    GwfWrapper(),
 ]

{mprocs-8.8.2 → mprocs-8.8.3}/src/MProcs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: MProcs
-Version: 8.8.2
+Version: 8.8.3
 Summary: MProcs - derived from NeonBunny
 Author-email: tderk <usvu.tech@gmail.com>
 License: MIT

{mprocs-8.8.2 → mprocs-8.8.3}/src/MProcs.egg-info/SOURCES.txt

@@ -11,6 +11,7 @@ src/MProcs/scripts/__init__.py
 src/MProcs/scripts/ai_image.py
 src/MProcs/scripts/data_loader.py
 src/MProcs/scripts/deepseek_ai.py
+src/MProcs/scripts/gwf.py
 src/MProcs/scripts/keys.py
 src/MProcs/scripts/lpro.py
 src/MProcs/scripts/lpro_s.py

{mprocs-8.8.2 → mprocs-8.8.3}/src/MProcs.egg-info/entry_points.txt

@@ -1,5 +1,6 @@
 [console_scripts]
 MProcs = MProcs.scripts.main:run
+gwf = MProcs.scripts.gwf:run
 lpro = MProcs.scripts.lpro:main
 lpro-s = MProcs.scripts.lpro_s:main
 mprocs = MProcs.scripts.main:run