socket types are not determined by type hints. no longer hardcoded

Author: Bryan Howard

color_utils.py

@@ -0,0 +1,52 @@
+# color_utils.py
+# A utility for generating consistent, bright colors from arbitrary strings.
+
+import hashlib
+from PySide6.QtGui import QColor
+
+# A cache to store generated colors so we don't have to re-hash every time.
+COLOR_CACHE = {}
+
+
+def generate_color_from_string(type_str: str) -> QColor:
+    """
+    Generates a consistent, bright QColor from a given string (e.g., a type hint).
+
+    This function uses a hashing algorithm to ensure the same string always
+    produces the same color. The hash is then used to generate HSV values
+    that are constrained to a bright and colorful range.
+
+    :param type_str: The string to generate a color for.
+    :return: A QColor instance.
+    """
+    type_str = type_str.lower()
+
+    if type_str in COLOR_CACHE:
+        return COLOR_CACHE[type_str]
+
+    # Special case for a generic 'any' type for reroute nodes, etc.
+    if type_str == "any":
+        color = QColor("#C0C0C0")  # Grey
+        COLOR_CACHE[type_str] = color
+        return color
+
+    # Use SHA1 to get a consistent hash from the string
+    hash_object = hashlib.sha1(type_str.encode("utf-8"))
+    hex_digest = hash_object.hexdigest()
+
+    # Use parts of the hash to determine Hue, Saturation, and Value
+    # We use integer conversion on slices of the hex hash string
+
+    # Hue: Full 360-degree range for variety
+    hue = int(hex_digest[:4], 16) % 360
+
+    # Saturation: Constrained to be high (180-255) to avoid dull colors
+    saturation = 180 + (int(hex_digest[4:8], 16) % 76)
+
+    # Value: Constrained to be high (200-255) to avoid dark colors
+    value = 200 + (int(hex_digest[8:12], 16) % 56)
+
+    color = QColor.fromHsv(hue, saturation, value)
+    COLOR_CACHE[type_str] = color
+
+    return color

node.py

@@ -1,15 +1,13 @@
 # node.py
 # Represents a single processing unit (node) in the graph.
-# This version contains the definitive fix for dynamic resizing and re-implements
-# the node properties context menu.
+# Now uses the simplified, dynamic pin creation system.
 
 import uuid
 import ast
 from PySide6.QtWidgets import QGraphicsItem, QGraphicsTextItem, QGraphicsProxyWidget, QPushButton, QVBoxLayout, QWidget
 from PySide6.QtCore import QRectF, Qt, QPointF, Signal
 from PySide6.QtGui import QPainter, QColor, QBrush, QPen, QFont, QLinearGradient, QPainterPath, QContextMenuEvent
 from pin import Pin
-from socket_type import SocketType
 from code_editor_dialog import CodeEditorDialog
 from node_properties_dialog import NodePropertiesDialog
 
@@ -78,13 +76,12 @@ def contextMenuEvent(self, event: QContextMenuEvent):
             self._title_item.setPlainText(self.title)
             self.color_title_bar = QColor(props["title_color"])
             self.color_body = QColor(props["body_color"])
-            self.update()  # Redraw the node with new colors
+            self.update()
 
     def _create_content_widget(self):
         """Creates the main content area with the custom GUI and a single control button."""
         self.content_container = ResizableWidgetContainer()
         self.content_container.setAttribute(Qt.WA_TranslucentBackground)
-        # Connect the custom resized signal to our layout update function
         self.content_container.resized.connect(self._update_layout)
 
         main_layout = QVBoxLayout(self.content_container)
@@ -127,7 +124,6 @@ def rebuild_gui(self):
                 error_label.setStyleSheet("color: red;")
                 self.custom_widget_layout.addWidget(error_label)
 
-        # Trigger an initial layout update after building the GUI
         self._update_layout()
 
     def get_gui_values(self):
@@ -206,6 +202,7 @@ def _update_layout(self):
         num_pins = max(len(self.input_pins), len(self.output_pins))
         pin_area_height = (num_pins * pin_spacing) if num_pins > 0 else 0
 
+        self.content_container.layout().activate()
         content_size = self.content_container.sizeHint()
         content_height = content_size.height()
 
@@ -249,7 +246,6 @@ def paint(self, painter: QPainter, option, widget=None):
         painter.drawLine(0, 32, self.width, 32)
         painter.restore()
 
-    # --- Other methods remain the same ---
     def get_pin_by_name(self, name):
         for pin in self.pins:
             if pin.name == name:
@@ -296,6 +292,7 @@ def update_pins_from_code(self):
                     new_outputs["output_1"] = self._parse_type_hint(return_annotation).lower()
         except (SyntaxError, AttributeError):
             return
