Update app.py

app.py

@@ -11,6 +11,7 @@ class PropertyFormulaAnalyzer:
         """Initialize the analyzer with the formula file path"""
         self.formula_file_path = formula_file_path
         self.formulas = {}
+        self.computed_values = {}  # Store computed values for cascading calculations
         self.load_formulas()
     
     def load_formulas(self):
@@ -20,13 +21,11 @@ class PropertyFormulaAnalyzer:
                 content = f.read()
             
             # Parse formulas using regex
-            # Pattern: number. cell_ref (description) = formula
             pattern = r'(\d+)\.\s+([A-Z]+\d+)\s*\(([^)]+)\)\s*=\s*([^=\n]+?)(?=\s+\d+\.|$)'
             matches = re.findall(pattern, content, re.DOTALL)
             
             for match in matches:
                 formula_num, cell_ref, description, formula = match
-                # Clean up the formula
                 formula = formula.strip()
                 formula = re.sub(r'\s+', ' ', formula)
                 
@@ -75,26 +74,19 @@ class PropertyFormulaAnalyzer:
             else:
                 combined_text += self.extract_text_from_txt(file_path) + "\n"
         
-        # Extract data using comprehensive patterns
         extracted_data = {}
         
         # Define extraction patterns
         patterns = {
-            # Basic property info
             'UNITS': [r'(?:Total\s+)?Units?\s*:?\s*(\d+)', r'Units\s*(\d+)'],
             'BUILDING_SF': [r'Building\s+(?:Size|SF)\s*:?\s*([\d,]+)', r'Building\s+(?:Size|SF)\s*(\d+)'],
             'LOT_ACRES': [r'Lot\s+Size\s*:?\s*([\d.]+)\s*(?:acres?|Acres?)', r'Lot:\s*([\d.]+)\s*acres?'],
-            'LOT_SF': [r'Lot\s+(?:Size\s+)?SF\s*:?\s*([\d,]+)'],
-            
-            # Financial metrics
             'PRICE': [r'(?:Asking\s+)?Price\s*:?\s*\$\s*([\d,]+)', r'Price\s+per\s+Unit\s*\$\s*([\d,]+)'],
             'NOI': [r'Net\s+Operating\s+Income\s*(?:\(NOI\))?\s*:?\s*\$?\s*([\d,]+)', r'NOI\s*:?\s*\$?\s*([\d,]+)'],
             'EGI': [r'Effective\s+Gross\s+Income\s*:?\s*\$?\s*([\d,]+)', r'EGI\s*:?\s*\$?\s*([\d,]+)'],
             'GPR': [r'Gross\s+Potential\s+Rent\s*(?:\(Annual\))?\s*:?\s*\$?\s*([\d,]+)', r'GPR\s*:?\s*\$?\s*([\d,]+)'],
             'OPEX': [r'Operating\s+Expenses\s*:?\s*\$?\s*([\d,]+)', r'Total\s+Operating\s+Expenses\s*=?\s*\$?\s*([\d,]+)'],
             'VACANCY': [r'Vacancy\s*(?:\([\d.]+%\))?\s*:?\s*-?\$?\s*([\d,]+)'],
-            
-            # Operating expenses categories
             'PROPERTY_TAXES': [r'Property\s+Taxes\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'INSURANCE': [r'Insurance\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'UTILITIES': [r'Utilities\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
@@ -104,38 +96,21 @@ class PropertyFormulaAnalyzer:
             'MARKETING': [r'Marketing\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'REPLACEMENT_RESERVES': [r'Replacement\s+Reserves\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
             'MANAGEMENT_FEE': [r'Management\s*(?:\([^)]+\))?\s*:?\s*\$?\s*([\d,]+\.?\d*)'],
-            
-            # Rates and percentages
             'CAP_RATE': [r'Cap\s+Rate\s*:?\s*([\d.]+)%?', r'Cap\s+Rate\s+([\d.]+)'],
             'INTEREST_RATE': [r'Interest\s+Rate\s*:?\s*([\d.]+)%?'],
             'LTC': [r'Loan[- ]to[- ]Cost\s*(?:\(LTC\))?\s*:?\s*([\d.]+)%?'],
             'EXIT_CAP_RATE': [r'Exit\s+Cap\s+Rate\s*:?\s*([\d.]+)%?'],
-            
-            # Demographics
-            'MEDIAN_INCOME': [r'Median\s+(?:HH\s+)?Income\s*:?\s*\$?\s*([\d,]+)', r'Median\s+(?:Household\s+)?Income:\s*\$?\s*([\d,]+)'],
+            'MEDIAN_INCOME': [r'Median\s+(?:HH\s+)?Income\s*:?\s*\$?\s*([\d,]+)'],
             'POPULATION': [r'Population\s*:?\s*([\d,]+)'],
             'HOUSEHOLDS': [r'Households\s*:?\s*([\d,]+)'],
             'RENTER_OCCUPIED_PCT': [r'Renter[- ]Occupied\s*:?\s*([\d.]+)%?'],
-            
-            # Construction & Development
-            'CONSTRUCTION_GMP': [r'(?:Total\s+)?Construction\s+GMP\s*:?\s*\$?\s*([\d,]+)'],
-            'SOFT_COSTS': [r'(?:Total\s+)?Soft\s+Costs?\s*:?\s*\$?\s*([\d,]+)'],
-            'CONTINGENCY': [r'Contingency\s*:?\s*\$?\s*([\d,]+)'],
-            'DEV_FEE': [r'Dev(?:elopment)?\s+Fee\s*:?\s*\$?\s*([\d,]+)'],
-            
-            # Land & Acquisition
-            'LAND_VALUE': [r'(?:Total\s+)?Land\s+Value\s*:?\s*\$?\s*([\d,]+)'],
-            'CLOSING_COSTS': [r'Closing\s+Costs\s*:?\s*\$?\s*([\d,]+)'],
-            'ACQ_FEE': [r'Acq(?:uisition)?\s+Fee\s*:?\s*\$?\s*([\d,]+)'],
         }
         
-        # Extract values using patterns
         for key, pattern_list in patterns.items():
             for pattern in pattern_list:
                 matches = re.findall(pattern, combined_text, re.IGNORECASE)
                 if matches:
                     try:
-                        # Take the first match and clean it
                         value_str = matches[0].replace(',', '').strip()
                         value = float(value_str)
                         extracted_data[key] = value
@@ -143,7 +118,7 @@ class PropertyFormulaAnalyzer:
                     except (ValueError, IndexError):
                         continue
         
-        # Calculate derived values
+        # Derived values
         if 'PRICE' in extracted_data and 'UNITS' in extracted_data:
             extracted_data['PRICE_PER_UNIT'] = extracted_data['PRICE'] / extracted_data['UNITS']
         
@@ -151,63 +126,64 @@ class PropertyFormulaAnalyzer:
             extracted_data['CALCULATED_CAP_RATE'] = (extracted_data['NOI'] / extracted_data['PRICE']) * 100
         
         if 'LTC' in extracted_data and extracted_data['LTC'] > 1:
-            extracted_data['LTC'] = extracted_data['LTC'] / 100  # Convert percentage
+            extracted_data['LTC'] = extracted_data['LTC'] / 100
         
         if 'INTEREST_RATE' in extracted_data and extracted_data['INTEREST_RATE'] > 1:
             extracted_data['INTEREST_RATE'] = extracted_data['INTEREST_RATE'] / 100
         
-        # Add common cell references based on extracted data
+        # Map to cell references
         if 'BUILDING_SF' in extracted_data:
             extracted_data['D2'] = extracted_data['BUILDING_SF']
-            extracted_data['D$2'] = extracted_data['BUILDING_SF']
-            extracted_data['$D$2'] = extracted_data['BUILDING_SF']
         
         if 'UNITS' in extracted_data:
             extracted_data['F2'] = extracted_data['UNITS']
-            extracted_data['F$2'] = extracted_data['UNITS']
-            extracted_data['$F$2'] = extracted_data['UNITS']
         
-        # Assume RSF is 90% of GSF if not provided
-        if 'BUILDING_SF' in extracted_data and 'E2' not in extracted_data:
+        if 'BUILDING_SF' in extracted_data:
             extracted_data['E2'] = extracted_data['BUILDING_SF'] * 0.9
-            extracted_data['E$2'] = extracted_data['E2']
-            extracted_data['$E$2'] = extracted_data['E2']
-        
-        # Map common variables
-        if 'LAND_VALUE' in extracted_data:
-            extracted_data['C4'] = extracted_data['LAND_VALUE']
-            extracted_data['$C4'] = extracted_data['LAND_VALUE']
-            extracted_data['$C$4'] = extracted_data['LAND_VALUE']
-        
-        if 'CLOSING_COSTS' in extracted_data:
-            extracted_data['C5'] = extracted_data['CLOSING_COSTS']
-            extracted_data['$C5'] = extracted_data['CLOSING_COSTS']
         
         if 'OPEX' in extracted_data:
             extracted_data['M15'] = extracted_data['OPEX']
-            extracted_data['$M$15'] = extracted_data['OPEX']
         
         if 'EGI' in extracted_data:
             extracted_data['J38'] = extracted_data['EGI']
-            extracted_data['$J$38'] = extracted_data['EGI']
         
         return extracted_data
     
+    def normalize_cell_ref(self, cell_ref: str) -> str:
+        """Normalize cell reference by removing $ signs"""
+        return cell_ref.replace('$', '')
+    
+    def get_value(self, var: str, data: Dict[str, Any]) -> Any:
+        """Get value for a variable, handling all variants"""
+        # Try exact match
+        if var in data:
+            return data[var]
+        
+        # Try normalized (without $)
+        normalized = self.normalize_cell_ref(var)
+        if normalized in data:
+            return data[normalized]
+        
+        # Try with computed values
+        if var in self.computed_values:
+            return self.computed_values[var]
+        
+        if normalized in self.computed_values:
+            return self.computed_values[normalized]
+        
+        return None
+    
     def extract_variables_from_formula(self, formula: str) -> List[str]:
         """Extract all variable references from a formula"""
         # Match Excel-style cell references (e.g., C4, $D$2, E2)
         cell_pattern = r'\$?[A-Z]+\$?\d+'
         variables = re.findall(cell_pattern, formula)
         
-        # Also match named variables
-        named_pattern = r'[A-Z_][A-Z0-9_]*'
-        named_vars = re.findall(named_pattern, formula)
-        
-        # Filter out Excel functions
+        # Remove Excel functions and operators
         excel_functions = {'SUM', 'PV', 'MIN', 'MAX', 'AVERAGE', 'IF', 'AND', 'OR'}
-        named_vars = [v for v in named_vars if v not in excel_functions]
+        variables = [v for v in variables if v not in excel_functions]
         
-        return list(set(variables + named_vars))
+        return list(set(variables))
     
     def check_formula_computable(self, formula: str, data: Dict[str, Any]) -> Tuple[bool, List[str]]:
         """Check if a formula can be computed with available data"""
@@ -215,63 +191,62 @@ class PropertyFormulaAnalyzer:
         missing = []
         
         for var in variables:
-            # Check all variants of the variable
-            variants = [var, var.replace('$', ''), var.upper()]
-            if not any(v in data for v in variants):
+            if self.get_value(var, data) is None:
                 missing.append(var)
         
         return len(missing) == 0, missing
     
-    def evaluate_formula(self, formula: str, data: Dict[str, Any]) -> Any:
+    def safe_eval_formula(self, formula: str, data: Dict[str, Any]) -> Any:
         """Safely evaluate a formula with the provided data"""
         try:
-            # Create a safe evaluation environment
-            safe_dict = {}
-            
-            # Add all data to the environment
-            for key, value in data.items():
-                safe_dict[key] = value
-                safe_dict[key.replace('$', '')] = value
-                safe_dict[key.upper()] = value
-            
-            # Replace Excel functions with Python equivalents
             formula_py = formula
             
-            # Handle SUM function
-            sum_pattern = r'SUM\(([^)]+)\)'
-            while re.search(sum_pattern, formula_py):
-                match = re.search(sum_pattern, formula_py)
+            # Handle SUM function with ranges
+            def process_sum_range(match):
                 range_str = match.group(1)
-                # For ranges like C4:C6, we'll need to handle them
                 if ':' in range_str:
-                    # Extract the range
-                    parts = range_str.split(':')
-                    # For now, we'll just try to add the values if they exist
-                    formula_py = formula_py.replace(match.group(0), f"sum_range('{range_str}')")
+                    # For now, return 0 for ranges we can't process
+                    return '0'
                 else:
-                    formula_py = formula_py.replace(match.group(0), f"sum([{range_str}])")
+                    # Individual cells
+                    cells = [c.strip() for c in range_str.split(',')]
+                    values = []
+                    for cell in cells:
+                        val = self.get_value(cell, data)
+                        if val is not None:
+                            values.append(str(val))
+                    if values:
+                        return f"({'+'.join(values)})"
+                    return '0'
+            
+            sum_pattern = r'SUM\(([^)]+)\)'
+            formula_py = re.sub(sum_pattern, process_sum_range, formula_py)
             
-            # Handle PV function (present value) - simplified
-            pv_pattern = r'PV\([^)]+\)'
-            formula_py = re.sub(pv_pattern, '0', formula_py)  # Simplified for now
+            # Handle PV function - simplified to 0
+            formula_py = re.sub(r'PV\([^)]+\)', '0', formula_py)
             
             # Handle MIN function
             formula_py = re.sub(r'MIN\(([^)]+)\)', r'min([\1])', formula_py)
             
             # Replace cell references with their values
-            for key in sorted(data.keys(), key=len, reverse=True):
-                if key in formula_py:
-                    formula_py = formula_py.replace(key, str(data[key]))
+            variables = self.extract_variables_from_formula(formula_py)
+            for var in sorted(variables, key=len, reverse=True):
+                value = self.get_value(var, data)
+                if value is not None:
+                    formula_py = formula_py.replace(var, str(value))
             
             # Replace ^ with ** for exponentiation
             formula_py = formula_py.replace('^', '**')
             
+            # Clean up any remaining issues
+            formula_py = formula_py.replace('--', '+')
+            
             # Evaluate
-            result = eval(formula_py, {"__builtins__": {}}, safe_dict)
+            result = eval(formula_py, {"__builtins__": {"min": min, "max": max, "sum": sum}}, {})
             return result
             
         except Exception as e:
-            raise Exception(f"Error evaluating formula: {str(e)}")
+            raise Exception(f"Error evaluating formula '{formula}': {str(e)}")
     
     def process_files(self, files) -> Tuple[str, str, str]:
         """Main processing function for Gradio interface"""
@@ -279,45 +254,79 @@ class PropertyFormulaAnalyzer:
             if not files:
                 return "❌ No files uploaded", "", ""
             
-            # Extract file paths
             file_paths = [f.name for f in files]
             
-            # Extract data from all files
+            # Extract data
             extracted_data = self.extract_data_from_files(file_paths)
             
             if not extracted_data:
                 return "❌ No data could be extracted from the files", "", ""
             
-            # Process formulas
+            # Reset computed values
+            self.computed_values = {}
+            
+            # Multiple passes to handle dependencies
+            max_iterations = 5
             computable_formulas = {}
             non_computable_formulas = {}
             
-            for cell_ref, formula_info in self.formulas.items():
-                formula = formula_info['formula']
-                is_computable, missing_vars = self.check_formula_computable(formula, extracted_data)
+            for iteration in range(max_iterations):
+                newly_computed = 0
                 
-                if is_computable:
-                    try:
-                        result = self.evaluate_formula(formula, extracted_data)
-                        computable_formulas[cell_ref] = {
-                            'description': formula_info['description'],
-                            'formula': formula,
-                            'result': result,
-                            'formatted_result': f"{result:,.2f}" if isinstance(result, (int, float)) else str(result)
-                        }
-                    except Exception as e:
+                for cell_ref, formula_info in self.formulas.items():
+                    # Skip if already computed
+                    if cell_ref in computable_formulas:
+                        continue
+                    
+                    formula = formula_info['formula']
+                    
+                    # Combine extracted data with computed values for checking
+                    all_data = {**extracted_data, **self.computed_values}
+                    
+                    is_computable, missing_vars = self.check_formula_computable(formula, all_data)
+                    
+                    if is_computable:
+                        try:
+                            result = self.safe_eval_formula(formula, all_data)
+                            
+                            # Store result
+                            computable_formulas[cell_ref] = {
+                                'description': formula_info['description'],
+                                'formula': formula,
+                                'result': result,
+                                'formatted_result': f"{result:,.2f}" if isinstance(result, (int, float)) else str(result),
+                                'iteration': iteration + 1
+                            }
+                            
+                            # Add to computed values for cascading
+                            self.computed_values[cell_ref] = result
+                            self.computed_values[self.normalize_cell_ref(cell_ref)] = result
+                            
+                            newly_computed += 1
+                            
+                        except Exception as e:
+                            non_computable_formulas[cell_ref] = {
+                                'description': formula_info['description'],
+                                'formula': formula,
+                                'error': str(e),
+                                'missing_variables': []
+                            }
+                    else:
                         non_computable_formulas[cell_ref] = {
                             'description': formula_info['description'],
                             'formula': formula,
-                            'error': str(e),
-                            'missing_variables': []
+                            'missing_variables': missing_vars
                         }
-                else:
-                    non_computable_formulas[cell_ref] = {
-                        'description': formula_info['description'],
-                        'formula': formula,
-                        'missing_variables': missing_vars
-                    }
+                
+                print(f"Iteration {iteration + 1}: Computed {newly_computed} new formulas")
+                
+                # If no new formulas computed, stop
+                if newly_computed == 0:
+                    break
+            
+            # Remove successfully computed formulas from non-computable list
+            for cell_ref in computable_formulas.keys():
+                non_computable_formulas.pop(cell_ref, None)
             
             # Create summary
             summary = f"""
@@ -328,6 +337,7 @@ class PropertyFormulaAnalyzer:
 **❌ Non-Computable Formulas:** {len(non_computable_formulas)}
 **📄 Files Processed:** {len(file_paths)}
 **🔢 Data Points Extracted:** {len(extracted_data)}
+**🔄 Computation Iterations:** {iteration + 1}
 """
             
             # Create extracted data display
@@ -344,15 +354,20 @@ class PropertyFormulaAnalyzer:
             for cell_ref, info in sorted(computable_formulas.items()):
                 results_display += f"### {cell_ref}: {info['description']}\n"
                 results_display += f"**Formula:** `{info['formula']}`\n"
-                results_display += f"**Result:** {info['formatted_result']}\n\n"
+                results_display += f"**Result:** {info['formatted_result']}\n"
+                results_display += f"*Computed in iteration {info['iteration']}*\n\n"
             
             # if non_computable_formulas:
             #     results_display += "\n## ❌ Non-Computable Formulas\n\n"
-            #     for cell_ref, info in sorted(non_computable_formulas.items()):
+            #     # Show only first 20 to avoid overwhelming output
+            #     for idx, (cell_ref, info) in enumerate(sorted(non_computable_formulas.items())):
+            #         if idx >= 20:
+            #             results_display += f"\n*... and {len(non_computable_formulas) - 20} more non-computable formulas*\n"
+            #             break
             #         results_display += f"### {cell_ref}: {info['description']}\n"
             #         results_display += f"**Formula:** `{info['formula']}`\n"
             #         if info.get('missing_variables'):
-            #             results_display += f"**Missing Variables:** {', '.join(info['missing_variables'])}\n"
+            #             results_display += f"**Missing Variables:** {', '.join(info['missing_variables'][:5])}\n"
             #         if info.get('error'):
             #             results_display += f"**Error:** {info['error']}\n"
             #         results_display += "\n"
@@ -363,7 +378,8 @@ class PropertyFormulaAnalyzer:
                     'total_formulas': len(self.formulas),
                     'computable': len(computable_formulas),
                     'non_computable': len(non_computable_formulas),
-                    'files_processed': len(file_paths)
+                    'files_processed': len(file_paths),
+                    'iterations': iteration + 1
                 },
                 'extracted_data': extracted_data,
                 'computable_formulas': computable_formulas,
@@ -387,7 +403,7 @@ with gr.Blocks(title="Property Formula Analyzer", theme=gr.themes.Soft()) as app
     # 🏢 Property Formula Analyzer
     
     Upload property documents (PDF or TXT) to automatically extract data and compute real estate formulas.
-    The system will analyze your documents and calculate all computable formulas based on the extracted data.
+    The system uses iterative computation to handle formula dependencies.
     """)
     
     with gr.Row():
@@ -407,6 +423,8 @@ with gr.Blocks(title="Property Formula Analyzer", theme=gr.themes.Soft()) as app
             2. Click "Analyze & Compute Formulas"
             3. Review the extracted data and computed formulas
             4. Download the JSON results for further analysis
+            
+            **Note:** The system performs multiple computation passes to handle formula dependencies.
             """)
     
     with gr.Row():
@@ -425,7 +443,6 @@ with gr.Blocks(title="Property Formula Analyzer", theme=gr.themes.Soft()) as app
                 lines=20
             )
     
-    # Connect the button to the processing function
     analyze_btn.click(
         fn=analyzer.process_files,
         inputs=[file_input],
@@ -435,8 +452,8 @@ with gr.Blocks(title="Property Formula Analyzer", theme=gr.themes.Soft()) as app
     gr.Markdown("""
     ---
     ### 📝 Notes:
-    - The system automatically extracts property metrics like units, price, NOI, operating expenses, etc.
-    - Formulas are computed only when all required variables are available in the extracted data
+    - The system automatically extracts property metrics from your documents
+    - Formulas are computed iteratively to handle dependencies between formulas
     - Non-computable formulas are listed with their missing variables
     - All results can be downloaded as JSON for further processing
     """)