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

zhmiscellany/macro.py

@@ -1,22 +1,32 @@
 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
 
 
-def click_pixel(x=None, y=None, click_duration=None, right_click=False, middle_click=False, shift=False, ctrl=False, act_start=True, act_end=True, click_end_duration=None, double_click=False, animation_time=None, animation_fps=60, animation_easing=True, relative=False, ensure_movement=True, pre_click_duration=None, pre_click_wiggle=False, click=True):
+def click_pixel(x=None, y=None, click_duration=None, right_click=False, middle_click=False, shift=False, ctrl=False, act_start=True, act_end=True, click_end_duration=None, double_click=False, animation_time=None, animation_fps=60, animation_easing=True, relative=False, ensure_movement=True, pre_click_duration=None, pre_click_wiggle=True, click=True):
     if not click:
         act_start=False;act_end=False
     if right_click and middle_click:
@@ -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)
@@ -356,6 +408,252 @@ def toggle_function(func, key='f8', blocking=True):
         return t
 
 
+def record_actions_to_code(RECORD_MOUSE_MOVEMENT=False, STOP_KEY='f9'):
+    import time
+    import pynput
+    import pyperclip
+
+    # --- Configuration ---
+    # Set to True to record every single mouse movement.
+    # Set to False to only record mouse position on clicks and drags.
+
+    # --- Global State ---
+    events = []
+    start_time = None
+
+    # --- Helper Functions ---
+    def format_key(key):
+        """
+        Formats the pynput key object into a string for the generated script.
+        Handles cases where modifier keys (like Ctrl) are held down, which can
+        prevent the `key.char` attribute from being populated correctly.
+        """
+        if isinstance(key, pynput.keyboard.Key):
+            # Special keys (e.g., Key.shift, Key.ctrl)
+            return f"Key.{key.name}"
+
+        if isinstance(key, pynput.keyboard.KeyCode):
+            # This is the robust way to handle alphanumeric keys, especially with modifiers.
+            # key.char can be None or a control character when Ctrl/Alt are held.
+            # key.vk is the virtual key code, which is more reliable.
+
+            # Heuristic for A-Z keys (VK codes on Windows/Linux are often in this range)
+            if 65 <= getattr(key, 'vk', 0) <= 90:
+                return f"'{chr(key.vk).lower()}'"
+
+            # For other keys, try to use the char if it exists
+            if key.char:
+                bs = '\\'
+                return f"'{key.char.replace(bs, bs + bs + bs)}'"
+
+            # As a fallback for other keys without a char, use the vk
+            if hasattr(key, 'vk'):
+                return f"pynput.keyboard.KeyCode.from_vk({key.vk})"
+
+        # If it's some other type of key object (less common)
+        return str(key)
+
+    def generate_code(events, start_time):
+        """
+        Generates the Python script from the recorded events and copies it to the clipboard.
+        """
+
+        if not events:
+            print("No actions were recorded.")
+            return
+
+        # Code preamble
+        code_lines = [
+            "import zhmiscellany",
+            "",
+            "zhmiscellany.misc.die_on_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...")',
+            "sleep(3)",
+            ""
+        ]
+
+        last_time = start_time
+        skip_next = 0
+        for i, event in enumerate(events):
+            if skip_next:
+                skip_next -= 1
+                continue
+            current_time = event['time']
+            try:
+                next_event = events[i+1]
+            except:
+                next_event = None
+            delay = current_time - last_time
+
+            action = event['action']
+
+            if action == 'click':
+                x, y, button, pressed = event['x'], event['y'], event['button'], event['pressed']
+                button_str = f"Button.{button.name}"
+                action_str = "press" if pressed else "release"
+
+                replacements = {
+                    'right': 'right_click=True, ',
+                    'middle': 'middle_click=True, ',
+                    'left': '',
+                }
+                for key, value in replacements.items():
+                    if key in button_str:
+                        button_str = value
+                        break
+
+                replacements = {
+                    'press': 'act_end=False, ',
+                    'release': 'act_start=False, ',
+                }
+                for key, value in replacements.items():
+                    if key in action_str:
+                        action_str = value
+                        break
+
+                if next_event and next_event['action'] == 'click' and (next_event['x'], next_event['y']) == (x, y):
+                    action_str = ''
+                    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_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':
+                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']
+                key_str = format_key(key)
+                if '.' in key_str:
+                    key_str = key_str.split('.')[1]
+                replacements = {
+                    'ctrl': 'ctrl',
+                    'shift': 'shift',
+                    'alt': 'alt',
+                }
+                for key, value in replacements.items():
+                    if key in key_str:
+                        key_str = value
+                        break
+                action_str = "press" if action == 'key_press' else "release"
+
+                replacements = {
+                    'press': 'act_end=False, ',
+                    'release': 'act_start=False, ',
+                }
+                for key, value in replacements.items():
+                    if key in action_str:
+                        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
+
+        code_lines.append("\nprint('Replay finished.')")
+
+        # Join all lines into a single script
+        final_script = "\n".join(code_lines)
+
+        # Print and copy to clipboard
+        print("\n" + "=" * 50)
+        print("      RECORDING FINISHED - SCRIPT GENERATED")
+        print("=" * 50 + "\n")
+        print(final_script)
+        print("\n" + "=" * 50)
+
+        try:
+            pyperclip.copy(final_script)
+            print("Script has been copied to your clipboard!")
+        except pyperclip.PyperclipException:
+            print("Could not copy to clipboard. Please install xclip or xsel on Linux.")
+        return final_script
+
+    # --- Pynput Listener Callbacks ---
+
+    def on_move(x, y):
+        if RECORD_MOUSE_MOVEMENT:
+            events.append({'action': 'move', 'x': x, 'y': y, 'time': time.time()})
+
+    def on_click(x, y, button, pressed):
+        events.append({'action': 'click', 'x': x, 'y': y, 'button': button, 'pressed': pressed, 'time': time.time()})
+
+    def on_scroll(x, y, dx, dy):
+        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):
+        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.")
+    print("...")
+
+    start_time = time.time()
+
+    # Create and start listeners
+    mouse_listener = pynput.mouse.Listener(on_move=on_move, on_click=on_click, on_scroll=on_scroll)
+    keyboard_listener = pynput.keyboard.Listener(on_press=on_press, on_release=on_release)
+
+    mouse_listener.start()
+    keyboard_listener.start()
+
+    # Wait for the keyboard listener to stop (on F9 press)
+    keyboard_listener.join()
+
+    # Stop the mouse listener explicitly once the keyboard one has finished
+    mouse_listener.stop()
+
+    # Generate the replay script
+    return generate_code(events, start_time)
+
+
 KEY_CODES = {
     'None': 0,
     'LeftMouseButton': 1,
@@ -496,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