app.py

import gradio as gr
import pandas as pd
from continuous_beam import ContinuousBeam
import matplotlib.pyplot as plt
import numpy as np
import io
import base64
import gc  # Garbage collection for memory management
import warnings
warnings.filterwarnings('ignore')  # Suppress warnings for cleaner output

# Configure matplotlib for cloud deployment
plt.style.use('default')  # Use simple style
plt.rcParams['figure.max_open_warning'] = 0  # Disable figure warnings

class GradioBeamApp:
    def __init__(self):
        self.beam = ContinuousBeam()
        self.spans_data = []
    
    def parse_point_loads(self, point_loads_text):
        """Parse point loads from text input"""
        if not point_loads_text or point_loads_text.strip() == "":
            return []
        
        point_loads = []
        try:
            # Expected format: "position1,load1; position2,load2; ..."
            # Example: "2.0,50; 4.0,30"
            load_pairs = point_loads_text.split(';')
            for pair in load_pairs:
                if pair.strip():
                    pos_str, load_str = pair.split(',')
                    position = float(pos_str.strip())
                    load = float(load_str.strip())
                    point_loads.append((position, load))
        except:
            raise ValueError("Invalid point load format. Use: position1,load1; position2,load2")
        
        return point_loads
    
    def add_span(self, length, distributed_load, point_loads_text, spans_display):
        """Add a span to the beam"""
        try:
            length = float(length)
            distributed_load = float(distributed_load)
            
            if length <= 0 or distributed_load < 0:
                return spans_display, "Error: Please enter valid values (length > 0, distributed_load >= 0)"
            
            # Parse point loads
            point_loads = self.parse_point_loads(point_loads_text)
            
            # Validate point load positions
            for pos, load in point_loads:
                if pos < 0 or pos > length:
                    return spans_display, f"Error: Point load at {pos}m is outside span length {length}m"
                if load < 0:
                    return spans_display, f"Error: Point load {load}kN must be positive"
            
            self.beam.add_span(length, distributed_load, point_loads)
            
            # Create span description
            span_info = f"Span {len(self.beam.spans)}: L={length}m, w={distributed_load}kN/m"
            if point_loads:
                point_load_str = ", ".join([f"P={load}kN@{pos}m" for pos, load in point_loads])
                span_info += f", {point_load_str}"
            
            self.spans_data.append(span_info)
            
            # Update display
            updated_display = "\n".join(self.spans_data)
            return updated_display, f"Added: {span_info}"
            
        except ValueError as e:
            return spans_display, f"Error: {str(e)}"
    
    def clear_spans(self):
        """Clear all spans"""
        self.beam = ContinuousBeam()
        self.spans_data = []
        return "", "All spans cleared"
    
    def design_beam(self, width, depth, fc, fy, cover, spans_display):
        """Design the beam and return results"""
        if not self.beam.spans:
            return "No spans added. Please add at least one span.", None, None, None, None, None
        
        try:
            # Limit spans for cloud deployment
            if len(self.beam.spans) > 10:
                return "Error: Maximum 10 spans allowed for cloud deployment.", None, None, None, None, "Error: Too many spans"
            
            # Update beam properties
            self.beam.beam_width = float(width)
            self.beam.beam_depth = float(depth)
            self.beam.fc = float(fc)
            self.beam.fy = float(fy)
            self.beam.cover = float(cover)
            self.beam.d = self.beam.beam_depth - self.beam.cover
            
            # Perform design with timeout protection
            design_results = self.beam.design_beam()
            
            # Generate report
            report = self.beam.generate_report(design_results)
            
            # Create summary table
            summary_data = []
            for span_data in design_results:
                span_num = span_data['span']
                for i, (reinf, stirrup) in enumerate(zip(span_data['reinforcement'], span_data['stirrups'])):
                    if reinf['moment'] != 0 or stirrup['shear'] != 0:
                        summary_data.append([
                            span_num if i == 0 else '',
                            reinf['location'],
                            f"{reinf['moment']:.2f}" if reinf['moment'] != 0 else '-',
                            reinf['bars'] if reinf['moment'] != 0 else '-',
                            f"{stirrup['shear']:.2f}" if stirrup['shear'] != 0 else '-',
                            stirrup['stirrup_spacing'] if stirrup['shear'] != 0 else '-'
                        ])
            
            # Create DataFrame for table display
            df = pd.DataFrame(summary_data, columns=[
                'Span', 'Location', 'Moment (kN-m)', 'Reinforcement', 'Shear (kN)', 'Stirrups'
            ])
            
            # Generate plots with error handling
            try:
                bmd_sfd_plot = self.beam.plot_bmd_sfd(design_results)
                reinforcement_plot = self.beam.plot_reinforcement_layout(design_results)
                stirrup_plot = self.beam.plot_stirrup_layout(design_results)
            except Exception as plot_error:
                print(f"Plotting error: {plot_error}")
                # Return simplified results if plotting fails
                return report, df, None, None, None, "Design completed (plots unavailable)"
            
            # Force garbage collection to free memory
            gc.collect()
            
            return report, df, bmd_sfd_plot, reinforcement_plot, stirrup_plot, "Design completed successfully!"
            
        except Exception as e:
            gc.collect()  # Clean up memory on error
            error_msg = str(e)
            if "memory" in error_msg.lower() or "allocation" in error_msg.lower():
                return "Error: Insufficient memory. Try reducing the number of spans or load complexity.", None, None, None, None, "Memory Error"
            return f"Design calculation failed: {error_msg}", None, None, None, None, f"Error: {error_msg}"

