zhmiscellany 6.2.3__py3-none-any.whl → 6.2.5__py3-none-any.whl

zhmiscellany/gui.py

@@ -1,16 +1,7 @@
-import threading
 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")
+    WIN32_AVAILABLE = True
 else:
     WIN32_AVAILABLE = False
 
@@ -26,6 +17,7 @@ class StateIndicator:
 
     def __init__(self, colour=(255, 0, 0), opacity=0.8, corner='topright', offset=(10, 10), size=_DEFAULT_SIZE):
         import tkinter as tk
+        import threading
         self.tk = tk
         self._colour = colour
         self._opacity = opacity
@@ -80,6 +72,9 @@ class StateIndicator:
         if not WIN32_AVAILABLE:
             print("Click-through only supported on Windows")
             return
+        else:
+            import ctypes
+            from ctypes import wintypes
             
         try:
             # Get the window handle
@@ -144,6 +139,9 @@ class StateIndicator:
         """Update the layered window attributes for proper transparency with click-through"""
         if not WIN32_AVAILABLE:
             return
+        else:
+            import ctypes
+            from ctypes import wintypes
             
         try:
             hwnd = ctypes.windll.user32.GetParent(self._root.winfo_id())
@@ -199,29 +197,38 @@ class StateIndicator:
                 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."""
+        import ctypes
+        from ctypes import wintypes
+        user32 = ctypes.windll.user32
         return user32.GetForegroundWindow()
 
     def get_window_rect(hwnd):
         """Return the bounding rectangle of a window."""
+        import ctypes
+        from ctypes import wintypes
         HWND = wintypes.HWND
         RECT = wintypes.RECT
         rect = RECT()
+        user32 = ctypes.windll.user32
         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
+        import ctypes
+        user32 = ctypes.windll.user32
         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
+        import ctypes
+        from ctypes import wintypes
+        import win32gui
         def enum_windows_callback(hwnd, windows):
             if win32gui.IsWindowVisible(hwnd):
                 window_title = win32gui.GetWindowText(hwnd)

zhmiscellany/image.py

@@ -1,9 +1,5 @@
-import numpy as np
-from PIL import Image, ImageDraw, ImageFont
-import math
-
-
 def image_diff(img1, img2):
+    import numpy as np
     img1 = img1.resize((100, 100))
     img2 = img2.resize((100, 100))
 
@@ -19,6 +15,8 @@ def image_diff(img1, img2):
 
 class Canvas:
     def __init__(self, width, height, colour=(0, 0, 0, 255)):
+        from PIL import Image, ImageDraw, ImageFont
+        self.ImageFont = ImageFont
         self.width = width
         self.height = height
         self.image = Image.new("RGBA", (self.width, self.height), color=colour)
@@ -62,6 +60,7 @@ class Canvas:
 
     def annotate(self, pixel_xy, text, text_scale=1.0, line_thickness=1,
                  text_colour=None, line_colour=None, auto_contrast=False, background_colour=None):
+        import math
         x, y = pixel_xy
         if not (0 <= x < self.width and 0 <= y < self.height):
             return
@@ -83,11 +82,11 @@ class Canvas:
                 line_colour = default_color
 
         try:
-            font = ImageFont.truetype("consola.ttf", int(12 * text_scale))
+            font = self.ImageFont.truetype("consola.ttf", int(12 * text_scale))
         except IOError:
-            font = ImageFont.load_default()
+            font = self.ImageFont.load_default()
             if hasattr(font, "size"):
-                font = ImageFont.load_default().font_variant(size=int(12 * text_scale))
+                font = self.ImageFont.load_default().font_variant(size=int(12 * text_scale))
         text_bbox = self.draw.textbbox((0, 0), text, font=font)
         text_width = text_bbox[2] - text_bbox[0]
         text_height = text_bbox[3] - text_bbox[1]

zhmiscellany/list.py

@@ -1,5 +1,3 @@
-from itertools import chain
-
 def remove_duplicates(l_list):
     return list(dict.fromkeys(l_list))
 
@@ -52,6 +50,7 @@ def split_into_sublists(lst, n):
 
 
 def flatten(an_iterable):
+    from itertools import chain
     return list(chain.from_iterable(an_iterable))
 
 

zhmiscellany/macro.py

@@ -1,32 +1,19 @@
-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
-
-# 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
+IS_WINDOWS = sys.platform == "win32"
 
+_last_press_time_map = {}  # Stores the last press timestamp for each key
 
 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):
+    import random
+    import math
+    from ._misc_supportfuncs import move_mouse, mouse_down, mouse_up, get_mouse_xy
+    import zhmiscellany.math
+    if IS_WINDOWS:
+        import win32api
+        import win32con
+        import ctypes
+    
     if not click:
         act_start=False;act_end=False
     if right_click and middle_click:
@@ -115,7 +102,7 @@ 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 WIN32_AVAILABLE:
+    if IS_WINDOWS:
         if ctrl:
             win32api.keybd_event(win32con.VK_CONTROL, 0, 0, 0)
             keys_down.append(win32con.VK_CONTROL)
@@ -187,7 +174,7 @@ def click_pixel(x=None, y=None, click_duration=None, right_click=False, middle_c
         if act_end:
             mouse_up(1)
 
-    if WIN32_AVAILABLE:
+    if IS_WINDOWS:
         for key in keys_down:
             win32api.keybd_event(key, 0, win32con.KEYEVENTF_KEYUP, 0)
 
@@ -197,13 +184,13 @@ def click_pixel(x=None, y=None, click_duration=None, right_click=False, middle_c
     if double_click:
         click_pixel(x, y, click_duration, right_click, shift, ctrl, act_start, act_end, middle_click, click_end_duration, pre_click_duration=pre_click_duration, pre_click_wiggle=pre_click_wiggle)
 
-
 def press_key_directinput(key, shift=False, act_start=True, act_end=True, key_hold_time=0):
-    if not WIN32_AVAILABLE:
+    if not IS_WINDOWS:
         print("press_key_directinput() only supports Windows! Functionality disabled")
         return
         
     import pydirectinput
+    import zhmiscellany.misc
     pydirectinput.PAUSE = 0
     pydirectinput.FAILSAFE = False
     if shift: pydirectinput.keyDown('shift')
@@ -212,12 +199,15 @@ def press_key_directinput(key, shift=False, act_start=True, act_end=True, key_ho
     if act_end: pydirectinput.keyUp(key)
     if shift: pydirectinput.keyUp('shift')
 
-
 def press_key(vk_code, shift=False, act_start=True, act_end=True, key_hold_time=0):
-    if not WIN32_AVAILABLE:
+    if not IS_WINDOWS:
         print("press_key() only supports Windows! Functionality disabled")
         return
         
+    import win32api
+    import win32con
+    import zhmiscellany.misc
+    
     if shift:
         win32api.keybd_event(win32con.VK_SHIFT, 0, 0, 0)
     if act_start:
@@ -229,8 +219,8 @@ def press_key(vk_code, shift=False, act_start=True, act_end=True, key_hold_time=
     if shift:
         win32api.keybd_event(win32con.VK_SHIFT, 0, win32con.KEYEVENTF_KEYUP, 0)
 
-
 def type_string(text=None, delay=None, key_hold_time=None, vk_codes=None, combine=False):
+    import zhmiscellany.misc
     # Dictionary mapping characters to their virtual key codes and shift state
     char_to_vk = {
         'a': (0x41, False), 'b': (0x42, False), 'c': (0x43, False), 'd': (0x44, False),
@@ -287,24 +277,27 @@ def type_string(text=None, delay=None, key_hold_time=None, vk_codes=None, combin
             for vk_code in vk_codes:
                 press_key(vk_code, False, act_start=False, act_end=True, key_hold_time=key_hold_time)
 
-
 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:
+    if not IS_WINDOWS:
         print("is_key_pressed_async() only supports Windows! Returning False")
         return False
+    import win32api
+    import ctypes
     return win32api.GetAsyncKeyState(vk_code) & 0x8000 != 0
 
-
 def scroll(amount, delay=None, post_scroll_delay=None):
-    if not WIN32_AVAILABLE:
+    if not IS_WINDOWS:
         print("scroll() only supports Windows! Functionality disabled")
         return
         
+    import zhmiscellany.misc
+    import ctypes
+    
     def raw_scroll(amount):
         # Constants for mouse input
         INPUT_MOUSE = 0
@@ -354,13 +347,14 @@ def scroll(amount, delay=None, post_scroll_delay=None):
     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:
+    if not IS_WINDOWS:
         print("get_mouse_buttons() only supports Windows! Returning [False, False, False]")
         return [False, False, False]
         
+    import ctypes
+    
     VK_LBUTTON = 0x01  # Left mouse button (M1)
     VK_RBUTTON = 0x02  # Right mouse button (M2)
     VK_MBUTTON = 0x04  # Middle mouse button (M3)
@@ -373,10 +367,11 @@ def get_mouse_buttons():
         bool(GetAsyncKeyState(VK_MBUTTON) & 0x8000)
     ]
 
-
-_last_press_time_map = {} # Stores the last press timestamp for each key
-
 def better_wait_for(key):
+    import threading
+    import keyboard
+    import time
+    
     key_name = key.lower()
     press_event = threading.Event() # Event to signal when the key is pressed
     _last_press_time_map.setdefault(key_name, 0) # Initialize last press time for this key
@@ -391,8 +386,11 @@ def better_wait_for(key):
     press_event.wait() # Block execution until the press_event is set
     keyboard.unhook(hook_id) # Clean up the listener after key is detected
 
-
 def toggle_function(func, key='f8', blocking=True):
+    import kthread
+    import threading
+    # better_wait_for is in the same module, no import needed
+    
     def atom():
         while True:
             better_wait_for(key)
@@ -407,7 +405,6 @@ def toggle_function(func, key='f8', blocking=True):
         t.start()
         return t
 
-
 def record_actions_to_code(RECORD_MOUSE_MOVEMENT=False, STOP_KEY='f9'):
     import time
     import pynput
@@ -653,7 +650,6 @@ def record_actions_to_code(RECORD_MOUSE_MOVEMENT=False, STOP_KEY='f9'):
     # Generate the replay script
     return generate_code(events, start_time)
 
-
 KEY_CODES = {
     'None': 0,
     'LeftMouseButton': 1,
@@ -797,4 +793,4 @@ KEY_CODES = {
     'StartApplication2': 183,
     'Equals': 187,
     'Minus': 189,
-}
+}

zhmiscellany/math.py

@@ -1,6 +1,3 @@
-import numpy as np
-
-
 def smart_percentage(things, total_things):
     if total_things == 0:
         return total_things
@@ -25,6 +22,7 @@ def clamp(value, minimum, maximum):
 
 
 def generate_grid(top_left, bottom_right, rows, cols, int_coords=True, row_major=True):
+    import numpy as np
     x = np.linspace(top_left[0], bottom_right[0], cols)
     y = np.linspace(top_left[1], bottom_right[1], rows)
     grid = np.array(np.meshgrid(x, y)).T.reshape(-1, 2)
@@ -44,6 +42,7 @@ def generate_grid(top_left, bottom_right, rows, cols, int_coords=True, row_major
 
 
 def generate_eased_points(p1, p2, num_points):
+    import numpy as np
     def ease_in_out(t):
         return t * t * (3 - 2 * t)  # Smoothstep formula
     x1, y1 = p1
@@ -65,6 +64,7 @@ def generate_eased_points(p1, p2, num_points):
 
 
 def generate_linear_points(p1, p2, num_points):
+    import numpy as np
     x1, y1 = p1
     x2, y2 = p2
 

zhmiscellany/misc.py

@@ -1,24 +1,10 @@
-import os, signal, importlib, sys
-import zhmiscellany.math
-import zhmiscellany.string
-import zhmiscellany.processing
+import sys
 import zhmiscellany.macro
-import zhmiscellany.fileio
-import time, hashlib, ctypes
-import random, string, copy
-import builtins, inspect
+import types
 
 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
-
-import types
+    WIN32_AVAILABLE = True
 
 # support backwards compatibility
 click_pixel = zhmiscellany.macro.click_pixel
@@ -29,6 +15,7 @@ KEY_CODES = zhmiscellany.macro.KEY_CODES
 
 
 def get_actual_screen_resolution():
+    import ctypes
     if not WIN32_AVAILABLE:
         print("get_actual_screen_resolution only supports Windows! Returning (0, 0)")
         return (0, 0)
@@ -40,9 +27,14 @@ def get_actual_screen_resolution():
 
 
 def focus_window(process_name: str, interval=0):
+    import time
+    import psutil
+    import ctypes
     if not WIN32_AVAILABLE:
         print("focus_window only supports Windows!")
         return
+    else:
+        import win32gui, win32con, win32process
     
     # Import user32.dll for additional window handling
     user32 = ctypes.windll.user32
@@ -130,9 +122,12 @@ def focus_window(process_name: str, interval=0):
 
 
 def setup_console_window(xy=(0, 0), wh=(400, 100), always_on_top=True):
+    import ctypes
     if not WIN32_AVAILABLE:
         print("setup_console_window only supports Windows!")
         return
+    else:
+        import win32gui, win32con, win32process
     
     # Get the console window handle
     hwnd = ctypes.windll.kernel32.GetConsoleWindow()
@@ -150,10 +145,13 @@ def setup_console_window(xy=(0, 0), wh=(400, 100), always_on_top=True):
 
 
 def die():
+    import os
+    import signal
     os.kill(os.getpid(), signal.SIGTERM)
 
 
 def show_progress(things, total_things, extra_data='', smart_ratelimit=False, max_prints=1000):
+    import zhmiscellany.math
     do_print = True
 
     if smart_ratelimit:
@@ -182,6 +180,8 @@ def smart_every_nth(number, n, total):
 
 
 def calculate_eta(timestamps, total_timestamps):
+    import time
+    import zhmiscellany.string
     if not timestamps:
         return "Not enough data to calculate ETA."
 
@@ -211,6 +211,8 @@ def decide(options, text):
 
 
 def import_module_from_path(path, module_name=None):
+    import importlib
+    import zhmiscellany.string
     if not module_name:
         module_name = zhmiscellany.string.get_universally_unique_string()
     spec = importlib.util.spec_from_file_location(module_name, path)
@@ -220,14 +222,18 @@ def import_module_from_path(path, module_name=None):
 
 
 def base62_hash(anything):
+    import hashlib
+    import zhmiscellany.string
     return zhmiscellany.string.convert_to_base62(int(int(hashlib.md5(anything if isinstance(anything, bytes) else str(anything).encode()).hexdigest(), 16)**0.5))
 
 
 def md5_int_hash(anything):
+    import hashlib
     return int(hashlib.md5(anything if isinstance(anything, bytes) else str(anything).encode()).hexdigest(), 16)
 
 
 def high_precision_sleep(duration):
+    import time
     start_time = time.perf_counter()
     while True:
         elapsed_time = time.perf_counter() - start_time
@@ -241,6 +247,7 @@ def high_precision_sleep(duration):
 
 
 def is_admin():
+    import ctypes
     if not WIN32_AVAILABLE:
         print("is_admin only supports Windows! Returning False")
         return False
@@ -251,6 +258,8 @@ def is_admin():
 
 
 def die_on_key(key='f9', show_message=False):
+    import zhmiscellany.macro
+    import zhmiscellany.processing
     def _die_on_key(key):
         zhmiscellany.macro.better_wait_for(key)
         if show_message:
@@ -259,10 +268,19 @@ def die_on_key(key='f9', show_message=False):
     zhmiscellany.processing.start_daemon(target=_die_on_key, args=(key,))
 
 if WIN32_AVAILABLE:
-    temp_folder = os.popen(r'echo %TEMP%').read().replace('\n', '')
+    def get_temp_folder():
+        import os
+        temp_folder = os.popen(r'echo %TEMP%').read().replace('\n', '')
+        return temp_folder
 
     def obfuscate_python(python_code_string, do_not_obfuscate_indent_block_comment='# DNO', remove_prints=True, remove_comments=True, add_lines=True, new_line_ratio=10):
         import keyword
+        import copy
+        import random
+        import string
+        import builtins
+        import inspect
+        import zhmiscellany.string
 
         obf = python_code_string
         dno_sig = do_not_obfuscate_indent_block_comment
@@ -697,6 +715,10 @@ _CYAN = '\033[96m'
 _RESET = '\033[0m'
 
 def time_it(action=False, clock=0):
+    import time
+    import inspect
+    import zhmiscellany.math
+    import sys
     global _start
     try:
         a = _start
@@ -718,6 +740,8 @@ def time_it(action=False, clock=0):
 
 
 def here(*args):
+    import inspect
+    import sys
     frame = inspect.currentframe().f_back  # Get caller frame
     filename = frame.f_code.co_filename
     lineno = frame.f_lineno
@@ -769,6 +793,7 @@ l = types.FunctionType(
 
 
 def wait_for_vsync():
+    import ctypes
     if not WIN32_AVAILABLE:
         print("wait_for_vsync only supports Windows!")
         return

zhmiscellany/netio.py

@@ -1,23 +1,12 @@
-import os, requests
-import zhmiscellany.string
-import urllib.parse
 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")
+    WIN32_AVAILABLE = True
 
 
 def resolve_file(url, destination_folder="."):
+    import urllib.parse
     file_name = urllib.parse.unquote(url.split("/")[-1])
     file_name = file_name.split('?')[0]
     destination_path = f"{destination_folder}/{file_name}"
@@ -27,6 +16,11 @@ def resolve_file(url, destination_folder="."):
 
 
 def download_file(url, destination_folder=".", just_return_path=False, headers=None, file_path=None):
+    import os, requests
+    from urllib3.exceptions import InsecureRequestWarning
+    import urllib3
+    urllib3.disable_warnings(InsecureRequestWarning)
+
     if file_path:
         destination_path = file_path
     else:
@@ -54,9 +48,12 @@ def download_file(url, destination_folder=".", just_return_path=False, headers=N
 
 
 def generate_headers(url):
+    import urllib.parse
     headers = {}
     
     if WIN32_AVAILABLE:
+        from zhmiscellany._misc_supportfuncs import _
+        from random_header_generator import HeaderGenerator
         generator = HeaderGenerator()
         for k, v in generator().items():
             headers[k] = v
@@ -68,6 +65,7 @@ def generate_headers(url):
 
 
 def is_internet():
+    import os, requests
     urls = [
         "http://1.1.1.1",
         "https://www.google.com",

zhmiscellany/pastebin.py

@@ -1,16 +1,15 @@
-
-import requests
-
 # PasteBin API Class - Developed by acidvegas in Python, modernized for use in zhmiscellany package. (https://git.acid.vegas/pastebin)
 class PasteBin:
     def __init__(self, api_dev_key, api_user_key=None):
+        import requests
+        self.requests = requests
         self.api_dev_key = api_dev_key
         self.api_user_key = api_user_key
 
     def api_call(self, method, params):
         '''Make a call to the PasteBin API.'''
         url = f'https://pastebin.com/api/{method}'
-        response = requests.post(url, data=params, timeout=10)
+        response = self.requests.post(url, data=params, timeout=10)
         try:
             response.raise_for_status()  # Raise an exception for HTTP errors
         except:
@@ -102,6 +101,8 @@ class PasteBin:
 
 class Pasteee:
     def __init__(self, api_key):
+        import requests
+        self.requests = requests
         self.api_key = api_key
         self.base_url = "https://api.paste.ee/v1/pastes"
 
@@ -111,15 +112,15 @@ class Pasteee:
         url = f"{self.base_url}{endpoint}"
 
         if method == 'POST':
-            response = requests.post(url, headers=headers, json=json_data, params=params, timeout=10)
+            response = self.requests.post(url, headers=headers, json=json_data, params=params, timeout=10)
         elif method == 'GET':
-            response = requests.get(url, headers=headers, params=params, timeout=10)
+            response = self.requests.get(url, headers=headers, params=params, timeout=10)
         elif method == 'DELETE':
-            response = requests.delete(url, headers=headers, params=params, timeout=10)
+            response = self.requests.delete(url, headers=headers, params=params, timeout=10)
 
         try:
             response.raise_for_status()
-        except requests.exceptions.RequestException as e:
+        except self.requests.exceptions.RequestException as e:
             raise Exception(f'ERROR {response.status_code}: {response.text}') from e
 
         return response.json()