zhmiscellany 5.7.9__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