Merge pull request #16 from ryanontheinside/refactor/phase-3

Refactor/phase 3

Author: ryanontheinside

__init__.py

@@ -1,6 +1,6 @@
-import os
 import importlib
 import inspect
+import os
 import re
 import traceback
 
@@ -11,74 +11,79 @@
 
 print("\033[93m" + "[ComfyUI_RealtimeNodes] Loading nodes...")
 
+
 def load_nodes_from_directory(package_path):
     """Dynamically loads nodes from Python files in a directory."""
-    loaded_nodes = {} 
+    loaded_nodes = {}
     loaded_display_names = {}
-    
+
     # Calculate absolute path to the package directory
-    package_abs_path = os.path.join(os.path.dirname(__file__), *package_path.split('.'))
-    
+    package_abs_path = os.path.join(os.path.dirname(__file__), *package_path.split("."))
+
     if not os.path.isdir(package_abs_path):
         print(f"\033[91m" + f"[ComfyUI_RealtimeNodes] Warning: Directory not found: {package_abs_path}")
         return loaded_nodes, loaded_display_names
 
     print(f"\033[92m" + f"[ComfyUI_RealtimeNodes] Searching for nodes in: {package_abs_path}")
 
     for filename in os.listdir(package_abs_path):
-        if filename.endswith(".py") and not filename.startswith('__'):
+        if filename.endswith(".py") and not filename.startswith("__"):
             module_name = filename[:-3]
-            full_module_path = f".{package_path}.{module_name}" # Relative import path
-            
+            full_module_path = f".{package_path}.{module_name}"  # Relative import path
+
             try:
                 module = importlib.import_module(full_module_path, package=__name__)
-                
+
                 # Find classes defined in the module
                 for name, obj in inspect.getmembers(module):
                     if inspect.isclass(obj):
                         # Check if it's a ComfyUI node (heuristic: has INPUT_TYPES)
-                        if hasattr(obj, 'INPUT_TYPES') and callable(obj.INPUT_TYPES):
-                             # Exclude base classes/mixins if they are explicitly named or lack a CATEGORY
-                             if not name.endswith("Base") and not name.endswith("Mixin") and hasattr(obj, 'CATEGORY'):
+                        if hasattr(obj, "INPUT_TYPES") and callable(obj.INPUT_TYPES):
+                            # Exclude base classes/mixins if they are explicitly named or lack a CATEGORY
+                            if not name.endswith("Base") and not name.endswith("Mixin") and hasattr(obj, "CATEGORY"):
                                 loaded_nodes[name] = obj
-                                
+
                                 # Generate display name (similar to original logic)
-                                display_name = ' '.join(word.capitalize() for word in re.findall(r'[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|\W|$)|\d+', name))
+                                display_name = " ".join(
+                                    word.capitalize() for word in re.findall(r"[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|\W|$)|\d+", name)
+                                )
                                 suffix = " 🕒🅡🅣🅝"
                                 if not display_name.endswith(suffix):
                                     display_name += suffix
                                 loaded_display_names[name] = display_name
                                 print(f"\033[94m" + f"[ComfyUI_RealtimeNodes]   - Loaded node: {name} -> {display_name}")
-                                
+
             except ImportError as e:
                 print(f"\033[91m" + f"[ComfyUI_RealtimeNodes] Error importing module {full_module_path}: {e}")
                 traceback.print_exc()
             except Exception as e:
                 print(f"\033[91m" + f"[ComfyUI_RealtimeNodes] Error processing module {full_module_path}: {e}")
                 traceback.print_exc()
-                
+
     return loaded_nodes, loaded_display_names
 
+
 # --- Main Loading Logic ---
 
 # Get base path for the node_wrappers directory
 base_dir_path = os.path.join(os.path.dirname(__file__), WRAPPER_DIR)
 
+
 # Recursively scan all directories and subdirectories
 def scan_for_modules(base_path, base_package):
     """Recursively scan directories for module files"""
     try:
         for item in os.listdir(base_path):
             item_path = os.path.join(base_path, item)
-            
+
             # Skip __pycache__ and files/dirs starting with __
-            if item.startswith('__'):
+            if item.startswith("__"):
                 continue
-                
+
             if os.path.isdir(item_path):
                 # Handle subdirectory
                 subdir_package = f"{base_package}.{item}"
-                
+
                 # First load .py files in this directory
                 try:
                     nodes, display_names = load_nodes_from_directory(subdir_package)
