update streamlit issue

anycoder_app/prompts.py

@@ -98,15 +98,16 @@ STREAMLIT_SYSTEM_PROMPT = """You are an expert Streamlit developer. Create a com
 
 ## Multi-File Application Structure
 
-When creating complex Streamlit applications, organize your code into multiple files for better maintainability:
-
-**File Organization:**
-- `app.py` or `streamlit_app.py` - Main application entry point
-- `utils.py` - Utility functions and helpers
-- `models.py` - Model loading and inference functions
-- `config.py` - Configuration and constants
-- `requirements.txt` - Python dependencies
-- `pages/` - Additional pages for multi-page apps
+When creating Streamlit applications, you MUST organize your code into multiple files for proper deployment:
+
+**File Organization (CRITICAL - Always Include These):**
+- `Dockerfile` - Docker configuration for deployment (REQUIRED)
+- `streamlit_app.py` - Main application entry point (REQUIRED)
+- `requirements.txt` - Python dependencies (REQUIRED)
+- `utils.py` - Utility functions and helpers (optional)
+- `models.py` - Model loading and inference functions (optional)
+- `config.py` - Configuration and constants (optional)
+- `pages/` - Additional pages for multi-page apps (optional)
 - Additional modules as needed (e.g., `data_processing.py`, `components.py`)
 
 **🚨 CRITICAL: DO NOT Generate README.md Files**
@@ -115,18 +116,70 @@ When creating complex Streamlit applications, organize your code into multiple f
 - Generating a README.md will break the deployment process
 - Only generate the code files listed above
 
-**Output Format for Multi-File Apps:**
-When generating multi-file applications, use this exact format:
+**Output Format for Streamlit Apps:**
+You MUST use this exact format and ALWAYS include Dockerfile, streamlit_app.py, and requirements.txt:
 
 ```
+=== Dockerfile ===
+[Dockerfile content]
+
 === streamlit_app.py ===
 [main application code]
 
-=== utils.py ===
-[utility functions]
-
 === requirements.txt ===
 [dependencies]
+
+=== utils.py ===
+[utility functions - optional]
+```
+
+**🚨 CRITICAL: Dockerfile Requirements (MANDATORY for HuggingFace Spaces)**
+Your Dockerfile MUST follow these exact specifications:
+- Use Python 3.11+ base image (e.g., FROM python:3.11-slim)
+- Set up a user with ID 1000 for proper permissions:
+  ```
+  RUN useradd -m -u 1000 user
+  USER user
+  ENV HOME=/home/user \\
+      PATH=/home/user/.local/bin:$PATH
+  WORKDIR $HOME/app
+  ```
+- ALWAYS use --chown=user with COPY and ADD commands:
+  ```
+  COPY --chown=user requirements.txt .
+  COPY --chown=user . .
+  ```
+- Install dependencies: RUN pip install --no-cache-dir -r requirements.txt
+- Expose port 7860 (HuggingFace Spaces default): EXPOSE 7860
+- Start with: CMD ["streamlit", "run", "streamlit_app.py", "--server.port=7860", "--server.address=0.0.0.0"]
+
+**Example Dockerfile structure (USE THIS AS TEMPLATE):**
+```dockerfile
+FROM python:3.11-slim
+
+# Set up user with ID 1000
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \\
+    PATH=/home/user/.local/bin:$PATH
+
+# Set working directory
+WORKDIR $HOME/app
+
+# Copy requirements file with proper ownership
+COPY --chown=user requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files with proper ownership
+COPY --chown=user . .
+
+# Expose port 7860
+EXPOSE 7860
+
+# Start Streamlit app
+CMD ["streamlit", "run", "streamlit_app.py", "--server.port=7860", "--server.address=0.0.0.0"]
 ```
 
 **🚨 CRITICAL: requirements.txt Formatting Rules**
@@ -146,21 +199,18 @@ When generating multi-file applications, use this exact format:
   - pandas
   ```
 
-**Single vs Multi-File Decision:**
-- Use single file for simple applications (< 100 lines) - but still generate requirements.txt if dependencies exist
-- Use multi-file structure for complex applications with:
-  - Multiple pages or sections
-  - Extensive data processing
-  - Complex UI components
-  - Multiple models or APIs
-  - When user specifically requests modular structure
-
 **Multi-Page Apps:**
 For multi-page Streamlit apps, use the pages/ directory structure:
 ```
+=== Dockerfile ===
+[Dockerfile content]
+
 === streamlit_app.py ===
 [main page]
 
+=== requirements.txt ===
+[dependencies]
+
 === pages/1_📊_Analytics.py ===
 [analytics page]
 
@@ -169,14 +219,15 @@ For multi-page Streamlit apps, use the pages/ directory structure:
 ```
 
 Requirements:
-1. Create a modern, responsive Streamlit application
-2. Use appropriate Streamlit components and layouts
-3. Include proper error handling and loading states
-4. Follow Streamlit best practices for performance
-5. Use caching (@st.cache_data, @st.cache_resource) appropriately
-6. Include proper session state management when needed
-7. Make the UI intuitive and user-friendly
-8. Add helpful tooltips and documentation
+1. ALWAYS include Dockerfile, streamlit_app.py, and requirements.txt in your output
+2. Create a modern, responsive Streamlit application
+3. Use appropriate Streamlit components and layouts
+4. Include proper error handling and loading states
+5. Follow Streamlit best practices for performance
+6. Use caching (@st.cache_data, @st.cache_resource) appropriately
+7. Include proper session state management when needed
+8. Make the UI intuitive and user-friendly
+9. Add helpful tooltips and documentation
 
 IMPORTANT: Always include "Built with anycoder" as clickable text in the header/top section of your application that links to https://huggingface.co/spaces/akhaliq/anycoder
 """

