zhmiscellany 5.8.6__py3-none-any.whl → 6.0.9__py3-none-any.whl

zhmiscellany/_fileio_supportfuncs.py

@@ -1,4 +1,8 @@
+import sys
+
 def is_junction(entry):
+    if sys.platform != "win32":
+        return False
     try:
         st = entry.stat(follow_symlinks=False)
         # On Windows, st_file_attributes is available.

zhmiscellany/_misc_supportfuncs.py

@@ -1,7 +1,19 @@
-import threading, os, signal, time, sys, shutil, ctypes
+import threading, os, signal, time, sys, shutil, ctypes, math
 from ctypes import Structure, c_long, c_uint, c_int, POINTER, sizeof
 import zhmiscellany.fileio
-import win32api, math
+import sys
+
+# Windows-specific imports
+if sys.platform == "win32":
+    try:
+        import win32api
+        from ctypes import windll
+        WIN32_AVAILABLE = True
+    except ImportError:
+        WIN32_AVAILABLE = False
+        print("Warning: Windows modules not available - Windows functionality disabled")
+else:
+    WIN32_AVAILABLE = False
 
 
 _misc_action = 0
@@ -48,7 +60,8 @@ def patch_rhg():  # patches random_header_generator library's missing files. thi
     else:
         # we are running in normal Python environment
         pass
-patch_rhg()
+if WIN32_AVAILABLE:
+    patch_rhg()
 
 
 def patch_cpp():
@@ -75,111 +88,219 @@ def patch_cpp():
         gen()
         shutil.copy2(os.path.join(base_path, 'resources', fn), tp)
         os.chdir(cwd)
-patch_cpp()
 
+if WIN32_AVAILABLE:
+    patch_cpp()
+
+import ctypes
+import os
+import math
+import sys
+from ctypes import c_int, c_uint, c_long, POINTER, Structure, sizeof, byref, c_ulong, c_void_p
+
+# --- OS Detection ---
+IS_LINUX = not WIN32_AVAILABLE
+
+# --- Windows Imports & Structures ---
+if WIN32_AVAILABLE:
+    windll = ctypes.windll
+
+if WIN32_AVAILABLE:
+    class POINT(Structure):
+        _fields_ = [("x", c_long),
+                    ("y", c_long)]
+
+
+    class MOUSEINPUT(Structure):
+        _fields_ = [("dx", c_long),
+                    ("dy", c_long),
+                    ("mouseData", c_uint),
+                    ("dwFlags", c_uint),
+                    ("time", c_uint),
+                    ("dwExtraInfo", POINTER(c_uint))]
 
-class POINT(Structure):
-    _fields_ = [("x", c_long),
-                ("y", c_long)]
 
+    class INPUT_UNION(ctypes.Union):
+        _fields_ = [("mi", MOUSEINPUT)]
 
-class MOUSEINPUT(Structure):
-    _fields_ = [("dx", c_long),
-                ("dy", c_long),
-                ("mouseData", c_uint),
-                ("dwFlags", c_uint),
-                ("time", c_uint),
-                ("dwExtraInfo", POINTER(c_uint))]
 
+    class INPUT(Structure):
+        _fields_ = [("type", c_int),
+                    ("union", INPUT_UNION)]
 
-class INPUT_UNION(ctypes.Union):
-    _fields_ = [("mi", MOUSEINPUT)]
 
+    # Windows Constants
+    MOUSEEVENTF_ABSOLUTE = 0x8000
+    MOUSEEVENTF_MOVE = 0x0001
+    MOUSEEVENTF_LEFTDOWN = 0x0002
+    MOUSEEVENTF_LEFTUP = 0x0004
+    MOUSEEVENTF_RIGHTDOWN = 0x0008
+    MOUSEEVENTF_RIGHTUP = 0x0010
+    MOUSEEVENTF_MIDDLEDOWN = 0x0020
+    MOUSEEVENTF_MIDDLEUP = 0x0040
 
-class INPUT(Structure):
-    _fields_ = [("type", c_int),
-                ("union", INPUT_UNION)]
+# --- Linux / X11 Setup ---
+if IS_LINUX:
+    try:
+        # Load X11 and XTest (required for fake inputs)
+        x11 = ctypes.cdll.LoadLibrary("libX11.so.6")
+        xtst = ctypes.cdll.LoadLibrary("libXtst.so.6")
 
+        # Setup Display
+        display = x11.XOpenDisplay(None)
+        root_window = x11.XDefaultRootWindow(display)
 
-# Constants
-MOUSEEVENTF_ABSOLUTE = 0x8000
-MOUSEEVENTF_MOVE = 0x0001
-MOUSEEVENTF_LEFTDOWN = 0x0002
-MOUSEEVENTF_LEFTUP = 0x0004
-MOUSEEVENTF_RIGHTDOWN = 0x0008
-MOUSEEVENTF_RIGHTUP = 0x0010
-MOUSEEVENTF_MIDDLEDOWN = 0x0020
-MOUSEEVENTF_MIDDLEUP = 0x0040
+    except OSError:
+        print("Error: Could not load X11 or Xtst libraries. Ensure libx11-6 and libxtst6 are installed.")
+        x11 = None
+        xtst = None
 
-# Screen metrics
+
+# --- Screen Metrics ---
 def get_actual_screen_resolution():
-    hdc = ctypes.windll.user32.GetDC(0)
-    width = ctypes.windll.gdi32.GetDeviceCaps(hdc, 118)  # HORZRES
-    height = ctypes.windll.gdi32.GetDeviceCaps(hdc, 117)  # VERTRES
-    ctypes.windll.user32.ReleaseDC(0, hdc)
-    return width, height
+    if WIN32_AVAILABLE:
+        if WIN32_AVAILABLE:
+            hdc = windll.user32.GetDC(0)
+            width = windll.gdi32.GetDeviceCaps(hdc, 118)  # HORZRES
+            height = windll.gdi32.GetDeviceCaps(hdc, 117)  # VERTRES
+            windll.user32.ReleaseDC(0, hdc)
+            return width, height
+        return 1920, 1080
+    elif IS_LINUX and x11:
+        screen_num = 0
+        width = x11.XDisplayWidth(display, screen_num)
+        height = x11.XDisplayHeight(display, screen_num)
+        return width, height
+    else:
+        return 1920, 1080
+
 
 SCREEN_WIDTH, SCREEN_HEIGHT = get_actual_screen_resolution()
 
+# --- Globals ---
 calibrated = False
 calipass = False
+calibration_multiplier_x = 1.0
+calibration_multiplier_y = 1.0
+
+
+# --- Functions ---
 
 def move_mouse(x: int, y: int, relative=False):
