SOLUTION: Replace Gradio with Streamlit

- Gradio had persistent dependency conflicts with huggingface_hub
- Streamlit is much simpler and more reliable for deployment
- Same interactive functionality with faster startup
- Clean interface with sidebar controls
- Only 3 dependencies: streamlit, numpy, matplotlib

Dockerfile

@@ -8,4 +8,4 @@ RUN pip install --no-cache-dir --upgrade pip && \
 
 COPY . .
 
-CMD ["python", "app.py"]
+CMD ["streamlit", "run", "app.py", "--server.port=7860"]

app.py

@@ -1,8 +1,6 @@
-import gradio as gr
+import streamlit as st
 import numpy as np
 import matplotlib.pyplot as plt
-from io import BytesIO
-import base64
 import time
 
 def simple_simulation(mode, nx, delta, with_perturbation):
@@ -62,43 +60,44 @@ def simple_simulation(mode, nx, delta, with_perturbation):
         
         plt.tight_layout()
         
-        # Convertir en image
-        buf = BytesIO()
-        fig.savefig(buf, format='png', dpi=100)
-        buf.seek(0)
-        img_b64 = base64.b64encode(buf.read()).decode('utf-8')
-        plt.close(fig)
-        
-        plot_html = f'<img src="data:image/png;base64,{img_b64}" style="max-width:100%;">'
         elapsed = f"Temps de calcul: {time.time() - start_time:.2f}s"
         
-        return plot_html, elapsed
+        return fig, elapsed
         
     except Exception as e:
-        return f"Erreur: {str(e)}", f"Temps: {time.time() - start_time:.2f}s"
+        return None, f"Erreur: {str(e)}"
 
-# Interface Gradio simplifiée
-with gr.Blocks() as demo:
-    gr.Markdown("# Simulation Robot Souple - Interface Simplifiée")
-    
-    with gr.Row():
-        mode_dropdown = gr.Dropdown(["Boucle ouverte", "PID"], value="Boucle ouverte", label="Mode de simulation")
-    
-    with gr.Row():
-        nx_slider = gr.Slider(5, 15, 10, label="Nombre d'éléments (nx)")
-        delta_slider = gr.Slider(0.01, 0.1, 0.02, label="Pas de temps (δt)")
-        pert_checkbox = gr.Checkbox(False, label="Avec perturbation")
-    
-    with gr.Row():
-        run_btn = gr.Button("Lancer Simulation", variant="primary")
+# Interface Streamlit
+st.title("🤖 Simulation Robot Souple")
+st.markdown("Interface simple et rapide pour simuler un robot flexible")
+
+# Contrôles dans la sidebar
+with st.sidebar:
+    st.header("Paramètres")
+    mode = st.selectbox("Mode de simulation", ["Boucle ouverte", "PID"])
+    nx = st.slider("Nombre d'éléments (nx)", 5, 15, 10)
+    delta = st.slider("Pas de temps (δt)", 0.01, 0.1, 0.02)
+    with_perturbation = st.checkbox("Avec perturbation", False)
     
-    plot_output = gr.HTML()
-    time_output = gr.Textbox(label="Performance")
+    run_button = st.button("🚀 Lancer Simulation", type="primary")
+
+# Zone de résultat
+if run_button:
+    with st.spinner("Calcul en cours..."):
+        fig, elapsed = simple_simulation(mode, nx, delta, with_perturbation)
     
-    run_btn.click(
-        simple_simulation, 
-        inputs=[mode_dropdown, nx_slider, delta_slider, pert_checkbox], 
-        outputs=[plot_output, time_output]
-    )
+    if fig is not None:
+        st.success(elapsed)
+        st.pyplot(fig, use_container_width=True)
+    else:
+        st.error(elapsed)
+else:
+    st.info("👈 Configurez les paramètres et cliquez sur 'Lancer Simulation'")
 
-demo.launch()
+# Instructions
+st.markdown("---")
+st.markdown("### 💡 Instructions")
+st.markdown("1. Choisissez le mode de simulation dans le menu de gauche")
+st.markdown("2. Ajustez les paramètres avec les curseurs")
+st.markdown("3. Cliquez sur 'Lancer Simulation' pour voir les résultats")
+st.markdown("4. Les calculs sont ultra-rapides : < 1 seconde !")

