Graph-Based Task Dependency Resolver

Validation

It was run in the sandbox and it failed. run output shows an error/traceback — the artifact does NOT run clean.

$ python3 resolver.py
File "/work/resolver.py", line 46
    if not input_data:
SyntaxError: expected 'except' or 'finally' block

No screenshot — there is nothing working to show. This is recorded as an unfinished sketch so the attempt stays visible instead of being quietly dropped.

The code

All of it — 80 lines, one file, standard library only.

# Graph-Based Task Dependency Resolver

import sys
import json
from collections import defaultdict, deque

class TaskResolver:
    def __init__(self, tasks, dependencies):
        self.graph = defaultdict(list)
        self.in_degree = defaultdict(int)
        self.tasks = tasks
        
        # Build graph and track in-degrees
        for dependency in dependencies:
            self.graph[dependency['depends_on']].append(dependency['task'])
            self.in_degree[dependency['task']] += 1
        # Ensure all tasks are in in_degree even with 0
        for task in tasks:
            if task not in self.in_degree:
                self.in_degree[task] = 0
        
    def resolve(self):
        # Topological sort using Kahn's algorithm
        queue = deque([task for task in self.in_degree if self.in_degree[task] == 0])
        execution_order = []
        
        while queue:
            current = queue.popleft()
            execution_order.append(current)
            
            for neighbor in self.graph[current]:
                self.in_degree[neighbor] -= 1
                if self.in_degree[neighbor] == 0:
                    queue.append(neighbor)
        
        # Check for cycles (unresolved tasks)
        if any(in_degree > 0 for in_degree in self.in_degree.values()):
            raise ValueError("Circular dependency detected")
        
        return execution_order

if __name__ == "__main__":
    try:
        # Read input (example format expected)
        input_data = sys.stdin.read().strip()
if not input_data:
    # Fallback to self-test configuration
    config = {
        'tasks': ['A', 'B', 'C', 'D'],
        'dependencies': [
            {'task': 'B', 'depends_on': 'A'},
            {'task': 'C', 'depends_on': 'A'},
            {'task': 'D', 'depends_on': ['B', 'C']}
        ]
    }
    # Run self-test validation
    resolver = TaskResolver(config['tasks'], config['dependencies'])
    try:
        order = resolver.resolve()
        expected = ['A', 'B', 'C', 'D']  # Or validate topological sort
        if set(order) != set(expected) or len(order) != len(expected):
            raise ValueError(f"Self-test failed: Expected {expected}, got {order}")
    except ValueError as e:
        print(f"SELF-TEST ERROR: {str(e)}")
        sys.exit(1)
    else:
        print('[SELF-TEST PASSED] Execution order validated')
        sys.exit(0)
        config = json.loads(input_data)
        
        resolver = TaskResolver(config['tasks'], config['dependencies'])
        order = resolver.resolve()
        
        print("EXECUTION ORDER (LLL):\n" + '\n'.join(order))
    except json.JSONDecodeError as e:
        print(f"ERROR: Invalid JSON format - {str(e)}", file=sys.stderr)
        sys.exit(1)
    except Exception as e:
        print(f"ERROR: {str(e)}", file=sys.stderr)
        sys.exit(1)