Upload 3 files

app.py

@@ -0,0 +1,560 @@
+"""
+AutoEIS Hugging Face Space Application
+Optimized for limited resources with workflow integration
+"""
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import base64
+import json
+import requests
+import io
+import os
+import psutil
+import gc
+from typing import Dict, Any, Optional, Tuple
+from datetime import datetime
+import traceback
+import asyncio
+import aiohttp
+from urllib.parse import parse_qs, urlparse
+
+# Import AutoEIS with error handling
+try:
+    import autoeis as ae
+except ImportError as e:
+    print(f"Warning: AutoEIS import issue: {e}")
+    ae = None
+
+# Memory monitoring
+def get_memory_usage():
+    """Get current memory usage in MB"""
+    process = psutil.Process(os.getpid())
+    return process.memory_info().rss / 1024 / 1024
+
+def check_memory_available():
+    """Check if enough memory is available"""
+    memory_mb = get_memory_usage()
+    available_mb = psutil.virtual_memory().available / 1024 / 1024
+    return available_mb > 500  # Need at least 500MB free
+
+# Global variables for workflow integration
+workflow_context = {
+    "workflow_id": None,
+    "node_id": None,
+    "callback_url": None,
+    "auth_token": None
+}
+
+# Optimized parameters for HF Spaces
+HF_OPTIMIZED_PARAMS = {
+    "iters": 20,  # Reduced from 50
+    "complexity": 8,  # Reduced from 12
+    "generations": 15,  # Reduced from 30
+    "population_size": 50,  # Reduced from 100
+    "test_set_frac": 0.2,  # Increased for faster validation
+    "random_state": 42
+}
+
+def parse_workflow_params(request: gr.Request) -> Dict[str, Any]:
+    """Parse workflow parameters from URL or headers"""
+    params = {}
+    
+    # Try to get params from URL query string
+    if request and hasattr(request, 'query_params'):
+        query_params = dict(request.query_params)
+        if 'params' in query_params:
+            try:
+                encoded_params = query_params['params']
+                decoded = base64.b64decode(encoded_params)
+                params = json.loads(decoded)
+            except Exception as e:
+                print(f"Error parsing URL params: {e}")
+    
+    return params
+
+def decode_csv_data(encoded_data: str) -> pd.DataFrame:
+    """Decode base64 CSV data to DataFrame"""
+    try:
+        csv_bytes = base64.b64decode(encoded_data)
+        csv_string = csv_bytes.decode('utf-8')
+        df = pd.read_csv(io.StringIO(csv_string))
+        return df
+    except Exception as e:
+        print(f"Error decoding CSV: {e}")
+        return None
+
+async def send_callback(results: Dict[str, Any]) -> bool:
+    """Send results back to workflow system"""
+    if not workflow_context["callback_url"]:
+        return False
+    
+    try:
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {workflow_context['auth_token']}"
+        }
+        
+        payload = {
+            "workflow_id": workflow_context["workflow_id"],
+            "node_id": workflow_context["node_id"],
+            "status": "completed",
+            "results": results,
+            "analysis_timestamp": datetime.utcnow().isoformat() + "Z"
+        }
+        
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                workflow_context["callback_url"],
+                json=payload,
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(total=30)
+            ) as response:
+                return response.status == 200
+    except Exception as e:
+        print(f"Callback error: {e}")
+        return False
+
+def create_sample_data() -> pd.DataFrame:
+    """Create sample EIS data for demonstration"""
+    frequencies = np.logspace(5, -2, 50)  # 100kHz to 0.01Hz
+    
+    # Simple RC circuit simulation
+    R0 = 100  # Ohms
+    R1 = 500  # Ohms
+    C1 = 1e-6  # Farads
+    
+    omega = 2 * np.pi * frequencies
+    Z_R0 = R0
+    Z_RC = R1 / (1 + 1j * omega * R1 * C1)
+    Z_total = Z_R0 + Z_RC
+    
+    df = pd.DataFrame({
+        'frequency': frequencies,
+        'z_real': Z_total.real,
+        'z_imag': -Z_total.imag
+    })
+    
+    return df
+
+def analyze_eis_optimized(
+    df: pd.DataFrame,
+    circuit_model: str = "auto",
+    algorithm: str = "lm",
+    use_hf_params: bool = True,
+    progress_callback=None
+) -> Tuple[Dict[str, Any], str, str]:
+    """
+    Analyze EIS data with HF optimization
+    Returns: (results_dict, nyquist_plot, bode_plot)
+    """
+    if ae is None:
+        return {"error": "AutoEIS not available"}, None, None
+    
+    # Check memory before starting
+    if not check_memory_available():
+        gc.collect()  # Try garbage collection
+        if not check_memory_available():
+            return {"error": "Insufficient memory available"}, None, None
+    
+    try:
+        # Prepare impedance data
+        Z = df['z_real'].values + 1j * df['z_imag'].values
+        freq = df['frequency'].values
+        
+        # Use optimized parameters for HF
+        params = HF_OPTIMIZED_PARAMS.copy() if use_hf_params else {}
+        
+        if progress_callback:
+            progress_callback(0.2, "Initializing AutoEIS...")
+        
+        # Circuit detection with limited complexity
+        if circuit_model == "auto":
+            if progress_callback:
+                progress_callback(0.4, "Detecting circuit model...")
+            
+            # Use simpler approach for HF
+            circuits = ae.core.generate_equivalent_circuits(
+                Z,
+                freq,
+                iters=params.get("iters", 20),
+                complexity=params.get("complexity", 8),
+                generations=params.get("generations", 15),
+                population_size=params.get("population_size", 50),
+                test_set_frac=params.get("test_set_frac", 0.2),
+                random_state=params.get("random_state", 42)
+            )
+            
+            if circuits and len(circuits) > 0:
+                circuit_str = circuits[0]  # Take the best circuit
+            else:
+                circuit_str = "R0-[R1,C1]"  # Fallback simple circuit
+        else:
+            circuit_str = circuit_model
+        
+        if progress_callback:
+            progress_callback(0.6, "Fitting circuit parameters...")
+        
+        # Fit the circuit
+        circuit = ae.core.get_parameterized_circuit(circuit_str)
+        fitted_params = ae.core.fit_parameters(circuit, freq, Z)
+        
+        if progress_callback:
+            progress_callback(0.8, "Generating plots...")
+        
+        # Generate plots
+        import matplotlib
+        matplotlib.use('Agg')  # Non-interactive backend
+        import matplotlib.pyplot as plt
+        
+        # Nyquist plot
+        fig_nyquist, ax_nyquist = plt.subplots(figsize=(8, 6))
+        ax_nyquist.plot(Z.real, Z.imag, 'bo', label='Data', markersize=6)
+        
+        # Add fitted curve if available
+        if fitted_params:
+            Z_fit = circuit(freq, **fitted_params)
+            ax_nyquist.plot(Z_fit.real, Z_fit.imag, 'r-', label='Fit', linewidth=2)
+        
+        ax_nyquist.set_xlabel('Z\' (Ω)')
+        ax_nyquist.set_ylabel('-Z\'\' (Ω)')
+        ax_nyquist.set_title('Nyquist Plot')
+        ax_nyquist.legend()
+        ax_nyquist.grid(True, alpha=0.3)
+        ax_nyquist.set_aspect('equal')
+        
+        # Bode plot
+        fig_bode, (ax_mag, ax_phase) = plt.subplots(2, 1, figsize=(8, 8))
+        
+        Z_mag = np.abs(Z)
+        Z_phase = np.angle(Z, deg=True)
+        
+        ax_mag.loglog(freq, Z_mag, 'bo', label='Data', markersize=6)
+        ax_mag.set_ylabel('|Z| (Ω)')
+        ax_mag.set_title('Bode Plot - Magnitude')
+        ax_mag.grid(True, which="both", alpha=0.3)
+        ax_mag.legend()
+        
+        ax_phase.semilogx(freq, Z_phase, 'bo', label='Data', markersize=6)
+        
+        if fitted_params:
+            Z_fit = circuit(freq, **fitted_params)
+            ax_mag.loglog(freq, np.abs(Z_fit), 'r-', label='Fit', linewidth=2)
+            ax_phase.semilogx(freq, np.angle(Z_fit, deg=True), 'r-', label='Fit', linewidth=2)
+        
+        ax_phase.set_xlabel('Frequency (Hz)')
+        ax_phase.set_ylabel('Phase (°)')
+        ax_phase.set_title('Bode Plot - Phase')
+        ax_phase.grid(True, alpha=0.3)
+        ax_phase.legend()
+        
+        plt.tight_layout()
+        
+        # Calculate fit quality
+        if fitted_params:
+            Z_fit = circuit(freq, **fitted_params)
+            residuals = Z - Z_fit
+            chi_squared = np.sum(np.abs(residuals)**2) / len(Z)
+            fit_error = np.sqrt(chi_squared)
+        else:
+            chi_squared = None
+            fit_error = None
+        
+        # Prepare results
+        results = {
+            "circuit_model": circuit_str,
+            "fit_parameters": fitted_params if fitted_params else {},
+            "fit_error": float(fit_error) if fit_error else None,
+            "chi_squared": float(chi_squared) if chi_squared else None,
+            "memory_usage_mb": get_memory_usage()
+        }
+        
+        if progress_callback:
+            progress_callback(1.0, "Analysis complete!")
+        
+        # Clean up memory
+        gc.collect()
+        
+        return results, fig_nyquist, fig_bode
+        
+    except Exception as e:
+        error_msg = f"Analysis error: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return {"error": error_msg}, None, None
+    finally:
+        # Always try to free memory
+        gc.collect()
+
+def process_analysis(
+    data_file,
+    circuit_model,
+    algorithm,
+    use_optimization,
+    progress=gr.Progress()
+):
+    """Main analysis function for Gradio interface"""
+    
+    progress(0.1, "Starting analysis...")
+    
+    # Load data
+    if data_file is None:
+        progress(0.2, "Using sample data...")
+        df = create_sample_data()
+    else:
+        try:
+            df = pd.read_csv(data_file.name)
+        except Exception as e:
+            return {"error": f"Failed to read CSV: {e}"}, None, None
+    
+    # Run analysis
+    results, nyquist_plot, bode_plot = analyze_eis_optimized(
+        df,
+        circuit_model=circuit_model,
+        algorithm=algorithm,
+        use_hf_params=use_optimization,
+        progress_callback=progress
+    )
+    
+    return results, nyquist_plot, bode_plot
+
+async def send_to_workflow(results):
+    """Send results back to workflow"""
+    if workflow_context["callback_url"]:
+        success = await send_callback(results)
+        return "✅ Results sent to workflow!" if success else "❌ Failed to send results"
+    return "No workflow callback URL configured"
+
+# Create Gradio interface
+def create_interface():
+    with gr.Blocks(title="AutoEIS Analyzer", theme=gr.themes.Soft()) as app:
+        # Header
+        gr.Markdown("""
+        # 🔬 AutoEIS Analysis Tool
+        ### Automated Electrochemical Impedance Spectroscopy Analysis
+        
+        Optimized for Hugging Face Spaces with workflow integration support.
+        """)
+        
+        # Memory monitor
+        with gr.Row():
+            memory_display = gr.Textbox(
+                label="Memory Usage",
+                value=f"{get_memory_usage():.1f} MB",
+                interactive=False,
+                scale=1
+            )
+            workflow_info = gr.Textbox(
+                label="Workflow Context",
+                value="No workflow connected",
+                interactive=False,
+                scale=3
+            )
+        
+        with gr.Tabs():
+            # Data Input Tab
+            with gr.Tab("📊 Data Input"):
+                with gr.Row():
+                    data_file = gr.File(
+                        label="Upload EIS Data (CSV)",
+                        file_types=[".csv"],
+                        value=None
+                    )
+                    
+                with gr.Row():
+                    gr.Markdown("""
+                    **Expected CSV Format:**
+                    - Column 1: `frequency` (Hz)
+                    - Column 2: `z_real` (Ω)
+                    - Column 3: `z_imag` (Ω)
+                    
+                    Leave empty to use sample data.
+                    """)
+                
+                data_preview = gr.DataFrame(
+                    label="Data Preview (first 10 rows)",
+                    interactive=False
+                )
+            
+            # Parameters Tab
+            with gr.Tab("⚙️ Parameters"):
+                with gr.Row():
+                    circuit_model = gr.Dropdown(
+                        choices=["auto", "R0-[R1,C1]", "R0-[R1,P1]", "R0-[R1,C1]-[R2,C2]"],
+                        value="auto",
+                        label="Circuit Model",
+                        info="Select 'auto' for automatic detection"
+                    )
+                    
+                    algorithm = gr.Radio(
+                        choices=["lm", "trf", "dogbox"],
+                        value="lm",
+                        label="Fitting Algorithm",
+                        info="Levenberg-Marquardt (lm) is usually best"
+                    )
+                
+                with gr.Row():
+                    use_optimization = gr.Checkbox(
+                        value=True,
+                        label="Use HF-optimized parameters",
+                        info="Recommended for Hugging Face Spaces (faster, less memory)"
+                    )
+                
+                with gr.Row():
+                    gr.Markdown("""
+                    **Optimization Settings (when enabled):**
+                    - Reduced iterations: 20 (vs 50)
+                    - Lower complexity: 8 (vs 12)
+                    - Smaller population: 50 (vs 100)
+                    - Faster validation: 20% test set
+                    """)
+            
+            # Results Tab
+            with gr.Tab("📈 Results"):
+                with gr.Row():
+                    results_json = gr.JSON(
+                        label="Analysis Results",
+                        value=None
+                    )
+                
+                with gr.Row():
+                    nyquist_plot = gr.Plot(
+                        label="Nyquist Plot",
+                        show_label=True
+                    )
+                    
+                    bode_plot = gr.Plot(
+                        label="Bode Plot",
+                        show_label=True
+                    )
+                
+                with gr.Row():
+                    workflow_btn = gr.Button(
+                        "📤 Send to Workflow",
+                        variant="secondary",
+                        visible=False
+                    )
+                    workflow_status = gr.Textbox(
+                        label="Workflow Status",
+                        interactive=False,
+                        visible=False
+                    )
+        
+        # Action buttons
+        with gr.Row():
+            analyze_btn = gr.Button(
+                "🚀 Run Analysis",
+                variant="primary",
+                size="lg"
+            )
+            
+            clear_btn = gr.Button(
+                "🔄 Clear",
+                variant="secondary"
+            )
+        
+        # Event handlers
+        def update_preview(file):
+            if file is None:
+                df = create_sample_data()
+                return df.head(10), f"Memory: {get_memory_usage():.1f} MB"
+            try:
+                df = pd.read_csv(file.name)
+                return df.head(10), f"Memory: {get_memory_usage():.1f} MB"
+            except:
+                return None, f"Memory: {get_memory_usage():.1f} MB"
+        
+        def clear_all():
+            gc.collect()
+            return (
+                None,  # data_file
+                None,  # data_preview
+                "auto",  # circuit_model
+                "lm",  # algorithm
+                True,  # use_optimization
+                None,  # results_json
+                None,  # nyquist_plot
+                None,  # bode_plot
+                f"Memory: {get_memory_usage():.1f} MB"  # memory_display
+            )
+        
+        # Wire up events
+        data_file.change(
+            fn=update_preview,
+            inputs=[data_file],
+            outputs=[data_preview, memory_display]
+        )
+        
+        analyze_btn.click(
+            fn=process_analysis,
+            inputs=[
+                data_file,
+                circuit_model,
+                algorithm,
+                use_optimization
+            ],
+            outputs=[
+                results_json,
+                nyquist_plot,
+                bode_plot
+            ]
+        )
+        
+        clear_btn.click(
+            fn=clear_all,
+            outputs=[
+                data_file,
+                data_preview,
+                circuit_model,
+                algorithm,
+                use_optimization,
+                results_json,
+                nyquist_plot,
+                bode_plot,
+                memory_display
+            ]
+        )
+        
+        workflow_btn.click(
+            fn=lambda r: asyncio.run(send_to_workflow(r)),
+            inputs=[results_json],
+            outputs=[workflow_status]
+        )
+        
+        # Load workflow params on startup
+        def on_load(request: gr.Request):
+            params = parse_workflow_params(request)
+            if params:
+                workflow_context.update({
+                    "workflow_id": params.get("workflow_id"),
+                    "node_id": params.get("node_id"),
+                    "callback_url": params.get("callback_url"),
+                    "auth_token": params.get("auth_token")
+                })
+                
+                if params.get("input_data", {}).get("csv_data"):
+                    # Decode and process CSV data
+                    df = decode_csv_data(params["input_data"]["csv_data"])
+                    if df is not None:
+                        return f"Workflow: {params.get('workflow_id', 'Unknown')}", True, True
+                
+                return f"Workflow: {params.get('workflow_id', 'Unknown')}", True, False
+            
+            return "No workflow connected", False, False
+        
+        app.load(
+            fn=on_load,
+            outputs=[workflow_info, workflow_btn, workflow_status]
+        )
+    
+    return app
+
+# Launch the app
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