app_gradio.py

@@ -0,0 +1,104 @@
+import gradio as gr
+import numpy as np
+import matplotlib.pyplot as plt
+from io import BytesIO
+import base64
+import time
+
+def simple_simulation(mode, nx, delta, with_perturbation):
+    start_time = time.time()
+    
+    try:
+        # Paramètres très simplifiés
+        L = 500
+        nstep = min(50, int(1 / delta))  # Très court
+        time0 = np.linspace(0, delta * nstep, nstep + 1)
+        ixe = np.linspace(delta, L, nx)
+        
+        # Simulation ultra-simplifiée
+        if mode == "Boucle ouverte":
+            # Signal simple
+            u = np.zeros((nx, len(time0)))
+            for i, t in enumerate(time0):
+                if t > 0.1:
+                    u[:, i] = 0.01 * np.sin(2 * np.pi * 0.5 * t) * np.sin(np.pi * ixe / L)
+                else:
+                    u[:, i] = 0
+            
+            title = "Simulation Boucle Ouverte"
+            
+        else:  # PID
+            # Simulation PID ultra-simple
+            u = np.zeros((nx, len(time0)))
+            for i, t in enumerate(time0):
+                if t > 0.1:
+                    u[:, i] = 0.005 * (1 - np.exp(-2 * t)) * np.sin(np.pi * ixe / L)
+                else:
+                    u[:, i] = 0
+            
+            title = "Simulation PID"
+        
+        # Ajouter bruit si demandé
+        if with_perturbation:
+            noise = 0.001 * np.random.randn(nx, len(time0))
+            u += noise
+        
+        # Créer un simple plot
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 4))
+        
+        # Plot 1: Déformation finale
+        ax1.plot(ixe, u[:, -1], 'b-', linewidth=2)
+        ax1.set_title(f'{title} - Déformation finale')
+        ax1.set_xlabel('Position x (m)')
+        ax1.set_ylabel('Déplacement u (m)')
+        ax1.grid(True)
+        
+        # Plot 2: Évolution au temps
+        ax2.plot(time0, u[-1, :], 'r-', linewidth=2)
+        ax2.set_title(f'{title} - Évolution du tip')
+        ax2.set_xlabel('Temps (s)')
+        ax2.set_ylabel('Déplacement u_B (m)')
+        ax2.grid(True)
+        
+        plt.tight_layout()
+        
+        # Convertir en image
+        buf = BytesIO()
+        fig.savefig(buf, format='png', dpi=100)
+        buf.seek(0)
+        img_b64 = base64.b64encode(buf.read()).decode('utf-8')
+        plt.close(fig)
+        
+        plot_html = f'<img src="data:image/png;base64,{img_b64}" style="max-width:100%;">'
+        elapsed = f"Temps de calcul: {time.time() - start_time:.2f}s"
+        
+        return plot_html, elapsed
+        
+    except Exception as e:
+        return f"Erreur: {str(e)}", f"Temps: {time.time() - start_time:.2f}s"
+
+# Interface Gradio simplifiée
+with gr.Blocks() as demo:
+    gr.Markdown("# Simulation Robot Souple - Interface Simplifiée")
+    
+    with gr.Row():
+        mode_dropdown = gr.Dropdown(["Boucle ouverte", "PID"], value="Boucle ouverte", label="Mode de simulation")
+    
+    with gr.Row():
+        nx_slider = gr.Slider(5, 15, 10, label="Nombre d'éléments (nx)")
+        delta_slider = gr.Slider(0.01, 0.1, 0.02, label="Pas de temps (δt)")
+        pert_checkbox = gr.Checkbox(False, label="Avec perturbation")
+    
+    with gr.Row():
+        run_btn = gr.Button("Lancer Simulation", variant="primary")
+    
+    plot_output = gr.HTML()
+    time_output = gr.Textbox(label="Performance")
+    
+    run_btn.click(
+        simple_simulation, 
+        inputs=[mode_dropdown, nx_slider, delta_slider, pert_checkbox], 
+        outputs=[plot_output, time_output]
+    )
+
+demo.launch()

requirements.txt

@@ -1,3 +1,3 @@
-gradio==4.8.0
+streamlit==1.28.1
 numpy==1.24.3
 matplotlib==3.7.2