evaluate_code/extract.py

from typing import Dict, List, Any
import re

def _extract_section(text: str, start_marker: str, end_marker: str) -> str:
    """Extract content between two markers"""
    start = text.find(start_marker)
    if start == -1:
        return ""
    start += len(start_marker)
    end = text.find(end_marker, start)
    if end == -1:
        return ""
    return text[start:end].strip()

class AnswerExtractor:
    def __init__(self, task_name):
        """Initialize answer extractor"""
        self.task_name = task_name
    
    def extract_answers(self, response):
        """Extract answers based on task type"""
        try:
            task_extractors = {
                "S_0D": self.extract_S_0D,
                "S_1D": self.extract_S_1D,
                "S_Modification": self.extract_S_Modification,
                "M_Birth": self.extract_M_Birth,
                "M_Merge": self.extract_M_Merge,
                "M_Filtration": self.extract_M_Filtration,
                "H_Selection": self.extract_H_Selection,
                "H_Generation": self.extract_H_Generation,
                "R_Selection": self.extract_R_Selection,
                "R_Generation": self.extract_R_Generation,
                "R_Directly": self.extract_R_Directly
            }
            
            answer = task_extractors.get(self.task_name)(response) if self.task_name in task_extractors else None
            
            return answer
        except Exception as e:
            print(f"Error extracting answer: {str(e)}")
            return None
    
    
    def extract_S_0D(self, answer: str) -> Dict[str, Any]:
        """Extract information from 0-dimensional topology structure identification answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value with more flexible pattern matching
            value_match = re.search(r'connected components:\s*(\d+)', answer_section)
            if not value_match:
                return {"error": "connected components not found"}
            
            # Parse the value
            try:
                value = int(value_match.group(1).strip())
                return {
                    "connected_components": value
                }
            except ValueError as e:
                return {"error": f"Error parsing value: {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        
    def extract_S_1D(self, answer: str) -> Dict[str, Any]:
        """Extract information from 1-dimensional topology structure identification answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value with more flexible pattern matching
            value_match = re.search(r'cycle holes:\s*(\d+)', answer_section)
            if not value_match:
                return {"error": "cycle holes not found"}
            
            # Parse the value
            try:
                value = int(value_match.group(1).strip())
                return {
                    "cycle_holes": value
                }
            except ValueError as e:
                return {"error": f"Error parsing value: {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}


    def extract_S_Modification(self, answer: str) -> Dict[str, Any]:
        """Extract information from graph structure modification answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Try multiple matching patterns
            patterns = [
                r'Edge to add:\s*\[(.*?)\]',  # Match "Edge to add: [0, 7]" format
                r'Edge to add:\s*\((\d+)\s*,\s*(\d+)\)',  # Match "Edge to add: (0, 7)" format
                r'Edge to add:\s*(\d+)\s*-\s*(\d+)',  # Match "Edge to add: 0-7" format
                r'Edge to add:\s*(\d+)\s*,\s*(\d+)'  # Match "Edge to add: 0, 7" format
            ]
            
            for pattern in patterns:
                value_match = re.search(pattern, answer_section)
                if value_match:
                    try:
                        if pattern == r'Edge to add:\s*\[(.*?)\]':
                            # Handle [0, 7] format
                            values_str = value_match.group(1).strip()
                            values = [int(x.strip()) for x in values_str.split(',')]
                        else:
                            # Handle other formats
                            values = [int(value_match.group(1)), int(value_match.group(2))]
                        
                        return {
                            "edge_to_add": values
                        }
                    except (ValueError, IndexError):
                        continue
            
            return {"error": "Edge to add not found or invalid format"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        
        
    def extract_M_Birth(self, answer: str) -> Dict[str, Any]:
        """Extract birth time calculation task answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value
            value_match = re.search(r'birth time:\s*\[(.*?)\]', answer_section)
            if not value_match:
                return {"error": "birth_time not found"}
            
            # Parse the values
            try:
                values = [self._parse_number(x) for x in value_match.group(1).split(',')]
                return {
                    "birth_time": values
                }
            except ValueError as e:
                return {"error": f"Error parsing : {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}

    def extract_M_Merge(self, answer: str) -> Dict[str, Any]:
        """Extract information from 0-dimensional persistent homology calculation task answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value
            value_match = re.search(r'death time:\s*\[(.*?)\]', answer_section)
            if not value_match:
                return {"error": "death_time not found"}
            
            # Parse the values
            try:
                values = [self._parse_number(x) for x in value_match.group(1).split(',')]
                return {
                    "death_time": values
                }
            except ValueError as e:
                return {"error": f"Error parsing : {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        
    def extract_M_Filtration(self,answer:str) -> Dict[str, Any]:
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value
            value_match = re.search(r'connected components:\s*\[(.*?)\]', answer_section)
            if not value_match:
                return {"error": "connected components not found"}
            
            # Parse the values
            try:
                values = [self._parse_number(x) for x in value_match.group(1).split(',')]
                return {
                    "connected_components": values
                }
            except ValueError as e:
                return {"error": f"Error parsing : {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}

    def extract_H_Selection(self, answer: str) -> Dict[str, Any]:
        """Extract selected filtration method from the response"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            # Try multiple matching patterns
            patterns = [
                r'Method:\s*([\w-]+)',  # Match "Method: k-shell" format
                r'Method:\s*\[([\w-]+)\]',  # Match "Method: [k-shell]" format
                r'selected_method:\s*([\w-]+)',  # Match "selected_method: k-shell" format
                r'Selected Method:\s*([\w-]+)'  # Match "Selected Method: k-shell" format
            ]

            for pattern in patterns:
                value_match = re.search(pattern, answer_section, re.IGNORECASE)
                if value_match:
                    method = value_match.group(1).strip().lower()
                    # Validate method name
                    valid_methods = ['degree', 'betweenness', 'k-shell', 'closeness', 'weight', 'eigenvector']
                    if method in valid_methods:
                        return {
                            "selected_method": method
                        }

            return {"error": "Method not found or invalid"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}


    def extract_H_Generation(self, answer: str) -> Dict[str, Any]:
        """Extract information from filteration value selection task answer"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()
            
            # Extract the filtration value
            value_match = re.search(r'filtration value:\s*\[(.*?)\]', answer_section)
            if not value_match:
                return {"error": "Filtration value not found"}
            
            # Parse the values
            try:
                values = [int(x.strip()) for x in value_match.group(1).split(',')]
                return {
                    "selected_filtration_values": values
                }
            except ValueError as e:
                return {"error": f"Error parsing filtration values: {str(e)}"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        
    def extract_filtration_edge_construction(self, answer: str) -> Dict[str, Any]:
        """Extract information from filtration edge construction task answer"""
        result = {
            "filtration": {}
        }
        
        try:
            # Extract filtration process
            filtration_section = _extract_section(answer, "===FILTRATION_START===", "===FILTRATION_END===")
            result["filtration"] = self._parse_filtration_edges(filtration_section)
            
            # Validate results
            if not result["filtration"]:
                print("Warning: Failed to extract filtration process")
                print("Filtration process:", result["filtration"])
            
        except Exception as e:
            import traceback
            print(f"Error during extraction: {str(e)}")
            print("Error details:")
            print(traceback.format_exc())
            return result  # Return partially parsed results instead of None
        
        return result
    
    def extract_simplicial_complex_construction(self, answer: str) -> Dict[str, Any]:
        """
        Extract answer for simplicial_complex_construction task
        
        Parameters:
            answer: Model generated answer text
        
        Returns:
            dict: Contains extracted simplicial complex information
        """
        try:
            # Extract simplicial complex section
            simplex_text = self._extract_section(answer, "===SIMPLICIAL_COMPLEX_START===", "===SIMPLICIAL_COMPLEX_END===")
            if not simplex_text:
                return {"error": "Simplicial complex section not found"}
            
            # Parse simplicial complex
            simplices = {}
            
            for line in simplex_text.split('\n'):
                line = line.strip()
                if not line:
                    continue
                    
                # Check if it's a simplex
                if line.startswith('[') and line.endswith(']'):
                    try:
                        # Parse node list and filtration value
                        content = line[1:-1]  # Remove outer brackets
                        nodes_part, value_part = content.split('),')
                        nodes = [int(x.strip()) for x in nodes_part[1:].split(',')]  # Remove inner brackets
                        value = float(value_part.strip())
                        
                        if len(nodes) == 3:  # Only process 2-dimensional simplices (triangles)
                            if value not in simplices:
                                simplices[value] = []
                            simplices[value].append(nodes)
                    except (ValueError, IndexError) as e:
                        print(f"Error parsing simplex: {line}, error: {str(e)}")
                        continue
            
            return {
                "simplicial_complexes": simplices
            }
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
    
    def _parse_number(self, value_str: str) -> float:
        """Parse number intelligently, try integer first, then float"""
        value_str = value_str.strip()
        try:
            # Try parsing as integer first
            return int(value_str)
        except ValueError:
            try:
                # If integer parsing fails, try parsing as float
                value = float(value_str)
                # If it's an integer (no decimal part), return integer
                if value.is_integer():
                    return int(value)
                return value
            except ValueError:
                raise ValueError(f"Cannot parse number: {value_str}")

    def extract_R_Selection(self, answer: str) -> Dict[str, Any]:
        """Extract selected filtration method from the response"""
        try:
            # Extract the answer section
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()

            # Try multiple matching patterns
            patterns = [
                r'Method:\s*(\w+)',  # Match "Method: weight" format
                r'Method:\s*\[(.*?)\]',  # Match "Method: [weight]" format
                r'selected_method:\s*(\w+)',  # Match "selected_method: weight" format
                r'Selected Method:\s*(\w+)'  # Match "Selected Method: weight" format
            ]

            for pattern in patterns:
                value_match = re.search(pattern, answer_section, re.IGNORECASE)
                if value_match:
                    method = value_match.group(1).strip().lower()
                    # 验证方法名称是否有效
                    valid_methods = ['degree', 'betweenness', 'k-shell', 'closeness', 'weight','eigenvector']
                    if method in valid_methods:
                        return {
                            "selected_method": method
                        }

            return {"error": "Method not found or invalid"}
            
        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
        

    def extract_R_Generation(self, answer: str) -> Dict[str, Any]:
        """Extract filtration values from the response"""
        try:
            # Extract content after "Answer:" if present
            answer_section = answer
            if "Answer:" in answer:
                answer_section = answer.split("Answer:")[-1].strip()

            # Match pattern like Filtration value: [0.1,0.4,0.5,...]
            pattern = r'Filtration\s*value[s]?:\s*\[([^\]]+)\]'
            match = re.search(pattern, answer_section, re.IGNORECASE)
            if not match:
                return {"error": "Filtration values not found"}

            # Extract numbers inside brackets, split by comma and convert to float
            nums_str = match.group(1)
            values: List[float] = []
            for part in nums_str.split(','):
                part = part.strip()
                if part:
                    try:
                        values.append(float(part))
                    except ValueError:
                        return {"error": f"Cannot convert '{part}' to float"}
            
            return {"filtration_values": values}

        except Exception as e:
            return {"error": f"Error during extraction: {str(e)}"}
    
    def extract_R_Directly(self, answer: str) -> Dict[str, Any]:
        """Extract category classification from the response"""
        # Get content after "Answer:" if present
        if "Answer:" in answer:
            answer_section = answer.split("Answer:")[-1].strip()
        else:
            answer_section = answer
        pattern = r'Category:\s*[\[\(]\s*([\d\.\s,]+)[\]\)]\s*,\s*[\[\(]\s*([\d\.\s,]+)[\]\)]'
        match = re.search(pattern, answer_section, re.IGNORECASE | re.DOTALL)
        if not match:
            return {"error": "Category format not found or incorrect"}

        def parse_group(group_str: str) -> List[int]:
            return [int(float(x.strip())) for x in group_str.split(',') if x.strip()]

        category1 = parse_group(match.group(1))
        category2 = parse_group(match.group(2))

        all_indices = sorted(category1 + category2)
        if all_indices != [1, 2, 3, 4]:
            return {"error": f"Graph indices must be [1, 2, 3, 4], got: {all_indices}"}

        return {
            "categories": [category1, category2]
        }

    # def _parse_filtration_edges(self, section: str) -> Dict[float, List[Tuple[int, int]]]:
    #     """Parse filtration process, specific to the format of filtration edge construction task"""
    #     filtration = {}
    #     current_value = None
    #     for line in section.split('\n'):
    #         line = line.strip()
    #         if line.startswith('**Value='):
    #             value_part = line.replace('**', '').replace('Value=', '').strip()
    #             current_value = float(value_part)
    #             filtration[current_value] = []
    #         elif line.startswith('(') and line.endswith(')'):
    #             try:
    #                 u, v = map(int, line[1:-1].split(','))
    #                 filtration[current_value].append((u, v))
    #             except:
    #                 print(f"Cannot parse edge: {line}")
    #     return filtration
    
    
    # def extract_structure_identification(self, answer: str) -> Dict[str, Any]:
    #     """Extract information from topology structure identification answer"""
    #     result = {
    #         "cavities": [],
    #         "temporal_evolution": {}
    #     }
        
    #     # Extract cavity information
    #     if "2-DIMENSIONAL CAVITIES:" in answer:
    #         cavities_section = self._extract_section(
    #             answer, "2-DIMENSIONAL CAVITIES:", "TEMPORAL EVOLUTION:"
    #         )
    #         result["cavities"] = self._extract_cavities(cavities_section)
        
    #     # Extract temporal evolution
    #     if "TEMPORAL EVOLUTION:" in answer:
    #         evolution_section = answer.split("TEMPORAL EVOLUTION:")[1]
    #         result["temporal_evolution"] = self._extract_temporal_evolution(evolution_section)
        
    #     return result
    

    # def extract_simplex_structure_identification(self, answer: str) -> Dict[str, Any]:
    #     """Extract information from simplex structure identification answer"""
    #     result = {
    #         "simplex_count": 0
    #     }
        
    #     lines = answer.strip().split('\n')
    #     for line in lines:
    #         line = line.strip()
    #         if line.startswith('2维单纯形数量：'):
    #             count_str = line.split('：')[1].strip()
    #             try:
    #                 result["simplex_count"] = int(count_str)
    #             except ValueError:
    #                 # Keep default value 0 if cannot parse as integer
    #                 pass
        
    #     return result
    
    # def _extract_section(self, text: str, start_marker: str, end_marker: str) -> str:
    #     """Extract text between two markers"""
    #     if start_marker in text and end_marker in text:
    #         start_idx = text.find(start_marker) + len(start_marker)
    #         end_idx = text.find(end_marker)
    #         return text[start_idx:end_idx].strip()
    #     return ""
    
    

    
    # def _extract_list(self, text: str) -> List:
    #     """Extract list from text"""
    #     items = text.split(':')[1].strip()
    #     if items.startswith('[') and items.endswith(']'):
    #         return eval(items)
    #     return []
    
    # def _extract_feature_info(self, line: str) -> Dict[str, Any]:
    #     """Extract feature information from text"""
    #     info = {}
    #     if 'Birth time:' in line:
    #         info['birth'] = float(line.split(':')[1].strip())
    #     elif 'Death time:' in line:
    #         info['death'] = float(line.split(':')[1].strip())
    #     elif 'Persistence:' in line:
    #         info['persistence'] = float(line.split(':')[1].strip())
    #     elif 'Description:' in line:
    #         info['description'] = line.split(':')[1].strip()
    #     return info

    
    # def _extract_cavities(self, text: str) -> List[Dict[str, Any]]:
    #     """Extract cavity information"""
    #     cavities = []
    #     current_cavity = None
        
    #     for line in text.split('\n'):
    #         if line.startswith('Cavity'):
    #             if current_cavity:
    #                 cavities.append(current_cavity)
    #             current_cavity = {}
    #         elif current_cavity is not None and line.startswith('-'):
    #             key = line.split(':')[0].strip('- ').lower()
    #             value = line.split(':')[1].strip()
    #             if key in ['birth threshold', 'death threshold', 'persistence']:
    #                 value = float(value)
    #             elif key in ['nodes', 'edges']:
    #                 value = eval(value)
    #             current_cavity[key] = value
        
    #     if current_cavity:
    #         cavities.append(current_cavity)
        
    #     return cavities
    
    # def _extract_temporal_evolution(self, text: str) -> Dict[float, Dict[str, List[int]]]:
    #     """Extract temporal evolution information"""
    #     evolution = {}
    #     current_threshold = None
        
    #     for line in text.split('\n'):
    #         if line.startswith('Threshold'):
    #             current_threshold = float(line.split()[1])
    #             evolution[current_threshold] = {
    #                 'active': [],
    #                 'new': [],
    #                 'disappeared': []
    #             }
    #         elif current_threshold is not None and line.startswith('-'):
    #             key = line.split(':')[0].strip('- ').lower()
    #             value = eval(line.split(':')[1].strip())
    #             evolution[current_threshold][key] = value
        
    #     return evolution
    
    # def _extract_current_state(self, text: str) -> Dict[str, Any]:
    #     """Extract current state information"""
    #     state = {}
    #     for line in text.split('\n'):
    #         if line.startswith('- Number of cycles:'):
    #             state['cycles'] = int(line.split(':')[1].strip())
    #         elif line.startswith('- Cycle locations:'):
    #             state['locations'] = eval(line.split(':')[1].strip())
    #     return state
    
    # def _extract_proposed_modifications(self, text: str) -> List[Dict[str, Any]]:
    #     """Extract proposed modifications"""
    #     modifications = []
    #     current_mod = None
        
    #     for line in text.split('\n'):
    #         if line.startswith('Modification'):
    #             if current_mod:
    #                 modifications.append(current_mod)
    #             current_mod = {}
    #         elif current_mod is not None and line.startswith('-'):
    #             key = line.split(':')[0].strip('- ').lower()
    #             value = line.split(':')[1].strip()
    #             if key == 'new edge':
    #                 value = tuple(map(int, value.split('-')))
    #             elif key == 'expected new cycles':
    #                 value = eval(value)
    #             current_mod[key] = value
        
    #     if current_mod:
    #         modifications.append(current_mod)
        
    #     return modifications
    
    # def _extract_expected_outcome(self, text: str) -> Dict[str, Any]:
    #     """Extract expected outcome"""
    #     outcome = {}
    #     for line in text.split('\n'):
    #         if line.startswith('- New number of cycles:'):
    #             outcome['new_cycles'] = int(line.split(':')[1].strip())
    #         elif line.startswith('- New cycle locations:'):
    #             outcome['new_locations'] = eval(line.split(':')[1].strip())
    #         elif line.startswith('- Changes in persistence:'):
    #             outcome['persistence_changes'] = line.split(':')[1].strip()
    #     return outcome