@@ -87,14 +92,15 @@ def scan_for_modules(base_path, base_package):
                 except Exception as e:
                     print(f"\033[91m" + f"[ComfyUI_RealtimeNodes] Error processing directory {subdir_package}: {e}")
                     traceback.print_exc()
-                
+
                 # Then recursively process subdirectories
                 subdir_path = os.path.join(base_path, item)
                 scan_for_modules(subdir_path, subdir_package)
     except Exception as e:
         print(f"\033[91m" + f"[ComfyUI_RealtimeNodes] Error scanning directory {base_path}: {e}")
         traceback.print_exc()
 
+
 # Start recursive scanning from the base directory
 print(f"\033[92m" + f"[ComfyUI_RealtimeNodes] Scanning node_wrappers directory for modules...")
 scan_for_modules(base_dir_path, WRAPPER_DIR)
@@ -104,19 +110,19 @@ def scan_for_modules(base_path, base_package):
 for node_name in NODE_CLASS_MAPPINGS.keys():
     # Convert camelCase or snake_case to Title Case
     if node_name not in NODE_DISPLAY_NAME_MAPPINGS:
-        display_name = ' '.join(word.capitalize() for word in re.findall(r'[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|\W|$)|\d+', node_name))
+        display_name = " ".join(word.capitalize() for word in re.findall(r"[A-Z]?[a-z]+|[A-Z]+(?=[A-Z][a-z]|\d|\W|$)|\d+", node_name))
     else:
         display_name = NODE_DISPLAY_NAME_MAPPINGS[node_name]
-    
+
     # Add the suffix if it's not already present
     if not display_name.endswith(suffix):
         display_name += suffix
-    
+
     # Assign the final display name to the mappings
     NODE_DISPLAY_NAME_MAPPINGS[node_name] = display_name
 # --- Original Web Directory and Export ---
-WEB_DIRECTORY = "./web/js" # Adjusted path if needed
+WEB_DIRECTORY = "./web/js"  # Adjusted path if needed
 
-__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS']
+__all__ = ["NODE_CLASS_MAPPINGS", "NODE_DISPLAY_NAME_MAPPINGS"]
 
-print("\033[92m" + f"[ComfyUI_RealtimeNodes] Loaded {len(NODE_CLASS_MAPPINGS)} nodes.") 
+print("\033[92m" + f"[ComfyUI_RealtimeNodes] Loaded {len(NODE_CLASS_MAPPINGS)} nodes.")

node_wrappers/__init__.py

@@ -1 +1 @@
-# This file intentionally left blank 
+# This file intentionally left blank

node_wrappers/coordinates/__init__.py

@@ -4,7 +4,3 @@
 This package provides node wrappers for the coordinate system functionality,
 allowing users to convert between coordinate spaces and create coordinate objects.
 """
-
-from .conversion_nodes import NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS
-
-__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS'] 

node_wrappers/coordinates/conversion_nodes.py

@@ -4,18 +4,18 @@
 These nodes provide user-friendly interfaces for the coordinate system functionality.
 """
 
-import torch
 import logging
-from typing import Union, List, Tuple
 
 from ...src.coordinates import CoordinateSystem
 
 logger = logging.getLogger(__name__)
 
+
 class CoordinateConverterNode:
     """
     Fast coordinate conversion between different coordinate spaces.
     """
+
     CATEGORY = "Realtime Nodes/Coordinates"
     FUNCTION = "convert_coordinates"
     RETURN_TYPES = ("FLOAT", "FLOAT")
@@ -42,20 +42,20 @@ def convert_coordinates(self, x, y, image_for_dimensions, from_space, to_space):
         try:
             # Get dimensions from image
             dimensions = CoordinateSystem.get_dimensions_from_tensor(image_for_dimensions)
-            
+
             # Map string inputs to CoordinateSystem constants
             space_map = {
                 "pixel": CoordinateSystem.PIXEL,
                 "normalized": CoordinateSystem.NORMALIZED,
             }
-            
+
             from_space_const = space_map[from_space]
             to_space_const = space_map[to_space]
-            
+
             # Convert coordinates
             x_out = CoordinateSystem.convert(x, dimensions[0], from_space_const, to_space_const)
             y_out = CoordinateSystem.convert(y, dimensions[1], from_space_const, to_space_const)