+
         current_inputs = {pin.name: pin for pin in self.input_pins}
         current_outputs = {pin.name: pin for pin in self.output_pins}
         for name, pin in list(current_inputs.items()):
@@ -313,11 +310,8 @@ def update_pins_from_code(self):
         self._update_layout()
 
     def add_pin(self, name, direction, pin_type_str):
-        type_map = {"STR": "STRING", "BOOL": "BOOLEAN"}
-        processed_type_str = pin_type_str.upper().split("[")[0]
-        final_type_str = type_map.get(processed_type_str, processed_type_str)
-        pin_type = SocketType[final_type_str] if final_type_str in SocketType.__members__ else SocketType.ANY
-        pin = Pin(self, name, direction, pin_type)
+        """Creates a new Pin, passing the raw type string for color generation."""
+        pin = Pin(self, name, direction, pin_type_str)
         self.pins.append(pin)
         if direction == "input":
             self.input_pins.append(pin)

pin.py

@@ -1,38 +1,40 @@
 # pin.py
 # Represents an input or output socket on a node.
-# Now manages its own text label.
+# Now uses a dynamic string for its type and generates its color procedurally.
 
 import uuid
 from PySide6.QtWidgets import QGraphicsItem, QGraphicsTextItem
 from PySide6.QtCore import QRectF, Qt
 from PySide6.QtGui import QPainter, QColor, QBrush, QPen, QFont
-from socket_type import SocketType
+from color_utils import generate_color_from_string
+
 
 class Pin(QGraphicsItem):
     """
     A pin represents an input or output on a Node.
-    It handles drawing itself, its label, and its connections.
+    Its type is a string, and its color is generated dynamically from that string.
     """
-    def __init__(self, node, name, direction, pin_type_enum, parent=None):
+
+    def __init__(self, node, name, direction, pin_type_str, parent=None):
         super().__init__(node)
-        
+
         self.node = node
         self.name = name
         self.direction = direction
-        self.pin_type = pin_type_enum
+        self.pin_type = pin_type_str  # The type is now just a string
         self.uuid = str(uuid.uuid4())
-        
+
         self.radius = 6
         self.connections = []
         self.value = None
         self.label_margin = 8
 
-        # --- Visuals ---
-        self.color = self.pin_type.value
+        # --- Dynamic Color Generation ---
+        self.color = generate_color_from_string(self.pin_type)
         self.brush = QBrush(self.color)
         self.pen = QPen(QColor("#F0F0F0"))
         self.pen.setWidth(2)
-        
+
         # --- Label ---
         self.label = QGraphicsTextItem(self.name.replace("_", " ").title(), self)
         self.label.setDefaultTextColor(QColor("#FFDDDDDD"))
@@ -51,11 +53,9 @@ def destroy(self):
     def update_label_pos(self):
         """Update the position of the pin's text label relative to the pin."""
         if self.direction == "output":
-            # Align text to the left of the pin
             label_x = -self.label.boundingRect().width() - self.label_margin
             self.label.setPos(label_x, -self.label.boundingRect().height() / 2)
         else:
-            # Align text to the right of the pin
             label_x = self.label_margin
             self.label.setPos(label_x, -self.label.boundingRect().height() / 2)
 
@@ -83,16 +83,24 @@ def update_connections(self):
         self.scene().update()
 
     def can_connect_to(self, other_pin):
-        if not other_pin or self == other_pin: return False
-        if self.node == other_pin.node: return False
-        if self.direction == other_pin.direction: return False
-        if other_pin.direction == "input" and len(other_pin.connections) > 0: return False
-        if self.direction == "input" and len(self.connections) > 0: return False
-        
-        if self.pin_type == other_pin.pin_type: return True
-        if self.pin_type == SocketType.ANY or other_pin.pin_type == SocketType.ANY: return True
-        
-        return False
+        """Checks for compatibility based on pin type strings."""
+        if not other_pin or self == other_pin:
+            return False
+        if self.node == other_pin.node:
+            return False
+        if self.direction == other_pin.direction:
+            return False
+        if other_pin.direction == "input" and len(other_pin.connections) > 0:
+            return False
+        if self.direction == "input" and len(self.connections) > 0:
+            return False
+
+        # Allow 'any' to connect to anything
+        if self.pin_type == "any" or other_pin.pin_type == "any":
+            return True
+
+        # Otherwise, require an exact type match
+        return self.pin_type == other_pin.pin_type
 
     def mousePressEvent(self, event):
         if event.button() == Qt.LeftButton:
@@ -102,4 +110,4 @@ def mousePressEvent(self, event):
             event.ignore()
 
     def serialize(self):
