#!/usr/bin/env python3
"""
Output fixer for the evaluation agent model.
This script provides utilities to fix malformed structured output from the model.
"""
import re
import json
from typing import Dict, Optional, Tuple
class ModelOutputFixer:
"""Fixes malformed structured output from the evaluation agent model."""
def __init__(self):
"""Initialize the output fixer."""
self.common_tools = [
"Object Class", "Scene", "Color", "Spatial Relationship",
"Human Action", "Dynamic Degree", "Multiple Objects",
"Overall Consistency", "Aesthetic Quality", "Imaging Quality",
"Motion Smoothness", "Subject Consistency", "Background Consistency"
]
self.common_subaspects = [
"Basic object class generation", "Intermediate object class generation",
"Complex object class generation", "Advanced object class generation",
"Simple color accuracy", "Complex color combinations",
"Basic spatial relationships", "Complex spatial arrangements",
"Single object generation", "Multiple object generation"
]
def parse_malformed_output(self, output: str) -> Dict[str, Optional[str]]:
"""
Parse malformed output and extract components.
Args:
output: Malformed model output
Returns:
Dictionary with think, subaspect, and tool components
"""
result = {"think": None, "subaspect": None, "tool": None}
# Try to extract think content (various patterns)
think_patterns = [
r'(.*?)',
r'(.*?)(?:||$)',
r'(?:^|>)(.*?)', # Content before
]
for pattern in think_patterns:
match = re.search(pattern, output, re.DOTALL)
if match and match.group(1).strip():
result["think"] = match.group(1).strip()
break
# Try to extract subaspect content
subaspect_patterns = [
r'(.*?)',
r'(.*?)(?:||$)',
r'([A-Z][^<]*(?:generation|accuracy|relationships?|evaluation))[^<]*', # Content ending with
]
for pattern in subaspect_patterns:
match = re.search(pattern, output, re.DOTALL | re.IGNORECASE)
if match and match.group(1).strip():
candidate = match.group(1).strip()
# Check if it looks like a subaspect
if any(keyword in candidate.lower() for keyword in ["generation", "accuracy", "evaluation", "assessment", "analysis"]):
result["subaspect"] = candidate
break
# Try to extract tool content
tool_patterns = [
r'(.*?)',
r'(.*?)$',
r'([^<]*(?:Object Class|Scene|Color|Human Action|Dynamic Degree)[^<]*)', # Tool name in wrong tag
]
for pattern in tool_patterns:
match = re.search(pattern, output, re.DOTALL)
if match and match.group(1).strip():
candidate = match.group(1).strip()
# Check if it's a known tool
if any(tool.lower() in candidate.lower() for tool in self.common_tools):
result["tool"] = candidate
break
return result
def fix_output(self, malformed_output: str) -> str:
"""
Fix malformed output and return properly structured format.
Args:
malformed_output: The malformed model output
Returns:
Fixed output in correct format
"""
parsed = self.parse_malformed_output(malformed_output)
# Fix missing components with reasonable defaults
if not parsed["think"]:
parsed["think"] = "To evaluate this aspect, I will analyze the model's capabilities systematically."
if not parsed["subaspect"]:
# Try to infer from context or use a generic one
if "object" in malformed_output.lower():
parsed["subaspect"] = "Object generation capability"
elif "color" in malformed_output.lower():
parsed["subaspect"] = "Color accuracy assessment"
else:
parsed["subaspect"] = "Basic capability evaluation"
if not parsed["tool"]:
# Try to infer tool from context
for tool in self.common_tools:
if tool.lower().replace(" ", "") in malformed_output.lower().replace(" ", ""):
parsed["tool"] = tool
break
if not parsed["tool"]:
parsed["tool"] = "Object Class" # Default tool
# Construct proper output
fixed_output = f"{parsed['think']} {parsed['subaspect']} {parsed['tool']}"
return fixed_output
def validate_output(self, output: str) -> Tuple[bool, str]:
"""
Validate if output has correct structure.
Args:
output: Output to validate
Returns:
Tuple of (is_valid, error_message)
"""
required_patterns = [
(r'.*?', "Missing or malformed tags"),
(r'.*?', "Missing or malformed tags"),
(r'.*?', "Missing or malformed tags")
]
for pattern, error_msg in required_patterns:
if not re.search(pattern, output, re.DOTALL):
return False, error_msg
return True, "Valid structure"
def interactive_fix(self):
"""Interactive mode for fixing outputs."""
print("š§ MODEL OUTPUT FIXER - Interactive Mode")
print("="*50)
print("Paste your malformed model output below (press Enter twice to finish):")
lines = []
while True:
try:
line = input()
if line.strip() == "" and lines:
break
lines.append(line)
except (EOFError, KeyboardInterrupt):
break
if not lines:
print("No input provided.")
return
malformed_output = "\n".join(lines)
print(f"\nš„ Input: {malformed_output}")
# Parse components
parsed = self.parse_malformed_output(malformed_output)
print(f"\nš Parsed Components:")
print(f" Think: {parsed['think'][:50]}..." if parsed['think'] else " Think: ā Not found")
print(f" Subaspect: {parsed['subaspect']}" if parsed['subaspect'] else " Subaspect: ā Not found")
print(f" Tool: {parsed['tool']}" if parsed['tool'] else " Tool: ā Not found")
# Fix output
fixed = self.fix_output(malformed_output)
print(f"\nā
Fixed Output:\n{fixed}")
# Validate
is_valid, msg = self.validate_output(fixed)
print(f"\nā Validation: {msg}")
def main():
"""Main function for command line usage."""
import argparse
parser = argparse.ArgumentParser(description="Fix malformed model output")
parser.add_argument("--input", "-i", help="Input malformed output string")
parser.add_argument("--file", "-f", help="Input file with malformed output")
parser.add_argument("--interactive", "-I", action="store_true", help="Interactive mode")
parser.add_argument("--output", "-o", help="Output file for fixed result")
args = parser.parse_args()
fixer = ModelOutputFixer()
if args.interactive:
fixer.interactive_fix()
return
# Get input
malformed_output = ""
if args.input:
malformed_output = args.input
elif args.file:
try:
with open(args.file, 'r') as f:
malformed_output = f.read().strip()
except Exception as e:
print(f"Error reading file: {e}")
return
else:
print("Please provide input via --input, --file, or --interactive")
return
if not malformed_output:
print("No input provided")
return
# Fix output
print(f"Input: {malformed_output}")
parsed = fixer.parse_malformed_output(malformed_output)
print(f"\nParsed components:")
for key, value in parsed.items():
print(f" {key}: {value}")
fixed = fixer.fix_output(malformed_output)
print(f"\nFixed output: {fixed}")
# Save to file if requested
if args.output:
try:
with open(args.output, 'w') as f:
f.write(fixed)
print(f"Fixed output saved to {args.output}")
except Exception as e:
print(f"Error saving file: {e}")
if __name__ == "__main__":
main()
# Example usage as a module:
# from fix_model_output import ModelOutputFixer
# fixer = ModelOutputFixer()
# fixed = fixer.fix_output("Advanced Object Class Generation Object Class")
# print(fixed)