Read_in_Relations.py

"""
Read_in_Relations.py - Parse formalized geometric problems from text files

This module parses text files containing geometric predicates separated by semicolons,
with goals marked by question marks.
"""

from typing import List, Tuple, Dict
from relations import predicate, geometric

pred_dict = {
    "col": predicate.Col,
    "para": predicate.Para,
    "cong": predicate.Cong,
    "perp": predicate.Perp,
    "midp": predicate.Midp,
    "cyclic": predicate.Cyclic,
    "eqangle": predicate.Eqangle,
    "simtri1": predicate.Simtri1,
    "simtri2": predicate.Simtri2,
    "contri1": predicate.Contri1,
    "contri2": predicate.Contri2,
    "sameclock": predicate.Sameclock,
    "eqratio": predicate.Eqratio,
    "circle": predicate.Circle,
    "tchord": predicate.Tchord
}

def parse_relations_file(filename: str, points_dict: Dict[str, geometric.Point]) -> Tuple[List, List]:
    """
    Parse a text file containing formalized geometric predicates.
    
    Args:
        filename: Path to the text file
        points_dict: Dictionary of points from the problem
        
    Returns:
        Tuple of (assumptions, goals) lists
    """
    with open(filename, 'r') as file:
        content = file.read().strip()
    
    # Split by semicolons and clean up
    statements = [s.strip() for s in content.split(';') if s.strip()]
    
    assumptions = []
    goals = []
    
    for statement in statements:
        if statement.startswith('?'):
            # This is a goal
            predicate_text = statement[1:].strip()
            goal = _parse_predicate(predicate_text, points_dict)
            if goal:
                goals.append(goal)
        else:
            # This is an assumption
            assumption = _parse_predicate(statement, points_dict)
            if assumption:
                assumptions.append(assumption)
                
    return assumptions, goals


def _parse_predicate(predicate_text: str, points_dict: Dict[str, geometric.Point]):
    """
    Parse a single predicate from text.
    
    Args:
        predicate_text: Text representation of predicate (e.g., "para A B C D")
        points_dict: Dictionary of available points
        
    Returns:
        Predicate instance or None if parsing fails
    """
    parts = predicate_text.strip().split()
    if not parts:
        return None
        
    pred_type = parts[0].lower()
    point_names = parts[1:]
    
    # Get point objects
    try:
        points = [points_dict[name] for name in point_names]
    except KeyError as e:
        print(f"Warning: Point {e} not found in points dictionary")
        return None
    
    # Create appropriate predicate
    if pred_type in pred_dict:
        pred_class = pred_dict[pred_type]
        return pred_class(*points)
    else:
        print(f"Warning: Unknown or invalid predicate: {predicate_text}")
        return None


def create_sample_relations_file(filename: str):
    """
    Create a sample relations file for testing.
    
    Args:
        filename: Path where to create the sample file
    """
    sample_content = """para A B C D;
para B C D A;
col A E C;
col B E D;
? cong A E E C"""
    
    with open(filename, 'w') as file:
        file.write(sample_content)
    
    print(f"Sample relations file created: {filename}")


def create_sample_relations_file2(filename: str):
    """
    Create a second sample relations file for testing.
    
    Args:
        filename: Path where to create the sample file
    """
    sample_content = """midp M A C;
para M N A B;
col N C B;
? midp N C B"""
    
    with open(filename, 'w') as file:
        file.write(sample_content)
    
    print(f"Sample relations file created: {filename}")