-        return {"uuid": self.uuid, "name": self.name, "direction": self.direction, "type": self.pin_type.name.lower()}
+        return {"uuid": self.uuid, "name": self.name, "direction": self.direction, "type": self.pin_type}

reroute_node.py

@@ -1,20 +1,21 @@
 # reroute_node.py
 # A simple, draggable node for organizing connections.
-# Now with a serialize method for saving and loading.
+# Now uses the dynamic color generation system.
 
 import uuid
 from PySide6.QtWidgets import QGraphicsItem, QStyle
 from PySide6.QtCore import QRectF, QPointF
-from PySide6.QtGui import (QPainter, QColor, QBrush, QPen, QRadialGradient, 
-                           QKeyEvent, QPainterPath)
+from PySide6.QtGui import QPainter, QColor, QBrush, QPen, QRadialGradient, QKeyEvent, QPainterPath
 from pin import Pin
-from socket_type import SocketType
+from color_utils import generate_color_from_string
+
 
 class RerouteNode(QGraphicsItem):
     """
     A small, circular node that passes a connection through and
     adopts the color of the data type.
     """
+
     def __init__(self, parent=None):
         super().__init__(parent)
         self.setFlag(QGraphicsItem.ItemIsMovable)
@@ -25,22 +26,14 @@ def __init__(self, parent=None):
         self.title = "Reroute"
         self.radius = 8
         self.pins = []
-        
-        self.input_pin = self.add_pin("input", "input", SocketType.ANY)
-        self.output_pin = self.add_pin("output", "output", SocketType.ANY)
-        
+
+        self.input_pin = self.add_pin("input", "input", "any")
+        self.output_pin = self.add_pin("output", "output", "any")
+
         self.input_pin.setPos(0, 0)
         self.output_pin.setPos(0, 0)
-        
-        self.update_color()
 
-    def get_pin_by_name(self, name):
-        """Finds a pin on this node by its name ('input' or 'output')."""
-        if name == 'input':
-            return self.input_pin
-        elif name == 'output':
-            return self.output_pin
-        return None
+        self.update_color()
 
     def update_color(self):
         """Updates the node's color based on its input connection."""
@@ -49,8 +42,8 @@ def update_color(self):
             new_type = source_pin.pin_type
             new_color = source_pin.color
         else:
-            new_type = SocketType.ANY
-            new_color = SocketType.ANY.value
+            new_type = "any"
+            new_color = generate_color_from_string("any")
 
         self.color_base = new_color.darker(110)
         self.color_highlight = new_color.lighter(110)
@@ -60,23 +53,30 @@ def update_color(self):
 
         self.output_pin.pin_type = new_type
         self.output_pin.color = new_color
-        
+
         if self.scene():
             self.output_pin.update_connections()
             self.update()
 
-    def add_pin(self, name, direction, pin_type_enum):
-        pin = Pin(self, name, direction, pin_type_enum)
+    def add_pin(self, name, direction, pin_type_str):
+        pin = Pin(self, name, direction, pin_type_str)
         pin.hide()
         self.pins.append(pin)
         return pin
 
+    def get_pin_by_name(self, name):
+        if name == "input":
+            return self.input_pin
+        elif name == "output":
+            return self.output_pin
+        return None
+
     def boundingRect(self):
         return QRectF(-self.radius, -self.radius, 2 * self.radius, 2 * self.radius).adjusted(-5, -5, 5, 5)
 
     def shape(self):
         path = QPainterPath()
-        hitbox_radius = self.radius + 4 
+        hitbox_radius = self.radius + 4
         path.addEllipse(QPointF(0, 0), hitbox_radius, hitbox_radius)
         return path
 
@@ -89,10 +89,10 @@ def itemChange(self, change, value):
     def paint(self, painter: QPainter, option, widget=None):
         if option.state & QStyle.State_Selected:
             option.state &= ~QStyle.State_Selected
-        
+
         draw_rect = QRectF(-self.radius, -self.radius, self.radius * 2, self.radius * 2)
         gradient = QRadialGradient(QPointF(0, 0), self.radius)
-        
+
         if self.isSelected():
             painter.setPen(self.pen_selected)
             gradient.setColorAt(0, self.color_base.lighter(130))
@@ -106,9 +106,4 @@ def paint(self, painter: QPainter, option, widget=None):
         painter.drawEllipse(draw_rect)
 
     def serialize(self):
-        """Converts the reroute node's state to a serializable dictionary."""
-        return {
-            "uuid": self.uuid,
-            "pos": (self.pos().x(), self.pos().y()),
-            "is_reroute": True
-        }
+        return {"uuid": self.uuid, "pos": (self.pos().x(), self.pos().y()), "is_reroute": True}