223 lines
7.5 KiB
Python
223 lines
7.5 KiB
Python
#!/usr/bin/env python3
|
||
"""
|
||
Test script to verify logging works with ExactNode identifiers.
|
||
"""
|
||
|
||
import sys
|
||
import os
|
||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
|
||
|
||
from core.pipeline import is_model_node, is_input_node, is_output_node, get_stage_count
|
||
|
||
|
||
class MockExactNode:
|
||
"""Mock node that simulates the ExactNode behavior."""
|
||
|
||
def __init__(self, node_type, identifier):
|
||
self.node_type = node_type
|
||
self.__identifier__ = identifier
|
||
self.NODE_NAME = f"{node_type.capitalize()} Node"
|
||
|
||
def __str__(self):
|
||
return f"<{self.__class__.__name__}({self.NODE_NAME})>"
|
||
|
||
def __repr__(self):
|
||
return self.__str__()
|
||
|
||
|
||
class MockExactInputNode(MockExactNode):
|
||
def __init__(self):
|
||
super().__init__("Input", "com.cluster.input_node.ExactInputNode.ExactInputNode")
|
||
|
||
|
||
class MockExactModelNode(MockExactNode):
|
||
def __init__(self):
|
||
super().__init__("Model", "com.cluster.model_node.ExactModelNode.ExactModelNode")
|
||
|
||
|
||
class MockExactOutputNode(MockExactNode):
|
||
def __init__(self):
|
||
super().__init__("Output", "com.cluster.output_node.ExactOutputNode.ExactOutputNode")
|
||
|
||
|
||
class MockExactPreprocessNode(MockExactNode):
|
||
def __init__(self):
|
||
super().__init__("Preprocess", "com.cluster.preprocess_node.ExactPreprocessNode.ExactPreprocessNode")
|
||
|
||
|
||
class MockExactPostprocessNode(MockExactNode):
|
||
def __init__(self):
|
||
super().__init__("Postprocess", "com.cluster.postprocess_node.ExactPostprocessNode.ExactPostprocessNode")
|
||
|
||
|
||
class MockNodeGraph:
|
||
def __init__(self):
|
||
self.nodes = []
|
||
|
||
def all_nodes(self):
|
||
return self.nodes
|
||
|
||
def add_node(self, node):
|
||
self.nodes.append(node)
|
||
|
||
|
||
def test_exact_node_detection():
|
||
"""Test that our detection methods work with ExactNode identifiers."""
|
||
print("Testing ExactNode Detection...")
|
||
|
||
# Create ExactNode instances
|
||
input_node = MockExactInputNode()
|
||
model_node = MockExactModelNode()
|
||
output_node = MockExactOutputNode()
|
||
preprocess_node = MockExactPreprocessNode()
|
||
postprocess_node = MockExactPostprocessNode()
|
||
|
||
# Test detection
|
||
print(f"Input node: {input_node}")
|
||
print(f" Identifier: {input_node.__identifier__}")
|
||
print(f" is_input_node: {is_input_node(input_node)}")
|
||
print(f" is_model_node: {is_model_node(input_node)}")
|
||
print()
|
||
|
||
print(f"Model node: {model_node}")
|
||
print(f" Identifier: {model_node.__identifier__}")
|
||
print(f" is_model_node: {is_model_node(model_node)}")
|
||
print(f" is_input_node: {is_input_node(model_node)}")
|
||
print()
|
||
|
||
print(f"Output node: {output_node}")
|
||
print(f" Identifier: {output_node.__identifier__}")
|
||
print(f" is_output_node: {is_output_node(output_node)}")
|
||
print(f" is_model_node: {is_model_node(output_node)}")
|
||
print()
|
||
|
||
# Test stage counting
|
||
graph = MockNodeGraph()
|
||
print("Testing stage counting with ExactNodes...")
|
||
|
||
print(f"Empty graph: {get_stage_count(graph)} stages")
|
||
|
||
graph.add_node(input_node)
|
||
print(f"After adding input: {get_stage_count(graph)} stages")
|
||
|
||
graph.add_node(model_node)
|
||
print(f"After adding model: {get_stage_count(graph)} stages")
|
||
|
||
graph.add_node(output_node)
|
||
print(f"After adding output: {get_stage_count(graph)} stages")
|
||
|
||
model_node2 = MockExactModelNode()
|
||
graph.add_node(model_node2)
|
||
print(f"After adding second model: {get_stage_count(graph)} stages")
|
||
|
||
print("\n✅ ExactNode detection tests completed!")
|
||
|
||
|
||
def simulate_pipeline_logging():
|
||
"""Simulate the pipeline logging that would occur in the actual editor."""
|
||
print("\n" + "="*60)
|
||
print("Simulating Pipeline Editor Logging with ExactNodes")
|
||
print("="*60)
|
||
|
||
class MockPipelineEditor:
|
||
def __init__(self):
|
||
self.previous_stage_count = 0
|
||
self.nodes = []
|
||
print("🚀 Pipeline Editor initialized")
|
||
self.analyze_pipeline()
|
||
|
||
def add_node(self, node_type):
|
||
print(f"🔄 Adding {node_type} via toolbar...")
|
||
|
||
if node_type == "Input":
|
||
node = MockExactInputNode()
|
||
elif node_type == "Model":
|
||
node = MockExactModelNode()
|
||
elif node_type == "Output":
|
||
node = MockExactOutputNode()
|
||
elif node_type == "Preprocess":
|
||
node = MockExactPreprocessNode()
|
||
elif node_type == "Postprocess":
|
||
node = MockExactPostprocessNode()
|
||
|
||
self.nodes.append(node)
|
||
print(f"➕ Node added: {node.NODE_NAME}")
|
||
self.analyze_pipeline()
|
||
|
||
def analyze_pipeline(self):
|
||
graph = MockNodeGraph()
|
||
for node in self.nodes:
|
||
graph.add_node(node)
|
||
|
||
current_stage_count = get_stage_count(graph)
|
||
|
||
# Print stage count changes
|
||
if current_stage_count != self.previous_stage_count:
|
||
if self.previous_stage_count == 0 and current_stage_count > 0:
|
||
print(f"🎯 Initial stage count: {current_stage_count}")
|
||
elif current_stage_count != self.previous_stage_count:
|
||
change = current_stage_count - self.previous_stage_count
|
||
if change > 0:
|
||
print(f"📈 Stage count increased: {self.previous_stage_count} → {current_stage_count} (+{change})")
|
||
else:
|
||
print(f"📉 Stage count decreased: {self.previous_stage_count} → {current_stage_count} ({change})")
|
||
|
||
# Print current status
|
||
print(f"📊 Current Pipeline Status:")
|
||
print(f" • Stages: {current_stage_count}")
|
||
print(f" • Total Nodes: {len(self.nodes)}")
|
||
print("─" * 50)
|
||
|
||
self.previous_stage_count = current_stage_count
|
||
|
||
# Run simulation
|
||
editor = MockPipelineEditor()
|
||
|
||
print("\n1. Adding Input Node:")
|
||
editor.add_node("Input")
|
||
|
||
print("\n2. Adding Model Node:")
|
||
editor.add_node("Model")
|
||
|
||
print("\n3. Adding Output Node:")
|
||
editor.add_node("Output")
|
||
|
||
print("\n4. Adding Preprocess Node:")
|
||
editor.add_node("Preprocess")
|
||
|
||
print("\n5. Adding Second Model Node:")
|
||
editor.add_node("Model")
|
||
|
||
print("\n6. Adding Postprocess Node:")
|
||
editor.add_node("Postprocess")
|
||
|
||
print("\n✅ Simulation completed!")
|
||
|
||
|
||
def main():
|
||
"""Run all tests."""
|
||
try:
|
||
test_exact_node_detection()
|
||
simulate_pipeline_logging()
|
||
|
||
print("\n" + "="*60)
|
||
print("🎉 All tests completed successfully!")
|
||
print("="*60)
|
||
print("\nWhat you observed:")
|
||
print("• The logs show stage count changes when you add/remove model nodes")
|
||
print("• 'Updating for X stages' messages indicate the stage count is working")
|
||
print("• The identifier fallback mechanism handles different node formats")
|
||
print("• The detection methods correctly identify ExactNode types")
|
||
print("\nThis is completely normal behavior! The logs demonstrate that:")
|
||
print("• Stage counting works correctly with your ExactNode identifiers")
|
||
print("• The pipeline editor properly detects and counts model nodes")
|
||
print("• Real-time logging shows stage changes as they happen")
|
||
|
||
except Exception as e:
|
||
print(f"❌ Test failed: {e}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
|
||
if __name__ == '__main__':
|
||
main() |