anycoder_app/ui.py

@@ -1161,85 +1161,110 @@ with gr.Blocks(
                     action_text = "Updated" if is_update else "Deployed"
                     return gr.update(value=f"✅ {action_text}! [Open your React Space here]({space_url})", visible=True)
                 
-                # Streamlit logic
-                # Generate requirements.txt for Streamlit apps and upload only if needed
-                import_statements = extract_import_statements(code)
-                requirements_content = generate_requirements_txt_with_llm(import_statements)
+                # Streamlit logic - Parse multi-file structure
+                files = parse_multi_file_python_output(code)
+                if not files:
+                    return gr.update(value="Error: Could not parse Streamlit output. Please regenerate the code.", visible=True)
+                
+                # Verify required files exist
+                has_streamlit_app = 'streamlit_app.py' in files or 'app.py' in files
+                has_requirements = 'requirements.txt' in files
+                has_dockerfile = 'Dockerfile' in files
+                
+                if not has_streamlit_app:
+                    return gr.update(value="Error: Missing streamlit_app.py. Please regenerate the code.", visible=True)
                 
+                # If Dockerfile or requirements.txt is missing, generate them
+                if not has_dockerfile:
+                    # Generate default Dockerfile
+                    files['Dockerfile'] = """FROM python:3.11-slim
+
+# Set up user with ID 1000
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \\
+    PATH=/home/user/.local/bin:$PATH
+
+# Set working directory
+WORKDIR $HOME/app
+
+# Copy requirements file with proper ownership
+COPY --chown=user requirements.txt .
+
+# Install dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application files with proper ownership
+COPY --chown=user . .
+
+# Expose port 7860
+EXPOSE 7860
+
+# Start Streamlit app
+CMD ["streamlit", "run", "streamlit_app.py", "--server.port=7860", "--server.address=0.0.0.0"]
+"""
+                
+                if not has_requirements:
+                    # Generate requirements.txt from imports in the main app file
+                    main_app = files.get('streamlit_app.py') or files.get('app.py', '')
+                    import_statements = extract_import_statements(main_app)
+                    files['requirements.txt'] = generate_requirements_txt_with_llm(import_statements)
+                
+                # Upload Streamlit files
                 import tempfile
+                import time
                 
-                # Check if we need to upload requirements.txt
-                should_upload_requirements = True
-                if is_update:
-                    try:
-                        # Try to get existing requirements.txt content
-                        existing_requirements = api.hf_hub_download(
-                            repo_id=repo_id,
-                            filename="requirements.txt",
-                            repo_type="space"
-                        )
-                        with open(existing_requirements, 'r') as f:
-                            existing_content = f.read().strip()
+                for file_name, file_content in files.items():
+                    if not file_content:
+                        continue
                         
-                        # Compare with new content
-                        if existing_content == requirements_content.strip():
-                            should_upload_requirements = False
+                    success = False
+                    last_error = None
+                    max_attempts = 3
+                    
+                    for attempt in range(max_attempts):
+                        try:
+                            # Determine file extension
+                            if file_name == 'Dockerfile':
+                                suffix = ''
+                            else:
+                                suffix = f".{file_name.split('.')[-1]}"
                             
-                    except Exception:
-                        # File doesn't exist or can't be accessed, so we should upload
-                        should_upload_requirements = True
-                
-                # Upload requirements.txt only if needed
-                if should_upload_requirements:
-                    try:
-                        with tempfile.NamedTemporaryFile("w", suffix=".txt", delete=False) as f:
-                            f.write(requirements_content)
-                            requirements_temp_path = f.name
-                        
-                        api.upload_file(
-                            path_or_fileobj=requirements_temp_path,
-                            path_in_repo="requirements.txt",
-                            repo_id=repo_id,
-                            repo_type="space"
-                        )
-                    except Exception as e:
-                        error_msg = str(e)
-                        if "403 Forbidden" in error_msg and "write token" in error_msg:
-                            return gr.update(value=f"Error uploading requirements.txt: Permission denied. Please ensure you have write access to {repo_id} and your token has the correct permissions.", visible=True)
-                        else:
-                            return gr.update(value=f"Error uploading requirements.txt: {e}", visible=True)
-                    finally:
-                        import os
-                        if 'requirements_temp_path' in locals():
-                            os.unlink(requirements_temp_path)
-                
-                # Add anycoder tag to existing README
-                add_anycoder_tag_to_readme(api, repo_id)
+                            with tempfile.NamedTemporaryFile("w", suffix=suffix, delete=False) as f:
+                                f.write(file_content)
+                                temp_path = f.name
+                            
+                            api.upload_file(
+                                path_or_fileobj=temp_path,
+                                path_in_repo=file_name,
+                                repo_id=repo_id,
+                                repo_type="space"
+                            )
+                            success = True
+                            break
+                            
+                        except Exception as e:
+                            last_error = e
+                            error_msg = str(e)
+                            if "403 Forbidden" in error_msg and "write token" in error_msg:
+                                return gr.update(value=f"Error: Permission denied. Please ensure you have write access to {repo_id} and your token has the correct permissions.", visible=True)
+                            
+                            if attempt < max_attempts - 1:
+                                time.sleep(2)
+                        finally:
+                            import os
+                            if 'temp_path' in locals():
+                                os.unlink(temp_path)
+                    
+                    if not success:
+                        return gr.update(value=f"Error uploading {file_name}: {last_error}", visible=True)
                 
-                # Upload the user's code to src/streamlit_app.py (for both new and existing spaces)
-                with tempfile.NamedTemporaryFile("w", suffix=".py", delete=False) as f:
-                    f.write(code)
-                    temp_path = f.name
+                # Add anycoder tag and app_port to existing README
+                add_anycoder_tag_to_readme(api, repo_id, app_port=7860)
                 
-                try:
-                    api.upload_file(
-                        path_or_fileobj=temp_path,
-                        path_in_repo="src/streamlit_app.py",
-                        repo_id=repo_id,
-                        repo_type="space"
-                    )
-                    space_url = f"https://huggingface.co/spaces/{repo_id}"
-                    action_text = "Updated" if is_update else "Deployed"
-                    return gr.update(value=f"✅ {action_text}! [Open your Space here]({space_url})", visible=True)
-                except Exception as e:
-                    error_msg = str(e)
-                    if "403 Forbidden" in error_msg and "write token" in error_msg:
-                        return gr.update(value=f"Error: Permission denied. Please ensure you have write access to {repo_id} and your token has the correct permissions.", visible=True)
-                    else:
-                        return gr.update(value=f"Error uploading Streamlit app: {e}", visible=True)
-                finally:
-                    import os
-                    os.unlink(temp_path)
+                space_url = f"https://huggingface.co/spaces/{repo_id}"
+                action_text = "Updated" if is_update else "Deployed"
+                return gr.update(value=f"✅ {action_text}! [Open your Streamlit Space here]({space_url})", visible=True)
                     
             except Exception as e:
                 error_prefix = "Error duplicating Streamlit space" if not is_update else "Error updating Streamlit space"