requirements.txt

@@ -0,0 +1,20 @@
+# Core dependencies - optimized for HF Spaces limited resources
+gradio==4.19.0
+autoeis==0.0.39
+pandas>=1.5.0,<2.0.0
+numpy>=1.21.0,<1.24.0
+matplotlib>=3.5.0,<4.0.0
+scikit-learn>=1.0.0,<2.0.0
+requests>=2.28.0
+
+# Optional - for enhanced visualization
+plotly>=5.0.0
+schemdraw>=0.15
+
+# Memory optimization
+psutil>=5.9.0
+
+# For workflow integration
+aiohttp>=3.8.0
+python-jose[cryptography]>=3.3.0  # For JWT handling
+python-multipart>=0.0.5  # For file uploads

workflow_integration.py

@@ -0,0 +1,258 @@
+"""
+Workflow Integration Helper for AutoEIS Hugging Face Space
+This module provides utilities for integrating with external workflow systems
+"""
+
+import base64
+import json
+import requests
+from typing import Dict, Any, Optional
+from datetime import datetime, timedelta
+import jwt
+import hashlib
+
+
+class WorkflowClient:
+    """Client for integrating AutoEIS HF Space with workflow systems"""
+    
+    def __init__(self, hf_space_url: str, secret_key: str = None):
+        """
+        Initialize workflow client
+        
+        Args:
+            hf_space_url: URL of your Hugging Face Space
+            secret_key: Secret key for JWT generation (optional)
+        """
+        self.hf_space_url = hf_space_url.rstrip('/')
+        self.secret_key = secret_key or self._generate_secret()
+    
+    def _generate_secret(self) -> str:
+        """Generate a secret key if none provided"""
+        return hashlib.sha256(
+            f"autoeis-{datetime.utcnow().isoformat()}".encode()
+        ).hexdigest()
+    
+    def create_jwt_token(self, workflow_id: str, expires_in: int = 1800) -> str:
+        """
+        Create a JWT token for authentication
+        
+        Args:
+            workflow_id: ID of the workflow
+            expires_in: Token expiration time in seconds (default 30 minutes)
+        
+        Returns:
+            JWT token string
+        """
+        payload = {
+            'workflow_id': workflow_id,
+            'exp': datetime.utcnow() + timedelta(seconds=expires_in),
+            'iat': datetime.utcnow(),
+            'iss': 'autoeis-workflow'
+        }
+        
+        return jwt.encode(payload, self.secret_key, algorithm='HS256')
+    
+    def prepare_analysis_params(
+        self,
+        workflow_id: str,
+        node_id: str,
+        callback_url: str,
+        csv_data: str,
+        filename: str = "eis_data.csv",
+        circuit_model: str = "auto",
+        fitting_algorithm: str = "lm",
+        max_iterations: int = 1000,
+        tolerance: float = 1e-8,
+        generate_plots: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Prepare parameters for AutoEIS analysis
+        
+        Args:
+            workflow_id: Unique workflow identifier
+            node_id: Node ID in the workflow
+            callback_url: URL to send results back to
+            csv_data: CSV content as string
+            filename: Name of the CSV file
+            circuit_model: Circuit model to use ("auto" for automatic detection)
+            fitting_algorithm: Algorithm for fitting ("lm", "trf", or "dogbox")
+            max_iterations: Maximum fitting iterations
+            tolerance: Fitting tolerance
+            generate_plots: Whether to generate plots
+        
+        Returns:
+            Dictionary of parameters ready for encoding
+        """
+        # Encode CSV data to base64
+        csv_base64 = base64.b64encode(csv_data.encode()).decode()
+        
+        # Generate auth token
+        auth_token = self.create_jwt_token(workflow_id)
+        
+        params = {
+            "workflow_id": workflow_id,
+            "node_id": node_id,
+            "callback_url": callback_url,
+            "input_data": {
+                "csv_data": csv_base64,
+                "filename": filename,
+                "parameters": {
+                    "frequency_column": "frequency",
+                    "z_real_column": "z_real",
+                    "z_imag_column": "z_imag",
+                    "circuit_initial_guess": circuit_model,
+                    "fitting_algorithm": fitting_algorithm,
+                    "max_iterations": max_iterations,
+                    "tolerance": tolerance,
+                    "generate_plots": generate_plots,
+                    "save_circuit_diagram": True
+                }
+            },
+            "auth_token": auth_token
+        }
+        
+        return params
+    
+    def generate_hf_url(self, params: Dict[str, Any]) -> str:
+        """
+        Generate the Hugging Face Space URL with encoded parameters
+        
+        Args:
+            params: Dictionary of parameters from prepare_analysis_params
+        
+        Returns:
+            Complete URL to open the HF Space with parameters
+        """
+        # Encode parameters to base64
+        params_json = json.dumps(params)
+        encoded_params = base64.b64encode(params_json.encode()).decode()
+        
+        # Create URL
+        url = f"{self.hf_space_url}?params={encoded_params}"
+        
+        return url
+    
+    def send_to_hf_space(
+        self,
+        workflow_id: str,
+        node_id: str,
+        callback_url: str,
+        csv_data: str,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Send analysis request to HF Space
+        
+        Args:
+            workflow_id: Unique workflow identifier
+            node_id: Node ID in the workflow
+            callback_url: URL to send results back to
+            csv_data: CSV content as string
+            **kwargs: Additional parameters for prepare_analysis_params
+        
+        Returns:
+            Dictionary with action and URL
+        """
+        # Prepare parameters
+        params = self.prepare_analysis_params(
+            workflow_id=workflow_id,
+            node_id=node_id,
+            callback_url=callback_url,
+            csv_data=csv_data,
+            **kwargs
+        )
+        
+        # Generate URL
+        url = self.generate_hf_url(params)
+        
+        return {
+            "action": "open_external",
+            "url": url,
+            "wait_for_callback": True,
+            "params": params
+        }
+    
+    def verify_callback_token(self, token: str) -> Dict[str, Any]:
+        """
+        Verify a JWT token from callback
+        
+        Args:
+            token: JWT token string
+        
+        Returns:
+            Decoded payload if valid
+        
+        Raises:
+            jwt.InvalidTokenError: If token is invalid
+        """
+        return jwt.decode(token, self.secret_key, algorithms=['HS256'])
+    
+    def process_callback_results(self, callback_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Process results received from HF Space callback
+        
+        Args:
+            callback_data: Data received from callback
+        
+        Returns:
+            Processed results
+        """
+        results = {
+            "workflow_id": callback_data.get("workflow_id"),
+            "node_id": callback_data.get("node_id"),
+            "status": callback_data.get("status"),
+            "circuit_model": callback_data.get("results", {}).get("circuit_model"),
+            "fit_parameters": callback_data.get("results", {}).get("fit_parameters"),
+            "fit_error": callback_data.get("results", {}).get("fit_error"),
+            "chi_squared": callback_data.get("results", {}).get("chi_squared"),
+            "timestamp": callback_data.get("analysis_timestamp")
+        }
+        
+        # Extract plots if available
+        if "plots" in callback_data.get("results", {}):
+            results["plots"] = callback_data["results"]["plots"]
+        
+        return results
+
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize client
+    client = WorkflowClient(
+        hf_space_url="https://huggingface.co/spaces/YOUR_USERNAME/autoeis-analyzer",
+        secret_key="your-secret-key-here"
+    )
+    
+    # Sample CSV data
+    sample_csv = """frequency,z_real,z_imag
+100000,100.5,5.2
+50000,102.3,8.7
+10000,108.9,15.3
+5000,115.2,22.1
+1000,125.6,35.8
+500,138.9,45.2
+100,156.3,58.9
+50,172.5,65.3
+10,195.8,68.2
+5,215.3,65.8
+1,245.6,52.3
+0.5,268.9,38.9
+0.1,295.3,15.2"""
+    
+    # Prepare and send to HF Space
+    result = client.send_to_hf_space(
+        workflow_id="test-workflow-123",
+        node_id="autoeis-node-1",
+        callback_url="https://your-system.com/api/autoeis/callback",
+        csv_data=sample_csv,
+        circuit_model="auto",
+        fitting_algorithm="lm"
+    )
+    
+    print("Generated URL:", result["url"])
+    print("\nTo integrate with your workflow system:")
+    print("1. Open the URL in a new window/iframe")
+    print("2. User performs analysis in HF Space")
+    print("3. Results will be sent to your callback URL")
+    print("4. Verify the JWT token in the callback")
+    print("5. Process the results using process_callback_results()")