def create_interface():
    app = GradioBeamApp()
    
    with gr.Blocks(title="Continuous Beam RC Design - Thai Standards", theme=gr.themes.Default()) as interface:
        
        gr.Markdown("# Continuous Beam RC Design - Thai Standards")
        gr.Markdown("*Using Finite Element Analysis with Thai reinforcement standards (DB bars, RB stirrups)*")
        
        with gr.Row():
            with gr.Column(scale=1):
                gr.Markdown("## Beam Properties")
                
                with gr.Row():
                    width_input = gr.Number(label="Beam Width (mm)", value=300)
                    depth_input = gr.Number(label="Beam Depth (mm)", value=500)
                
                with gr.Row():
                    fc_input = gr.Number(label="f'c (ksc)", value=280)
                    fy_input = gr.Number(label="fy (ksc)", value=4000)
                
                cover_input = gr.Number(label="Cover (mm)", value=40)
                
                gr.Markdown("## Spans Configuration")
                
                with gr.Row():
                    span_length_input = gr.Number(label="Span Length (m)", value=6.0)
                    distributed_load_input = gr.Number(label="Distributed Load (kN/m)", value=25.0)
                
                point_loads_input = gr.Textbox(
                    label="Point Loads (position,load; position,load; ...)", 
                    placeholder="Example: 2.0,50; 4.0,30 (means 50kN at 2m and 30kN at 4m)",
                    value=""
                )
                
                with gr.Row():
                    add_span_btn = gr.Button("Add Span", variant="primary")
                    clear_spans_btn = gr.Button("Clear All", variant="secondary")
                
                spans_display = gr.Textbox(
                    label="Added Spans", 
                    lines=5, 
                    interactive=False,
                    placeholder="No spans added yet..."
                )
                
                design_btn = gr.Button("Design Beam", variant="primary", size="lg")
                
                status_output = gr.Textbox(label="Status", interactive=False)
            
            with gr.Column(scale=2):
                gr.Markdown("## Design Results")
                
                with gr.Tabs():
                    with gr.TabItem("Summary"):
                        summary_table = gr.Dataframe(
                            label="Design Summary",
                            headers=["Span", "Location", "Moment (kN-m)", "Reinforcement", "Shear (kN)", "Stirrups"],
                            interactive=False
                        )
                    
                    with gr.TabItem("BMD & SFD"):
                        bmd_sfd_plot = gr.Plot(label="Bending Moment and Shear Force Diagrams")
                    
                    with gr.TabItem("Reinforcement Layout"):
                        reinforcement_plot = gr.Plot(label="Reinforcement Bar Layout")
                    
                    with gr.TabItem("Stirrup Layout"):
                        stirrup_plot = gr.Plot(label="Shear Stirrup Layout")
                    
                    with gr.TabItem("Detailed Report"):
                        results_output = gr.Textbox(
                            label="Detailed Design Report", 
                            lines=20, 
                            interactive=False,
                            show_copy_button=True
                        )
        
        # Event handlers
        add_span_btn.click(
            fn=lambda length, dist_load, point_loads, spans: app.add_span(length, dist_load, point_loads, spans),
            inputs=[span_length_input, distributed_load_input, point_loads_input, spans_display],
            outputs=[spans_display, status_output]
        )
        
        clear_spans_btn.click(
            fn=lambda: app.clear_spans(),
            outputs=[spans_display, status_output]
        )
        
        design_btn.click(
            fn=lambda w, d, fc, fy, c, spans: app.design_beam(w, d, fc, fy, c, spans),
            inputs=[width_input, depth_input, fc_input, fy_input, cover_input, spans_display],
            outputs=[results_output, summary_table, bmd_sfd_plot, reinforcement_plot, stirrup_plot, status_output]
        )
    
    return interface

def main():
    interface = create_interface()
    # Optimized for Hugging Face Spaces
    interface.launch(
        share=False,
        debug=False,  # Disable debug for production
        show_error=True,
        quiet=True,   # Reduce console output
        ssr_mode=False,  # Disable SSR for compatibility
        auth=None,    # No authentication required
        max_threads=10  # Limit concurrent threads
    )

if __name__ == "__main__":
    main()