-            
+
             return (x_out, y_out)
         except Exception as e:
             logger.error(f"Error in coordinate conversion: {e}")
@@ -66,6 +66,7 @@ class Point2DNode:
     """
     Creates a 2D point with coordinate space awareness.
     """
+
     CATEGORY = "Realtime Nodes/Coordinates"
     FUNCTION = "create_point"
     RETURN_TYPES = ("POINT",)
@@ -80,33 +81,37 @@ def INPUT_TYPES(cls):
                 "space": (["normalized", "pixel"],),
             },
             "optional": {
-                "image_for_dimensions": ("IMAGE", {"tooltip": "Reference image for dimensions (required for pixel space)"}),
-            }
+                "image_for_dimensions": (
+                    "IMAGE",
+                    {"tooltip": "Reference image for dimensions (required for pixel space)"},
+                ),
+            },
         }
 
     def create_point(self, x, y, space, image_for_dimensions=None):
         """Create a Point object."""
         from ...src.coordinates import Point
-        
+
         space_map = {
             "pixel": CoordinateSystem.PIXEL,
             "normalized": CoordinateSystem.NORMALIZED,
         }
-        
+
         space_const = space_map[space]
-        
+
         # Validate dimensions if using pixel space
         if space == "pixel" and image_for_dimensions is None:
             logger.warning("Pixel space selected but no image provided for dimensions. Using normalized space.")
             space_const = CoordinateSystem.NORMALIZED
-        
+
         return (Point(x, y, None, space_const),)
 
 
 class PointListNode:
     """
     Creates a list of points from coordinate lists.
     """
+
     CATEGORY = "Realtime Nodes/Coordinates"
     FUNCTION = "create_point_list"
     RETURN_TYPES = ("POINT_LIST",)
@@ -116,40 +121,52 @@ class PointListNode:
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "x_coords": ("FLOAT", {"default": [0.25, 0.5, 0.75], "forceInput": True, "tooltip": "List of X coordinates"}),
-                "y_coords": ("FLOAT", {"default": [0.25, 0.5, 0.75], "forceInput": True, "tooltip": "List of Y coordinates"}),
+                "x_coords": (
+                    "FLOAT",
+                    {"default": [0.25, 0.5, 0.75], "forceInput": True, "tooltip": "List of X coordinates"},
+                ),
+                "y_coords": (
+                    "FLOAT",
+                    {"default": [0.25, 0.5, 0.75], "forceInput": True, "tooltip": "List of Y coordinates"},
+                ),
                 "space": (["normalized", "pixel"],),
             },
             "optional": {
-                "z_coords": ("FLOAT", {"default": None, "forceInput": True, "tooltip": "List of Z coordinates (optional)"}),
-                "image_for_dimensions": ("IMAGE", {"tooltip": "Reference image for dimensions (required for pixel space)"}),
-            }
+                "z_coords": (
+                    "FLOAT",
+                    {"default": None, "forceInput": True, "tooltip": "List of Z coordinates (optional)"},
+                ),
+                "image_for_dimensions": (
+                    "IMAGE",
+                    {"tooltip": "Reference image for dimensions (required for pixel space)"},
+                ),
+            },
         }
 
     def create_point_list(self, x_coords, y_coords, space, z_coords=None, image_for_dimensions=None):
         """Create a PointList object."""
         from ...src.coordinates import PointList
-        
+
         space_map = {
             "pixel": CoordinateSystem.PIXEL,
             "normalized": CoordinateSystem.NORMALIZED,
         }
-        
+
         space_const = space_map[space]
-        
+
         # Validate dimensions if using pixel space
         if space == "pixel" and image_for_dimensions is None:
             logger.warning("Pixel space selected but no image provided for dimensions. Using normalized space.")
             space_const = CoordinateSystem.NORMALIZED
-        
+
         # Ensure inputs are lists
         if not isinstance(x_coords, list):
             x_coords = [x_coords]
         if not isinstance(y_coords, list):
             y_coords = [y_coords]
         if z_coords is not None and not isinstance(z_coords, list):
             z_coords = [z_coords]
-        
+
         return (PointList.from_coordinates(x_coords, y_coords, z_coords, space_const),)
 
 
@@ -165,4 +182,4 @@ def create_point_list(self, x_coords, y_coords, space, z_coords=None, image_for_
     "CoordinateConverter": "Coordinate Converter",
     "Point2D": "Create 2D Point",
     "PointList": "Create Point List",
-} 
+}