-    if not relative:
-        # Convert coordinates to normalized coordinates (0-65535)
-        normalized_x = int(x * (65535 / SCREEN_WIDTH))
-        normalized_y = int(y * (65535 / SCREEN_HEIGHT))
-    else:
-        calibrate()
-        if calibrated:
-            normalized_x = math.ceil(x * calibration_multiplier_x)
-            normalized_y = math.ceil(y * calibration_multiplier_y)
+    if WIN32_AVAILABLE:
+        if not relative:
+            # Convert coordinates to normalized coordinates (0-65535)
+            normalized_x = int(x * (65535 / SCREEN_WIDTH))
+            normalized_y = int(y * (65535 / SCREEN_HEIGHT))
+            dwflags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE
         else:
-            normalized_x = x
-            normalized_y = y
-
-    if not relative:
-        dwflags = MOUSEEVENTF_ABSOLUTE | MOUSEEVENTF_MOVE
-    else:
-        dwflags = MOUSEEVENTF_MOVE
-
-    input_struct = INPUT(
-        type=0,  # INPUT_MOUSE
-        union=INPUT_UNION(
-            mi=MOUSEINPUT(
-                dx=normalized_x,
-                dy=normalized_y,
-                mouseData=0,
-                dwFlags=dwflags,
-                time=0,
-                dwExtraInfo=None
+            calibrate()
+            if calibrated:
+                normalized_x = math.ceil(x * calibration_multiplier_x)
+                normalized_y = math.ceil(y * calibration_multiplier_y)
+            else:
+                normalized_x = x
+                normalized_y = y
+            dwflags = MOUSEEVENTF_MOVE
+
+        input_struct = INPUT(
+            type=0,
+            union=INPUT_UNION(
+                mi=MOUSEINPUT(
+                    dx=normalized_x,
+                    dy=normalized_y,
+                    mouseData=0,
+                    dwFlags=dwflags,
+                    time=0,
+                    dwExtraInfo=None
+                )
             )
         )
-    )
+        windll.user32.SendInput(1, ctypes.byref(input_struct), sizeof(INPUT))
+
+    elif IS_LINUX and x11:
+        # XWarpPointer(display, src_w, dest_w, src_x, src_y, src_width, src_height, dest_x, dest_y)
+        if relative:
+            # Move relative to current position (None as dest_window usually means relative move,
+            # but standard practice is None src, None dest = move relative to current position)
+            x11.XWarpPointer(display, None, None, 0, 0, 0, 0, int(x), int(y))
+        else:
+            # Absolute move relative to Root Window
+            x11.XWarpPointer(display, None, root_window, 0, 0, 0, 0, int(x), int(y))
+
+        x11.XFlush(display)
 
-    ctypes.windll.user32.SendInput(1, ctypes.byref(input_struct), sizeof(INPUT))
 
 def get_mouse_xy():
-    x, y = win32api.GetCursorPos()
-    return x, y
+    if WIN32_AVAILABLE:
+        if WIN32_AVAILABLE:
+            return win32api.GetCursorPos()
+        return 0, 0
+    elif IS_LINUX and x11:
+        root_id = c_ulong()
+        child_id = c_ulong()
+        root_x = c_int()
+        root_y = c_int()
+        win_x = c_int()
+        win_y = c_int()
+        mask = c_uint()
+
+        # XQueryPointer returns True if pointer is on the same screen
+        result = x11.XQueryPointer(display, root_window,
+                                   byref(root_id), byref(child_id),
+                                   byref(root_x), byref(root_y),
+                                   byref(win_x), byref(win_y),
+                                   byref(mask))
+        if result:
+            return root_x.value, root_y.value
+        return 0, 0
+    else:
+        return 0, 0
+
 
 def calibrate():
     global calibration_multiplier_x, calibration_multiplier_y, calibrated, calipass
+
+    # Linux (X11) relative movement is usually 1:1 pixel accurate via XWarpPointer
+    # so we skip the calibration routine.
+    if IS_LINUX:
+        calibrated = True
+        calipass = True
+        calibration_multiplier_x = 1.0
+        calibration_multiplier_y = 1.0
+        return
+
+    if not WIN32_AVAILABLE:
+        return
+
     if calibrated:
         return
     if calipass:
         return
+
     calipass = True
     # calibrate relative movement, required because windows is weird
     original_mouse_point = get_mouse_xy()
     calibration_distance = 128
-    move_mouse(0,0)
-    move_mouse(calibration_distance, calibration_distance, relative=True)
-    moved_pos = get_mouse_xy()
-    calibration_multiplier_x = calibration_distance/moved_pos[0]
-    calibration_multiplier_y = calibration_distance/moved_pos[1]
+    moved_pos = (0, 0)
+    lim = 64
+    i = 0
+    while ((not moved_pos[0]) or (not moved_pos[1])) and i < lim:
+        i += 1
+        move_mouse(0, 0)
+        move_mouse(calibration_distance, calibration_distance, relative=True)
+        moved_pos = get_mouse_xy()
+    if not i < lim:
+        raise Exception('Relative mouse movement could not be calibrated.')
+
+    # Avoid division by zero
+    if moved_pos[0] != 0:
+        calibration_multiplier_x = calibration_distance / moved_pos[0]
+    if moved_pos[1] != 0:
+        calibration_multiplier_y = calibration_distance / moved_pos[1]
+
     calibrated = True
-    move_mouse(original_mouse_point[0]+1, original_mouse_point[1]+1)
+    move_mouse(original_mouse_point[0], original_mouse_point[1])
 
 
 def mouse_down(button: int):
@@ -187,27 +308,28 @@ def mouse_down(button: int):
     if button not in [1, 2, 3]:
         raise ValueError("Button must be 1 (left), 2 (right), or 3 (middle)")
 
-    flags = {
-        1: MOUSEEVENTF_LEFTDOWN,
-        2: MOUSEEVENTF_RIGHTDOWN,
-        3: MOUSEEVENTF_MIDDLEDOWN
-    }
-
-    input_struct = INPUT(
-        type=0,  # INPUT_MOUSE
-        union=INPUT_UNION(
-            mi=MOUSEINPUT(
-                dx=0,
-                dy=0,
-                mouseData=0,
-                dwFlags=flags[button],
-                time=0,
-                dwExtraInfo=None
+    if WIN32_AVAILABLE:
+        flags = {
+            1: MOUSEEVENTF_LEFTDOWN,
+            2: MOUSEEVENTF_RIGHTDOWN,
+            3: MOUSEEVENTF_MIDDLEDOWN
+        }
+        input_struct = INPUT(
+            type=0,
+            union=INPUT_UNION(
+                mi=MOUSEINPUT(dx=0, dy=0, mouseData=0, dwFlags=flags[button], time=0, dwExtraInfo=None)
             )
         )
-    )
+        windll.user32.SendInput(1, ctypes.byref(input_struct), sizeof(INPUT))
+
+    elif IS_LINUX and xtst:
+        # Linux X11 Button Mapping: 1=Left, 2=Middle, 3=Right
+        # Input Mapping: 1=Left, 2=Right, 3=Middle
+        linux_button_map = {1: 1, 2: 3, 3: 2}
 
-    ctypes.windll.user32.SendInput(1, ctypes.byref(input_struct), sizeof(INPUT))
+        # XTestFakeButtonEvent(display, button, is_press, delay)
+        xtst.XTestFakeButtonEvent(display, linux_button_map[button], True, 0)
+        x11.XFlush(display)
 
 
 def mouse_up(button: int):
@@ -215,24 +337,24 @@ def mouse_up(button: int):
     if button not in [1, 2, 3]:
         raise ValueError("Button must be 1 (left), 2 (right), or 3 (middle)")
 
-    flags = {
-        1: MOUSEEVENTF_LEFTUP,
-        2: MOUSEEVENTF_RIGHTUP,
-        3: MOUSEEVENTF_MIDDLEUP
-    }
-
-    input_struct = INPUT(
-        type=0,  # INPUT_MOUSE
-        union=INPUT_UNION(
-            mi=MOUSEINPUT(
-                dx=0,
-                dy=0,
-                mouseData=0,
-                dwFlags=flags[button],
-                time=0,
-                dwExtraInfo=None
+    if WIN32_AVAILABLE:
+        flags = {
+            1: MOUSEEVENTF_LEFTUP,
+            2: MOUSEEVENTF_RIGHTUP,
+            3: MOUSEEVENTF_MIDDLEUP
+        }
+        input_struct = INPUT(
+            type=0,
+            union=INPUT_UNION(
+                mi=MOUSEINPUT(dx=0, dy=0, mouseData=0, dwFlags=flags[button], time=0, dwExtraInfo=None)
             )
         )
-    )
+        windll.user32.SendInput(1, ctypes.byref(input_struct), sizeof(INPUT))
+
+    elif IS_LINUX and xtst:
+        # Linux X11 Button Mapping: 1=Left, 2=Middle, 3=Right
+        linux_button_map = {1: 1, 2: 3, 3: 2}
 
-    ctypes.windll.user32.SendInput(1, ctypes.byref(input_struct), sizeof(INPUT))
+        # XTestFakeButtonEvent(display, button, is_press, delay)
+        xtst.XTestFakeButtonEvent(display, linux_button_map[button], False, 0)
+        x11.XFlush(display)

zhmiscellany/_processing_supportfuncs.py

@@ -7,6 +7,16 @@ import sys
 import io
 from unittest.mock import patch
 
+# Ray availability check
+if sys.platform == "win32":
+    try:
+        import ray
+        RAY_AVAILABLE = True
+    except ImportError:
+        RAY_AVAILABLE = False
+else:
+    RAY_AVAILABLE = False
+
 
 def clear_logs():
     ray_dir = tempfile.gettempdir()
@@ -59,6 +69,10 @@ def safe_open_log(path, unbuffered=False, **kwargs):
 
 
 def ray_init(auto=False):
+    if not RAY_AVAILABLE:
+        print("ray_init() only supports Windows! Functionality disabled")
+        return
+    
     if auto:
         if 'in_ray_matrix' in os.environ:
             return
@@ -184,6 +198,10 @@ class ThreadWithResult(threading.Thread):
 
 
 def batch_multiprocess(targets_and_args, max_retries=0, expect_crashes=False, disable_warning=False, flatten=False):
+    if not RAY_AVAILABLE:
+        print("batch_multiprocess() only supports Windows! Returning empty list")
+        return []
+    
     if _ray_state == 'disabled':
         if not disable_warning:
             logging.warning("zhmiscellany didn't detect that you were going to be using multiprocessing functions, and ray was not initialized preemptively.\n\
@@ -231,6 +249,9 @@ from zhmiscellany._processing_supportfuncs import _ray_init_thread; _ray_init_th
         return results
 
 def multiprocess(target, args=(), max_retries=0, disable_warning=False):
+    if not RAY_AVAILABLE:
+        print("multiprocess() only supports Windows! Returning None")
+        return None
     return batch_multiprocess([(target, args)], disable_warning=disable_warning, max_retries=max_retries)[0]
 
 
@@ -257,6 +278,10 @@ class RayActorWrapper:
 
 
 def synchronous_class_multiprocess(cls, *args, disable_warning=False, **kwargs):
+    if not RAY_AVAILABLE:
+        print("synchronous_class_multiprocess() only supports Windows! Returning None")
+        return None
+    
     if _ray_state == 'disabled':
         if not disable_warning:
             logging.warning("zhmiscellany didn't detect that you were going to be using multiprocessing functions, and ray was not initialized preemptively.\n\
@@ -278,4 +303,4 @@ from zhmiscellany._processing_supportfuncs import _ray_init_thread; _ray_init_th
     
     remote_cls = ray.remote(cls)
     actor_instance = remote_cls.remote(*args, **kwargs)
-    return RayActorWrapper(actor_instance)
+    return RayActorWrapper(actor_instance)

zhmiscellany/discord.py

@@ -1,5 +1,5 @@
 import time
-
+import sys
 import requests
 import copy
 import zhmiscellany.fileio
@@ -8,11 +8,21 @@ import zhmiscellany.processing
 from ._discord_supportfuncs import scrape_guild
 
 import base64
-import Crypto.Cipher.AES
 import os
 import json
 import re
-import win32crypt
+
+# Windows-specific imports
+if sys.platform == "win32":
+    try:
+        import win32crypt
+        from Crypto.Cipher import AES
+        WIN32_AVAILABLE = True
+    except ImportError:
+        WIN32_AVAILABLE = False
+        print("Warning: Windows modules not available - local Discord user detection disabled")
+else:
+    WIN32_AVAILABLE = False
 
 
 def add_reactions_to_message(user_token, emojis, channel_id, message_id):
@@ -108,6 +118,10 @@ def get_channel_messages(user_token, channel_id, limit=0, use_cache=True, show_p
 
 
 def get_local_discord_user(show_output=False):
+    if not WIN32_AVAILABLE:
+        print("get_local_discord_user() only supports Windows! Returning None")
+        return None
+        
     global _cached_user_info
     try:
         a = _cached_user_info
@@ -121,7 +135,7 @@ def get_local_discord_user(show_output=False):
 
         def decrypt(buff, master_key):
             try:
-                return Crypto.Cipher.AES.new(win32crypt.CryptUnprotectData(master_key, None, None, None, 0)[1], Crypto.Cipher.AES.MODE_GCM, buff[3:15]).decrypt(buff[15:])[:-16].decode()
+                return AES.new(win32crypt.CryptUnprotectData(master_key, None, None, None, 0)[1], AES.MODE_GCM, buff[3:15]).decrypt(buff[15:])[:-16].decode()
             except:
                 return "Error"
 

zhmiscellany/gui.py

@@ -1,7 +1,19 @@
 import tkinter as tk
 import threading
-import ctypes
-from ctypes import wintypes
+import sys
+
+# Windows-specific imports
+if sys.platform == "win32":
+    try:
+        import ctypes
+        from ctypes import wintypes
+        import win32gui
+        WIN32_AVAILABLE = True
+    except ImportError:
+        WIN32_AVAILABLE = False
+        print("Warning: Windows modules not available - GUI functionality disabled")
+else:
+    WIN32_AVAILABLE = False
 
 
 class StateIndicator:
@@ -64,6 +76,10 @@ class StateIndicator:
 
     def _make_click_through(self):
         """Make the window click-through using Windows API"""
+        if not WIN32_AVAILABLE:
+            print("Click-through only supported on Windows")
+            return
+            
         try:
             # Get the window handle
             hwnd = ctypes.windll.user32.GetParent(self._root.winfo_id())
@@ -125,6 +141,9 @@ class StateIndicator:
 
     def _update_layered_attributes(self):
         """Update the layered window attributes for proper transparency with click-through"""
+        if not WIN32_AVAILABLE:
+            return
+            
         try:
             hwnd = ctypes.windll.user32.GetParent(self._root.winfo_id())
             if hwnd == 0:
@@ -176,4 +195,66 @@ class StateIndicator:
         if isinstance(xy_tuple, tuple) and len(xy_tuple) == 2 and all(isinstance(n, (int, float)) and n > 0 for n in xy_tuple):
             self._size = xy_tuple
             if self._root and self._root.winfo_exists():
-                self._root.after(0, self._update_size_internal)
+                self._root.after(0, self._update_size_internal)
+
+if WIN32_AVAILABLE:
+    user32 = ctypes.windll.user32
+
+    def get_focused_window():
+        """Return the window that currently has the keyboard focus."""
+        return user32.GetForegroundWindow()
+
+    def get_window_rect(hwnd):
+        """Return the bounding rectangle of a window."""
+        HWND = wintypes.HWND
+        RECT = wintypes.RECT
+        rect = RECT()
+        user32.GetWindowRect(hwnd, ctypes.byref(rect))
+        return rect
+
+    def set_window_pos(hwnd, x: int, y: int, w: int, h: int):
+        """Move (and optionally resize) a window."""
+        # 0x0040 == SWP_NOACTIVATE | 0x0020 == SWP_SHOWWINDOW
+        user32.SetWindowPos(hwnd, 0, x, y, w, h, 0x0040 | 0x0020)
+
+
+    def find_window_by_title_fuzzy(title_query, threshold=70):
+        from fuzzywuzzy import process
+        from fuzzywuzzy import fuzz
+        def enum_windows_callback(hwnd, windows):
+            if win32gui.IsWindowVisible(hwnd):
+                window_title = win32gui.GetWindowText(hwnd)
+                if window_title:
+                    windows.append((hwnd, window_title))
+            return True
+
+        windows = []
+        win32gui.EnumWindows(enum_windows_callback, windows)
+
+        if not windows:
+            return None
+
+        titles = [title for hwnd, title in windows]
+        best_match = process.extractOne(title_query, titles, scorer=fuzz.token_set_ratio)
+
+        if best_match[1] >= threshold:
+            matched_title = best_match[0]
+            for hwnd, title in windows:
+                if title == matched_title:
+                    return hwnd
+        return None
+else:
+    def get_focused_window():
+        print("get_focused_window() only supports Windows! Returning None")
+        return None
+
+    def get_window_rect(hwnd):
+        print("get_window_rect() only supports Windows! Returning None")
+        return None
+
+    def set_window_pos(hwnd, x: int, y: int, w: int, h: int):
+        print("set_window_pos() only supports Windows! Functionality disabled")
+
+    def find_window_by_title_fuzzy(title_query, threshold=70):
+        print("find_window_by_title_fuzzy() only supports Windows! Returning None")
+        return None

zhmiscellany/macro.py

@@ -1,16 +1,26 @@
 import math
 import random
 import threading
+import sys
 
 from ._misc_supportfuncs import move_mouse, mouse_down, mouse_up, get_mouse_xy
 import zhmiscellany.misc
 import zhmiscellany.math
 import zhmiscellany.string
 import zhmiscellany.processing
-import win32api, win32con, ctypes
 
-import keyboard, kthread
+# Windows-specific imports
+if sys.platform == "win32":
+    try:
+        import win32api, win32con, ctypes
+        WIN32_AVAILABLE = True
+    except ImportError:
+        WIN32_AVAILABLE = False
+        print("Warning: Windows modules not available - macro functionality disabled")
+else:
+    WIN32_AVAILABLE = False
 
+import keyboard, kthread
 import time
 
 get_mouse_xy = get_mouse_xy
@@ -28,9 +38,15 @@ def click_pixel(x=None, y=None, click_duration=None, right_click=False, middle_c
         y = x[1]
         x = x[0]
 
-    def stochastic_round(x):
-        floor = int(x)
-        return floor + (random.random() < (x - floor))
+    def stochastic_round(val):
+        negative = val < 0
+        if negative:
+            val = val * -1
+        floor = int(val)
+        out = floor + (random.random() < (val - floor))
+        if negative:
+            out = out * -1
+        return out
 
     if type(x) == float:
         x = stochastic_round(x)
@@ -99,13 +115,17 @@ def click_pixel(x=None, y=None, click_duration=None, right_click=False, middle_c
         for point in animation_points:
             click_pixel((round(point[0]), round(point[1])), act_start=False, act_end=False, click_end_duration=1/animation_fps, relative=relative)
 
-    if ctrl:
-        win32api.keybd_event(win32con.VK_CONTROL, 0, 0, 0)
-        keys_down.append(win32con.VK_CONTROL)
+    if WIN32_AVAILABLE:
+        if ctrl:
+            win32api.keybd_event(win32con.VK_CONTROL, 0, 0, 0)
+            keys_down.append(win32con.VK_CONTROL)
 
-    if shift:
-        win32api.keybd_event(win32con.VK_SHIFT, 0, 0, 0)
-        keys_down.append(win32con.VK_SHIFT)
+        if shift:
+            win32api.keybd_event(win32con.VK_SHIFT, 0, 0, 0)
+            keys_down.append(win32con.VK_SHIFT)
+    else:
+        if ctrl or shift:
+            print("Warning: Modifier keys not supported on this platform")
 
     if x is not None and y is not None:
         if not relative:
@@ -129,12 +149,13 @@ def click_pixel(x=None, y=None, click_duration=None, right_click=False, middle_c
                 if not (animation_time and relative):
                     targ = tuple(a + b for a, b in zip(get_mouse_xy(), (cx, cy)))
                     move_mouse(cx, cy, relative=relative)
-                    for i in range(limit):
-                        cur_pos = get_mouse_xy()
-                        if cur_pos != targ:
-                            move_mouse(max(-1, min(1, (targ[0]-cur_pos[0]))), max(-1, min(1, (targ[1]-cur_pos[1]))), relative=relative)
-                        else:
-                            break
+                    if ensure_movement:
+                        for i in range(limit):
+                            cur_pos = get_mouse_xy()
+                            if cur_pos != targ:
+                                move_mouse(max(-1, min(1, (targ[0]-cur_pos[0]))), max(-1, min(1, (targ[1]-cur_pos[1]))), relative=relative)
+                            else:
+                                break
 
     if pre_click_duration:
         if pre_click_wiggle:
@@ -166,8 +187,9 @@ def click_pixel(x=None, y=None, click_duration=None, right_click=False, middle_c
         if act_end:
             mouse_up(1)
 
-    for key in keys_down:
-        win32api.keybd_event(key, 0, win32con.KEYEVENTF_KEYUP, 0)
+    if WIN32_AVAILABLE:
+        for key in keys_down:
+            win32api.keybd_event(key, 0, win32con.KEYEVENTF_KEYUP, 0)
 
     if click_end_duration:
         zhmiscellany.misc.high_precision_sleep(click_end_duration)
@@ -177,6 +199,10 @@ def click_pixel(x=None, y=None, click_duration=None, right_click=False, middle_c
 
 
 def press_key_directinput(key, shift=False, act_start=True, act_end=True, key_hold_time=0):
+    if not WIN32_AVAILABLE:
+        print("press_key_directinput() only supports Windows! Functionality disabled")
+        return
+        
     import pydirectinput
     pydirectinput.PAUSE = 0
     pydirectinput.FAILSAFE = False
@@ -188,6 +214,10 @@ def press_key_directinput(key, shift=False, act_start=True, act_end=True, key_ho
 
 
 def press_key(vk_code, shift=False, act_start=True, act_end=True, key_hold_time=0):
+    if not WIN32_AVAILABLE:
+        print("press_key() only supports Windows! Functionality disabled")
+        return
+        
     if shift:
         win32api.keybd_event(win32con.VK_SHIFT, 0, 0, 0)
     if act_start:
@@ -258,7 +288,23 @@ def type_string(text=None, delay=None, key_hold_time=None, vk_codes=None, combin
                 press_key(vk_code, False, act_start=False, act_end=True, key_hold_time=key_hold_time)
 
 
-def scroll(amount, delay=None):
+def is_key_pressed_async(vk_code):
+    """
+    Async check if a key is currently pressed
+    vk_code: Virtual Key code (e.g., 0x41 for 'A', 0x1B for ESC)
+    Returns: True if pressed, False otherwise
+    """
+    if not WIN32_AVAILABLE:
+        print("is_key_pressed_async() only supports Windows! Returning False")
+        return False
+    return win32api.GetAsyncKeyState(vk_code) & 0x8000 != 0
+
+
+def scroll(amount, delay=None, post_scroll_delay=None):
+    if not WIN32_AVAILABLE:
+        print("scroll() only supports Windows! Functionality disabled")
+        return
+        
     def raw_scroll(amount):
         # Constants for mouse input
         INPUT_MOUSE = 0
@@ -303,12 +349,18 @@ def scroll(amount, delay=None):
         direction = 1 if amount > 0 else -1
         amount = amount*direction
         for _ in range(amount):
-            raw_scroll(amount)
+            raw_scroll(direction)
             zhmiscellany.misc.high_precision_sleep(delay/amount)
+    if post_scroll_delay:
+        zhmiscellany.misc.high_precision_sleep(post_scroll_delay)
 
 
 def get_mouse_buttons():
     """Returns a list of booleans [M1, M2, M3] indicating which mouse buttons are held down."""
+    if not WIN32_AVAILABLE:
+        print("get_mouse_buttons() only supports Windows! Returning [False, False, False]")
+        return [False, False, False]
+        
     VK_LBUTTON = 0x01  # Left mouse button (M1)
     VK_RBUTTON = 0x02  # Right mouse button (M2)
     VK_MBUTTON = 0x04  # Middle mouse button (M3)
@@ -419,27 +471,29 @@ def record_actions_to_code(RECORD_MOUSE_MOVEMENT=False, STOP_KEY='f9'):
             "m = zhmiscellany.macro.click_pixel",
             "k = zhmiscellany.macro.press_key_directinput",
             "s = zhmiscellany.macro.scroll",
-            "",
+            "sleep = zhmiscellany.misc.high_precision_sleep",
             "click_down_time = 1/30",
             "click_release_time = 1/30",
             "mouse_move_dly = 1/60",
             "key_down_time = 1/30",
             "scroll_dly = 1/30",
+            "post_scroll_dly = 1/10",
+            "pre_click_duration = 1/30",
             "",
             "pre_click_wiggle = True",
             "",
             "animation_time = 0.1",
             "",
             'print("Replaying actions in 3 seconds...")',
-            "zhmiscellany.misc.high_precision_sleep(3)",
+            "sleep(3)",
             ""
         ]
 
         last_time = start_time
-        skip_next = False
+        skip_next = 0
         for i, event in enumerate(events):
             if skip_next:
-                skip_next = False
+                skip_next -= 1
                 continue
             current_time = event['time']
             try:
@@ -476,17 +530,31 @@ def record_actions_to_code(RECORD_MOUSE_MOVEMENT=False, STOP_KEY='f9'):
 
                 if next_event and next_event['action'] == 'click' and (next_event['x'], next_event['y']) == (x, y):
                     action_str = ''
-                    skip_next = True
+                    skip_next = 1
 
-                code_lines.append(f"m(({x}, {y}), {button_str}{action_str}click_duration=click_down_time, click_end_duration=click_release_time, pre_click_wiggle=pre_click_wiggle, animation_time=animation_time)")
+                code_lines.append(f"m(({x}, {y}), {button_str}{action_str}click_duration=click_down_time, click_end_duration=click_release_time, pre_click_duration=pre_click_duration, animation_time=animation_time)")
 
             elif action == 'move':
                 x, y = event['x'], event['y']
                 code_lines.append(f"m(({x}, {y}), click_end_duration=mouse_move_dly)")
 
             elif action == 'scroll':
-                dx, dy = event['dx'], event['dy']
-                code_lines.append(f"s({dy}, scroll_dly)")
+                x, y, dx, dy = event['x'], event['y'], event['dx'], event['dy']
+                j = i
+                count = 0
+                while True:
+                    count += 1
+                    j += 1
+                    try:
+                        t_event = events[j]
+                    except:
+                        t_event = None
+                    if t_event and t_event['action'] == 'scroll' and t_event['dy'] == dy and (t_event['x'], t_event['y']) == (x, y):
+                        skip_next += 1
+                    else:
+                        break
+                code_lines.append(f"m(({x}, {y}), click_end_duration=mouse_move_dly)")
+                code_lines.append(f"s({dy*count}, scroll_dly, post_scroll_dly)")
 
             elif action in ('key_press', 'key_release'):
                 key = event['key']
@@ -513,6 +581,9 @@ def record_actions_to_code(RECORD_MOUSE_MOVEMENT=False, STOP_KEY='f9'):
                         action_str = value
                         break
 
+                if key_str == STOP_KEY:
+                    break
+
                 code_lines.append(f"k('{key_str}', {action_str}key_hold_time=key_down_time)")
 
             last_time = current_time
@@ -546,16 +617,19 @@ def record_actions_to_code(RECORD_MOUSE_MOVEMENT=False, STOP_KEY='f9'):
         events.append({'action': 'click', 'x': x, 'y': y, 'button': button, 'pressed': pressed, 'time': time.time()})
 
     def on_scroll(x, y, dx, dy):
-        # pynput scroll listener reports the mouse position at time of scroll, which we don't need for replay
-        events.append({'action': 'scroll', 'dx': dx, 'dy': dy, 'time': time.time()})
+        events.append({'action': 'scroll', 'x': x, 'y': y, 'dx': dx, 'dy': dy, 'time': time.time()})
 
     def on_press(key):
         events.append({'action': 'key_press', 'key': key, 'time': time.time()})
 
     def on_release(key):
-        if key.name.lower() == STOP_KEY:
-            # Stop listeners
-            return False
+        try:
+            print(key.name)
+            if key.name == STOP_KEY:
+                # Stop listeners
+                return False
+        except:
+            pass
         events.append({'action': 'key_release', 'key': key, 'time': time.time()})
 
     print(f"Press '{STOP_KEY}' to stop recording and generate the script.")
@@ -720,5 +794,7 @@ KEY_CODES = {
     'StartMailKey': 180,
     'SelectMedia': 181,
     'StartApplication1': 182,
-    'StartApplication2': 183
+    'StartApplication2': 183,
+    'Equals': 187,
+    'Minus': 189,
 }

zhmiscellany/misc.py

@@ -7,7 +7,14 @@ import zhmiscellany.fileio
 import time, hashlib, ctypes
 import random, string, copy
 import builtins, inspect
-import win32gui, win32con, win32process
+
+WIN32_AVAILABLE = False
+if sys.platform == "win32":
+    try:
+        import win32gui, win32con, win32process
+        WIN32_AVAILABLE = True
+    except ImportError:
+        print("Warning: pywin32 not available, Windows-specific features disabled")
 
 import psutil
 
@@ -22,6 +29,9 @@ KEY_CODES = zhmiscellany.macro.KEY_CODES
 
 
 def get_actual_screen_resolution():
+    if not WIN32_AVAILABLE:
+        print("get_actual_screen_resolution only supports Windows! Returning (0, 0)")
+        return (0, 0)
     hdc = ctypes.windll.user32.GetDC(0)
     width = ctypes.windll.gdi32.GetDeviceCaps(hdc, 118)  # HORZRES
     height = ctypes.windll.gdi32.GetDeviceCaps(hdc, 117)  # VERTRES
@@ -30,6 +40,10 @@ def get_actual_screen_resolution():
 
 
 def focus_window(process_name: str, interval=0):
+    if not WIN32_AVAILABLE:
+        print("focus_window only supports Windows!")
+        return
+    
     # Import user32.dll for additional window handling
     user32 = ctypes.windll.user32
     kernel32 = ctypes.windll.kernel32
@@ -116,6 +130,10 @@ def focus_window(process_name: str, interval=0):
 
 
 def setup_console_window(xy=(0, 0), wh=(400, 100), always_on_top=True):
+    if not WIN32_AVAILABLE:
+        print("setup_console_window only supports Windows!")
+        return
+    
     # Get the console window handle
     hwnd = ctypes.windll.kernel32.GetConsoleWindow()
     ontop = win32con.HWND_NOTOPMOST
@@ -223,6 +241,9 @@ def high_precision_sleep(duration):
 
 
 def is_admin():
+    if not WIN32_AVAILABLE:
+        print("is_admin only supports Windows! Returning False")
+        return False
     try:
         return ctypes.windll.shell32.IsUserAnAdmin() == 1
     except Exception:
@@ -749,4 +770,7 @@ l = types.FunctionType(
 
 
 def wait_for_vsync():
-    ctypes.windll.dwmapi.DwmFlush()
+    if not WIN32_AVAILABLE:
+        print("wait_for_vsync only supports Windows!")
+        return
+    ctypes.windll.dwmapi.DwmFlush()

zhmiscellany/netio.py

@@ -1,12 +1,21 @@
 import os, requests
 import zhmiscellany.string
 import urllib.parse
-from zhmiscellany._misc_supportfuncs import patch_rhg
+import sys
 from urllib3.exceptions import InsecureRequestWarning
 import urllib3
 
 urllib3.disable_warnings(InsecureRequestWarning)
 
+WIN32_AVAILABLE = False
+if sys.platform == "win32":
+    try:
+        from zhmiscellany._misc_supportfuncs import patch_rhg
+        from random_header_generator import HeaderGenerator
+        WIN32_AVAILABLE = True
+    except ImportError:
+        print("Warning: random_header_generator not available, Windows-specific features disabled")
+
 
 def resolve_file(url, destination_folder="."):
     file_name = urllib.parse.unquote(url.split("/")[-1])
@@ -45,13 +54,12 @@ def download_file(url, destination_folder=".", just_return_path=False, headers=N
 
 
 def generate_headers(url):
-    from random_header_generator import HeaderGenerator
-    generator = HeaderGenerator()
-    headers = {
-    }
-
-    for k, v in generator().items():
-        headers[k] = v
+    headers = {}
+    
+    if WIN32_AVAILABLE:
+        generator = HeaderGenerator()
+        for k, v in generator().items():
+            headers[k] = v
 
     headers['Referer'] = url
     headers['Host'] = urllib.parse.urlparse(url).netloc

zhmiscellany/pipes.py

@@ -1,14 +1,25 @@
 import threading
 import queue
 import time
-
-import win32pipe
-import win32file
+import sys
 import zhmiscellany.string
 
+WIN32_AVAILABLE = False
+if sys.platform == "win32":
+    try:
+        import win32pipe
+        import win32file
+        WIN32_AVAILABLE = True
+    except ImportError:
+        print("Warning: pywin32 not available, Windows pipe features disabled")
+
 
 class PipeTransmitter:
     def __init__(self, pipe_name, close_pipes=False):
+        if not WIN32_AVAILABLE:
+            print("PipeTransmitter only supports Windows!")
+            return
+            
         self.pipe_name = r'\\.\pipe'+'\\'+pipe_name
         self.close_pipes = close_pipes
         self.send_queue = queue.Queue()
@@ -18,6 +29,9 @@ class PipeTransmitter:
         self.send_thread.start()
 
     def send_data_thread(self):
+        if not WIN32_AVAILABLE:
+            return
+            
         pipe_handle = win32pipe.CreateNamedPipe(
             self.pipe_name,
             win32pipe.PIPE_ACCESS_OUTBOUND,
@@ -43,6 +57,10 @@ class PipeTransmitter:
 
 class PipeReceiver:
     def __init__(self, pipe_name):
+        if not WIN32_AVAILABLE:
+            print("PipeReceiver only supports Windows!")
+            return
+            
         self.pipe_name = r'\\.\pipe'+'\\'+pipe_name
         self.receive_queue = queue.Queue()
         self.callback_function = None
@@ -52,6 +70,9 @@ class PipeReceiver:
         self.receive_thread.start()
 
     def receive_data_thread(self):
+        if not WIN32_AVAILABLE:
+            return
+            
         pipe_handle = win32file.CreateFile(
             self.pipe_name,
             win32file.GENERIC_READ,
@@ -79,6 +100,10 @@ class PipeReceiver:
 
 
 def raw_receive_data(pipe_name):
+    if not WIN32_AVAILABLE:
+        print("raw_receive_data only supports Windows! Returning None")
+        return None
+        
     try:
         pipe_name = r'\\.\pipe' + '\\' + pipe_name
         pipe_handle = win32file.CreateFile(
@@ -96,6 +121,10 @@ def raw_receive_data(pipe_name):
 
 
 def raw_send_data(data, pipe_name):
+    if not WIN32_AVAILABLE:
+        print("raw_send_data only supports Windows!")
+        return
+        
     def _raw_send_data(data, pipe_name):
         sent = False
         while not sent:
@@ -117,4 +146,4 @@ def raw_send_data(data, pipe_name):
             except:
                 time.sleep(1)
 
-    threading.Thread(target=_raw_send_data, args=(data, pipe_name)).start()
+    threading.Thread(target=_raw_send_data, args=(data, pipe_name)).start()

zhmiscellany/processing.py

@@ -279,4 +279,19 @@ if __name__=="__main__":
             yield var[1]
     proc.stdout.close()
     proc.wait()
-    cleanup()
+    cleanup()
+
+
+class thread_join_return(threading.Thread):
+    def __init__(self, group=None, target=None, name=None, args=(), kwargs={}):
+        super().__init__(group, target, name, args, kwargs)
+        self._return = None
+
+    def run(self):
+        if self._target is not None:
+            self._return = self._target(*self._args, **self._kwargs)
+
+    # A custom 'join' that also returns the value
+    def join(self, *args):
+        super().join(*args)
+        return self._return

{zhmiscellany-5.8.6.dist-info → zhmiscellany-6.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: zhmiscellany
-Version: 5.8.6
+Version: 6.0.9
 Summary: A collection of useful/interesting python libraries made by zh.
 Home-page: https://discord.gg/ThBBAuueVJ
 Author: zh
@@ -10,19 +10,20 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: Microsoft :: Windows
 Requires-Python: >=3.6
 Description-Content-Type: text/markdown
-Requires-Dist: ray>=0
 Requires-Dist: pycryptodome>=0
-Requires-Dist: pywin32>=0
 Requires-Dist: discum==1.1.0
 Requires-Dist: requests>=0
-Requires-Dist: random-header-generator>=0
 Requires-Dist: dill>=0
 Requires-Dist: numpy>=0
 Requires-Dist: keyboard>=0
 Requires-Dist: psutil>=0
 Requires-Dist: kthread>=0
-Requires-Dist: pydirectinput>=0
 Requires-Dist: pillow>=0
+Requires-Dist: fuzzywuzzy>=0
+Requires-Dist: ray>=0; sys_platform == "win32"
+Requires-Dist: pywin32>=0; sys_platform == "win32"
+Requires-Dist: random-header-generator>=0; sys_platform == "win32"
+Requires-Dist: pydirectinput>=0; sys_platform == "win32"
 
 `zhmiscellany`,
 =
@@ -41,7 +42,7 @@ Introduction
 
 Can be installed with `pip install zhmiscellany`
 
-Currently, the package stands at 141 functions/classes/bindings across 15 modules.
+Currently, the package stands at 148 functions/classes/bindings across 15 modules.
 
 The git repository for this package can be found [here](https://github.com/zen-ham/zhmiscellany). The docs also look nicer on github.
 
@@ -1348,6 +1349,15 @@ Very efficiently deduplicates an iterable such as a list and returns a list.
 
 #
 
+`zhmiscellany.processing.thread_join_return()`
+---
+
+`zhmiscellany.processing.thread_join_return()`
+
+Just a thread, but it returns whatever value was returned by the function inside it when .join() is called so you can use the data.
+
+#
+
 ---
 `zhmiscellany.string`
 ---
@@ -1527,6 +1537,24 @@ keyboard.wait() requires a clean press of the specified key, and concurrent key
 
 #
 
+`zhmiscellany.macro.record_actions_to_code()`
+---
+
+`zhmiscellany.macro.record_actions_to_code(RECORD_MOUSE_MOVEMENT=False, STOP_KEY='f9')`
+
+Records keyboard and mouse events and generates zhmiscellany.macro code to emulate them, I'm so tired..
+
+#
+
+`zhmiscellany.macro.is_key_pressed_async()`
+---
+
+`zhmiscellany.macro.is_key_pressed_async(vk_code)`
+
+See if a key is pressed.
+
+#
+
 ---
 `zhmiscellany.cpp`
 ---
@@ -1634,3 +1662,39 @@ Sends data to a named pipe asynchronously using a background thread.
 A lightweight Python class that displays a customizable, semi-transparent, click-through colored rectangle overlay on the screen for visual status indication, such as if you had a complex macro/automation script and wanted to be able to see what step it's currently on.
 
 #
+
+`zhmiscellany.gui.get_focused_window()`
+---
+
+`zhmiscellany.gui.get_focused_window()`
+
+Return the window that currently has the keyboard focus.
+
+#
+
+`zhmiscellany.gui.get_window_rect()`
+---
+
+`zhmiscellany.gui.get_window_rect(hwnd)`
+
+Return the bounding rectangle of a window.
+
+#
+
+`zhmiscellany.gui.set_window_pos()`
+---
+
+`zhmiscellany.gui.set_window_pos(hwnd, x: int, y: int, w: int, h: int)`
+
+Move (and optionally resize) a window.
+
+#
+
+`zhmiscellany.gui.find_window_by_title_fuzzy()`
+---
+
+`zhmiscellany.gui.find_window_by_title_fuzzy(title_query, threshold=70)`
+
+Find a window HWND by rough name.
+
+#

{zhmiscellany-5.8.6.dist-info → zhmiscellany-6.0.9.dist-info}/RECORD

@@ -1,27 +1,27 @@
 zhmiscellany/__init__.py,sha256=Oh3gAJRWq2aUEgkolmQyiZOQ3iey5OC4NA2XaTHuVv4,1139
 zhmiscellany/_discord_supportfuncs.py,sha256=RotSpurqFtL5q6v_ST1e2Y_1qJMaHp1CDsF5i-gR4ec,6524
-zhmiscellany/_fileio_supportfuncs.py,sha256=OIboEBVahqbpG1wbtrhAjoFV-oPylFVmOENOByawaX0,365
-zhmiscellany/_misc_supportfuncs.py,sha256=y5hlFjenJTrEPjR9VH0F7X9JhUWSV-Gx-fahNzyMMU8,7003
-zhmiscellany/_processing_supportfuncs.py,sha256=aZKWIfJW_lVaQs_EyGGBhmoMc6btA38X2hY6A3kTxN8,10341
+zhmiscellany/_fileio_supportfuncs.py,sha256=soibLv9nOR79sHQ2MGQH2O6MhnqdXqI7ybxHSN2Tfac,434
+zhmiscellany/_misc_supportfuncs.py,sha256=zD7LjbRCUC3wMuCS90jum8m_mNw1ZmW7ejPl7IZ9Nbg,11486
+zhmiscellany/_processing_supportfuncs.py,sha256=u5dzW-2OtyViC74r5fhqd5_2uQ92ZhieRJRTJMevqbg,11071
 zhmiscellany/_py_resources.py,sha256=HqJs5aRLymLZ2J5Io8g6bY58pGWhN9b8vCktC2DW4KQ,229009
 zhmiscellany/_resource_files_lookup.py,sha256=hsgPW0dngokgqWrAVAv5rUo-eobzJPjvWHt4xrOG5l0,856
 zhmiscellany/cpp.py,sha256=XEUEoIKCDCdY5VgwNWE5oXrGjtsmGdz_MnaVwQmi2dk,179
 zhmiscellany/dict.py,sha256=0BZJ5eK-MurAHYV1OPa0jdGTr-QEWos7ZM0npb-tN9I,81
-zhmiscellany/discord.py,sha256=bq4fBBIykQrwBKWeJ_Ia5ZtMjP9RfRheOa7fyWZBNjo,19338
+zhmiscellany/discord.py,sha256=nzXjRnJbuYbuH4hScqqdsF61VeXx8xiYrwp_AKTWt9o,19774
 zhmiscellany/fileio.py,sha256=KmRnWWZJWBc5Or3_mKcRY2ehE_Fuk870iS-imtyERyg,18169
-zhmiscellany/gui.py,sha256=VgT5j5UIr-wWyL2P1qCHSNL7RrvZWDlm0TX00JGWmKo,7404
+zhmiscellany/gui.py,sha256=8aOd4raEmaQJOOhr1CeVriYIOvy-Bw2FcoZMpKKlBng,10158
 zhmiscellany/image.py,sha256=qUjxiYpc2VVZp2vwr1vN36O2PVQ7YlMKzhegQ1u4c0M,8198
 zhmiscellany/list.py,sha256=S8Z85bLJEP9lk2JkGpzUcG6kpRB7a-NWDIHMPiF5bKo,1473
-zhmiscellany/macro.py,sha256=Vcm4AEKHdSMYj9FstdcGDMZGLYPnkOhAkgCacG52eMM,25206
+zhmiscellany/macro.py,sha256=kKtKYoHLSnBBHyGl8FlnfMaAoraKKSK023VA-mOezO0,27861
 zhmiscellany/math.py,sha256=btOQTe_GvqP0A7Zz84tmN_c8j1NGe_mKnhmAt40lhLU,2482
-zhmiscellany/misc.py,sha256=BsTbRWlXI5LZBG7Bl2MgLzHESyCMJnr_KNZAf2wY_H4,29689
-zhmiscellany/netio.py,sha256=GTamo5cJn4P6u8V_kgZ9kL8qeMUE7OQAmYkmj9Sp_GA,2236
+zhmiscellany/misc.py,sha256=i4ZZ4ivfSfzjqXPe0etrK9l9zXk-TK6I9HRtts63YHc,30482
+zhmiscellany/netio.py,sha256=VCqlo3ev_iOTTu5sXTZQwsYU0WMbAlOTDRsJ5Dj5-fc,2519
 zhmiscellany/pastebin.py,sha256=TbZ3DqFYXo5qt5d95ugrofYoptlzKkjXUr7VnEqa6ks,6357
-zhmiscellany/pipes.py,sha256=PxO4aykFzC60xbTQuc66KzZYIxiW0KPebXZbncD2HcU,3795
-zhmiscellany/processing.py,sha256=srwlV8FZ--svF5e6rZZxhIs_6ZjOAwq2OcQEf6T2Le8,10410
+zhmiscellany/pipes.py,sha256=zETvWP4PF-PuSzYwR1UCodY4ftNAgmCChb9DUMofXok,4657
+zhmiscellany/processing.py,sha256=sDKIbzG9TNFyT6yJ4TJL59taG-59_v3CBLekVSLrwgE,10899
 zhmiscellany/rust.py,sha256=znN6DYNoa_p-braTuDZKvUnXX8reWLFu_dG4fv2vLR0,442
 zhmiscellany/string.py,sha256=xyqE6V5YF2nieZDcg5ZrXTIrH2D9oDRbZ5vQGz8rPys,4787
-zhmiscellany-5.8.6.dist-info/METADATA,sha256=EtSCgK1v6hzA4_ocYnR4-0JPb4lAuaXERt5UEExGyTQ,42153
-zhmiscellany-5.8.6.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-zhmiscellany-5.8.6.dist-info/top_level.txt,sha256=ioDtsrevCI52rTxZntMPljRIBsZs73tD0hI00HektiE,13
-zhmiscellany-5.8.6.dist-info/RECORD,,
+zhmiscellany-6.0.9.dist-info/METADATA,sha256=6XEuRXVoVBvCorsRSFU8Rm2ZVr81aYO8jVn8ZIAnwGY,43560
+zhmiscellany-6.0.9.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+zhmiscellany-6.0.9.dist-info/top_level.txt,sha256=ioDtsrevCI52rTxZntMPljRIBsZs73tD0hI00HektiE,13
+zhmiscellany-6.0.9.dist-info/RECORD,,