diff --git a/.dockerignore b/.dockerignore deleted file mode 100644 index 28928c33f309c4ef4a8c5c1fc4ac4ea2e38fdeb5..0000000000000000000000000000000000000000 --- a/.dockerignore +++ /dev/null @@ -1,67 +0,0 @@ -# Python -__pycache__/ -*.py[cod] -*$py.class -*.so -.Python -venv/ -.venv/ -ENV/ -env/ -*.egg-info/ -dist/ -build/ - -# Node -node_modules/ -npm-debug.log* -yarn-debug.log* -yarn-error.log* -.pnpm-debug.log* - -# Next.js -frontend/.next/ -frontend/out/ -frontend/build/ - -# Git -.git/ -.gitignore - -# IDE -.vscode/ -.idea/ -*.swp -*.swo -*~ - -# OS -.DS_Store -Thumbs.db - -# Documentation -*.md -!README.md - -# Docker -Dockerfile* -docker-compose*.yml -.dockerignore - -# Logs -*.log -logs/ -log/ - -# Generated -generated_projects/ - -# Tests -test/ -tests/ -__tests__/ - -# Lock files (will be regenerated) -uv.lock -poetry.lock - diff --git a/.gitattributes b/.gitattributes index 1abc6d15eb80582bc2bc48e8b790dd790b00d25b..a6344aac8c09253b3b630fb776ae94478aa0275b 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1 +1,35 @@ -Animated_Logo_Video_Ready.gif filter=lfs diff=lfs merge=lfs -text +*.7z filter=lfs diff=lfs merge=lfs -text +*.arrow filter=lfs diff=lfs merge=lfs -text +*.bin filter=lfs diff=lfs merge=lfs -text +*.bz2 filter=lfs diff=lfs merge=lfs -text +*.ckpt filter=lfs diff=lfs merge=lfs -text +*.ftz filter=lfs diff=lfs merge=lfs -text +*.gz filter=lfs diff=lfs merge=lfs -text +*.h5 filter=lfs diff=lfs merge=lfs -text +*.joblib filter=lfs diff=lfs merge=lfs -text +*.lfs.* filter=lfs diff=lfs merge=lfs -text +*.mlmodel filter=lfs diff=lfs merge=lfs -text +*.model filter=lfs diff=lfs merge=lfs -text +*.msgpack filter=lfs diff=lfs merge=lfs -text +*.npy filter=lfs diff=lfs merge=lfs -text +*.npz filter=lfs diff=lfs merge=lfs -text +*.onnx filter=lfs diff=lfs merge=lfs -text +*.ot filter=lfs diff=lfs merge=lfs -text +*.parquet filter=lfs diff=lfs merge=lfs -text +*.pb filter=lfs diff=lfs merge=lfs -text +*.pickle filter=lfs diff=lfs merge=lfs -text +*.pkl filter=lfs diff=lfs merge=lfs -text +*.pt filter=lfs diff=lfs merge=lfs -text +*.pth filter=lfs diff=lfs merge=lfs -text +*.rar filter=lfs diff=lfs merge=lfs -text +*.safetensors filter=lfs diff=lfs merge=lfs -text +saved_model/**/* filter=lfs diff=lfs merge=lfs -text +*.tar.* filter=lfs diff=lfs merge=lfs -text +*.tar filter=lfs diff=lfs merge=lfs -text +*.tflite filter=lfs diff=lfs merge=lfs -text +*.tgz filter=lfs diff=lfs merge=lfs -text +*.wasm filter=lfs diff=lfs merge=lfs -text +*.xz filter=lfs diff=lfs merge=lfs -text +*.zip filter=lfs diff=lfs merge=lfs -text +*.zst filter=lfs diff=lfs merge=lfs -text +*tfevents* filter=lfs diff=lfs merge=lfs -text diff --git a/.gitignore b/.gitignore index d5b6470f9b8d5d941f8a1547c325eeea189e75c4..0f25b866ecf0fddab1b5836b418c1966b98cb00f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ +.gradio/ + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] @@ -14,26 +16,21 @@ dist/ downloads/ eggs/ .eggs/ -# Ignore Python lib directories but NOT frontend/src/lib -/lib/ -/lib64/ -venv/lib/ -venv/lib64/ +lib/ +lib64/ parts/ sdist/ var/ +wheels/ +share/python-wheels/ *.egg-info/ .installed.cfg *.egg MANIFEST -# Virtual environments -venv/ -env/ -ENV/ -.venv/ - # PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. *.manifest *.spec @@ -51,34 +48,115 @@ htmlcov/ nosetests.xml coverage.xml *.cover +*.py,cover .hypothesis/ .pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ # Jupyter Notebook .ipynb_checkpoints +# IPython +profile_default/ +ipython_config.py + # pyenv -.python-version +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site # mypy .mypy_cache/ .dmypy.json +dmypy.json # Pyre type checker .pyre/ -# Gradio cache -log/ -logs/ - -# System files -.DS_Store -Thumbs.db +# pytype static type analyzer +.pytype/ -# Lock files -uv.lock -poetry.lock -Pipfile.lock +# Cython debug symbols +cython_debug/ -# VSCode -.vscode/ \ No newline at end of file +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4bc0c623a659d38b912b9efd8443b18bc4922d49 --- /dev/null +++ b/.pre-commit-config.yaml @@ -0,0 +1,32 @@ +repos: + - repo: https://github.com/pre-commit/pre-commit-hooks + rev: v5.0.0 + hooks: + - id: check-executables-have-shebangs + - id: check-json + - id: check-merge-conflict + - id: check-shebang-scripts-are-executable + - id: check-toml + - id: check-yaml + - id: end-of-file-fixer + - id: mixed-line-ending + args: ["--fix=lf"] + - id: requirements-txt-fixer + - id: trailing-whitespace + - repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.8.6 + hooks: + - id: ruff + args: ["--fix"] + - repo: https://github.com/pre-commit/mirrors-mypy + rev: v1.14.1 + hooks: + - id: mypy + args: ["--ignore-missing-imports"] + additional_dependencies: + [ + "types-python-slugify", + "types-requests", + "types-PyYAML", + "types-pytz", + ] diff --git a/.python-version b/.python-version new file mode 100644 index 0000000000000000000000000000000000000000..c8cfe3959183f8e9a50f83f54cd723f2dc9c252d --- /dev/null +++ b/.python-version @@ -0,0 +1 @@ +3.10 diff --git a/.vscode/extensions.json b/.vscode/extensions.json new file mode 100644 index 0000000000000000000000000000000000000000..854d34838a8695341a86e1cfa239be0014098058 --- /dev/null +++ b/.vscode/extensions.json @@ -0,0 +1,8 @@ +{ + "recommendations": [ + "ms-python.python", + "charliermarsh.ruff", + "streetsidesoftware.code-spell-checker", + "tamasfe.even-better-toml" + ] +} diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000000000000000000000000000000000000..6b1ad68d2449998e1085249c2f4828e886ff47e5 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,16 @@ +{ + "editor.formatOnSave": true, + "files.insertFinalNewline": false, + "[python]": { + "editor.defaultFormatter": "charliermarsh.ruff", + "editor.formatOnType": true, + "editor.codeActionsOnSave": { + "source.fixAll.ruff": "explicit" + } + }, + "[jupyter]": { + "files.insertFinalNewline": false + }, + "notebook.output.scrolling": true, + "notebook.formatOnSave.enabled": true +} diff --git a/Dockerfile b/Dockerfile deleted file mode 100644 index e59891ff7cc6e52fca61e0e2c8054d303db6f2d3..0000000000000000000000000000000000000000 --- a/Dockerfile +++ /dev/null @@ -1,104 +0,0 @@ -# Multi-stage build for AnyCoder Docker Space - -# Stage 1: Build frontend -FROM node:18-slim AS frontend-builder - -WORKDIR /build - -# Copy frontend package files -COPY frontend/package*.json ./ -RUN npm ci - -# Copy all frontend source files and configs -COPY frontend/src ./src -COPY frontend/public ./public -COPY frontend/next.config.js ./ -COPY frontend/tsconfig.json ./ -COPY frontend/tailwind.config.js ./ -COPY frontend/postcss.config.js ./ -# Note: next-env.d.ts is auto-generated by Next.js, not needed for build - -# Build frontend -RUN npm run build - -# Stage 2: Production image -FROM python:3.11-slim - -# Install system dependencies as root (git for pip, nodejs for frontend) -RUN apt-get update && \ - apt-get install -y --no-install-recommends \ - git \ - nodejs \ - npm \ - && rm -rf /var/lib/apt/lists/* - -# Set up a new user named "user" with user ID 1000 -RUN useradd -m -u 1000 user - -# Switch to the "user" user -USER user - -# Set home to the user's home directory -ENV HOME=/home/user \ - PATH=/home/user/.local/bin:$PATH \ - PYTHONUNBUFFERED=1 - -# Set the working directory to the user's home directory -WORKDIR $HOME/app - -# Copy Python requirements and install dependencies -COPY --chown=user:user requirements.txt . -RUN pip install --no-cache-dir --upgrade pip && \ - pip install --no-cache-dir -r requirements.txt - -# Copy application code -COPY --chown=user:user anycoder_app/ ./anycoder_app/ -COPY --chown=user:user backend_api.py . -COPY --chown=user:user backend_models.py . -COPY --chown=user:user backend_prompts.py . -COPY --chown=user:user backend_deploy.py . -COPY --chown=user:user project_importer.py . -COPY --chown=user:user app.py . - -# Copy built frontend from builder stage -COPY --chown=user:user --from=frontend-builder /build/.next ./frontend/.next -COPY --chown=user:user --from=frontend-builder /build/public ./frontend/public -COPY --chown=user:user --from=frontend-builder /build/package*.json ./frontend/ -COPY --chown=user:user --from=frontend-builder /build/next.config.js ./frontend/ -COPY --chown=user:user --from=frontend-builder /build/node_modules ./frontend/node_modules - -# Set environment variables for the application -# BACKEND_HOST is used by Next.js server for proxying -# Do NOT set NEXT_PUBLIC_API_URL - let frontend use relative URLs -ENV BACKEND_HOST=http://localhost:8000 \ - PORT=7860 - -# Create startup script that runs both services -# Backend on 8000, Frontend on 7860 (exposed port) -RUN echo '#!/bin/bash\n\ -set -e\n\ -\n\ -echo "šŸš€ Starting AnyCoder Docker Space..."\n\ -\n\ -# Start backend on port 8000 in background\n\ -echo "šŸ“” Starting FastAPI backend on port 8000..."\n\ -cd $HOME/app\n\ -uvicorn backend_api:app --host 0.0.0.0 --port 8000 &\n\ -BACKEND_PID=$!\n\ -\n\ -# Wait for backend to be ready\n\ -echo "ā³ Waiting for backend to start..."\n\ -sleep 5\n\ -\n\ -# Start frontend on port 7860 (HF Spaces exposed port)\n\ -echo "šŸŽØ Starting Next.js frontend on port 7860..."\n\ -cd $HOME/app/frontend\n\ -PORT=7860 BACKEND_HOST=http://localhost:8000 npm start\n\ -' > $HOME/app/start.sh && chmod +x $HOME/app/start.sh - -# Expose port 7860 (HF Spaces default) -EXPOSE 7860 - -# Run the startup script -CMD ["./start.sh"] - diff --git a/README.md b/README.md index 53bc2bb18578733709089789cfdbb601264044bf..282f3700195e90b2e5a2446f8d96915eeb7cd3b9 100644 --- a/README.md +++ b/README.md @@ -1,143 +1,13 @@ --- -title: AnyCoder -emoji: šŸš€ -colorFrom: blue -colorTo: purple -sdk: docker -app_port: 7860 +title: Anycoder +emoji: šŸ¢ +colorFrom: indigo +colorTo: indigo +sdk: gradio +sdk_version: 5.23.3 +app_file: app.py pinned: false -disable_embedding: false -hf_oauth: true -hf_oauth_scopes: - - manage-repos +disable_embedding: true --- -> **Note:** This is the Docker Space configuration for the React frontend version. -> For the original Gradio app, see `README_GRADIO.md`. - -# AnyCoder - AI Code Generator with React Frontend - -AnyCoder is a full-stack AI-powered code generator with a modern React/TypeScript frontend and FastAPI backend. Generate applications by describing them in plain English, with support for multiple AI models and one-click deployment to Hugging Face Spaces. - -## šŸŽØ Features - -- **Modern React UI**: Apple-inspired design with VS Code layout -- **Real-time Streaming**: Server-Sent Events for live code generation -- **Multi-Model Support**: MiniMax M2, DeepSeek V3, and more via HuggingFace InferenceClient -- **Multiple Languages**: HTML, Gradio, Streamlit, React, Transformers.js, ComfyUI -- **Authentication**: HuggingFace OAuth + Dev mode for local testing -- **One-Click Deployment**: Deploy generated apps directly to HF Spaces - -## šŸ—ļø Architecture - -``` -anycoder/ -ā”œā”€ā”€ backend_api.py # FastAPI backend with streaming -ā”œā”€ā”€ frontend/ # Next.js React frontend -ā”‚ ā”œā”€ā”€ src/ -ā”‚ ā”‚ ā”œā”€ā”€ app/ # Pages (page.tsx, layout.tsx, globals.css) -ā”‚ ā”‚ ā”œā”€ā”€ components/ # React components -ā”‚ ā”‚ ā”œā”€ā”€ lib/ # API client, auth utilities -ā”‚ ā”‚ ā””ā”€ā”€ types/ # TypeScript types -ā”‚ ā””ā”€ā”€ package.json -ā”œā”€ā”€ anycoder_app/ # Original Gradio app modules -ā”‚ ā”œā”€ā”€ agent.py -ā”‚ ā”œā”€ā”€ config.py -ā”‚ ā”œā”€ā”€ deploy.py -ā”‚ ā””ā”€ā”€ ... -ā”œā”€ā”€ app.py # Original Gradio interface -ā”œā”€ā”€ requirements.txt # Python dependencies -ā”œā”€ā”€ Dockerfile # Docker Space configuration -ā””ā”€ā”€ start_fullstack.sh # Local development script -``` - -## šŸš€ Quick Start - -### Local Development - -1. **Backend**: -```bash -export HF_TOKEN="your_huggingface_token" -export GEMINI_API_KEY="your_gemini_api_key" -python backend_api.py -``` - -2. **Frontend** (new terminal): -```bash -cd frontend -npm install -npm run dev -``` - -3. Open `http://localhost:3000` - -### Using start script: -```bash -export HF_TOKEN="your_token" -export GEMINI_API_KEY="your_gemini_api_key" -./start_fullstack.sh -``` - -## šŸ³ Docker Space Deployment - -This app runs as a Docker Space on HuggingFace. The Dockerfile: -- Builds the Next.js frontend -- Runs FastAPI backend on port 7860 -- Uses proper user permissions (UID 1000) -- Handles environment variables securely - -## šŸ”‘ Authentication - -- **Dev Mode** (localhost): Mock login for testing -- **Production**: HuggingFace OAuth with manage-repos scope - -## šŸ“ Supported Languages - -- `html` - Static HTML pages -- `gradio` - Python Gradio apps -- `streamlit` - Python Streamlit apps -- `react` - React/Next.js apps -- `transformers.js` - Browser ML apps -- `comfyui` - ComfyUI workflows - -## šŸ¤– Available Models - -- **Gemini 3 Pro Preview** (Default) - Google's latest with deep thinking & Google Search -- MiniMax M2 (via HF router with Novita) -- DeepSeek V3/V3.1 -- DeepSeek R1 -- And more via HuggingFace InferenceClient - -## šŸŽÆ Usage - -1. Sign in with HuggingFace (or use Dev Login locally) -2. Select a language and AI model -3. Describe your app in the chat -4. Watch code generate in real-time -5. Click **šŸš€ Deploy** to publish to HF Spaces - -## šŸ› ļø Environment Variables - -- `HF_TOKEN` - HuggingFace API token (required) -- `GEMINI_API_KEY` - Google Gemini API key (required for Gemini 3 Pro Preview) -- `POE_API_KEY` - Poe API key (optional, for GPT-5 and Claude models) -- `DASHSCOPE_API_KEY` - DashScope API key (optional, for Qwen models) -- `OPENROUTER_API_KEY` - OpenRouter API key (optional, for Sherlock models) -- `MISTRAL_API_KEY` - Mistral API key (optional, for Mistral models) - -## šŸ“¦ Tech Stack - -**Frontend:** -- Next.js 14 -- TypeScript -- Tailwind CSS -- Monaco Editor - -**Backend:** -- FastAPI -- HuggingFace Hub -- Server-Sent Events (SSE) - -## šŸ“„ License - -MIT +Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference \ No newline at end of file diff --git a/README_GRADIO.md b/README_GRADIO.md deleted file mode 100644 index 86bd6c2c80087529838443759c665c0b7f86103d..0000000000000000000000000000000000000000 --- a/README_GRADIO.md +++ /dev/null @@ -1,145 +0,0 @@ ---- -title: Anycoder -emoji: šŸ”„ -colorFrom: indigo -colorTo: indigo -sdk: gradio -sdk_version: 5.49.1 -app_file: app.py -pinned: false -disable_embedding: true -hf_oauth: true -hf_oauth_scopes: -- manage-repos ---- - -# AnyCoder - AI Code Generator - -> **šŸ“± New:** A React/TypeScript frontend version is now the default! This file is the backup Gradio version. For the Docker Space with modern React UI, see `README.md`. - -AnyCoder is an AI-powered code generator that helps you create applications by describing them in plain English. It supports multiple AI models, multimodal input, website redesign, and one-click deployment to Hugging Face Spaces. The UI is built with Gradio theming for a minimal, modern experience. - -## Features - -- **Multi-Model Support**: Choose from Moonshot Kimi-K2, Kimi K2 Turbo (Preview), Kimi K2 Thinking, DeepSeek V3, DeepSeek R1, ERNIE-4.5-VL, MiniMax M2, Qwen3-235B-A22B, Qwen3-30B-A3B-Instruct-2507, Qwen3-30B-A3B-Thinking-2507, SmolLM3-3B, GLM-4.1V-9B-Thinking, Gemini 2.5 Flash and Gemini 2.5 Pro (OpenAI-compatible) - - Claude-Opus-4.1 (via Poe) -- **Flexible Input**: Describe your app in text, upload a UI design image (for multimodal models), provide a reference file (PDF, TXT, MD, CSV, DOCX, or image), or enter a website URL for redesign -- **Web Search Integration**: Enable real-time web search (Tavily, with advanced search depth) to enhance code generation with up-to-date information and best practices -- **Code Generation**: Generate code in HTML, Python, JS, and more. Special support for transformers.js apps (outputs index.html, index.js, style.css) -- **Live Preview**: Instantly preview generated HTML in a sandboxed iframe -- **Modify Existing Code**: Use search/replace block format to update generated HTML -- **One-Click Deployment**: Deploy your app to Hugging Face Spaces (Gradio, Streamlit, Static HTML, or Transformers.js) with OAuth login -- **History & Examples**: Chat-like history of all interactions and quick example prompts for fast prototyping -- **Minimal, Modern UI**: Built with Gradio 5.x, using only built-in theming and styling (no custom CSS) - -## Installation - -1. Clone the repository: -```bash -git clone -cd anycoder -``` -2. Install dependencies: -```bash -pip install -r requirements.txt -``` -3. Set up environment variables: -```bash -export HF_TOKEN="your_huggingface_token" -export DASHSCOPE_API_KEY="your_dashscope_api_key" # Required for Qwen3-30B models via DashScope -export POE_API_KEY="your_poe_api_key" # Required for GPT-5, Grok-4, and Grok-Code-Fast-1 via Poe -export GEMINI_API_KEY="your_gemini_api_key" # Required for Gemini models -export MOONSHOT_API_KEY="your_moonshot_api_key" # Required for Kimi models -export MINIMAX_API_KEY="your_minimax_api_key" # Required for MiniMax M2 model -``` - -## Usage - -1. Run the application: -```bash -python app.py -``` -2. Open your browser and navigate to the provided URL -3. Describe your application in the text input field, or: - - Upload a UI design image (for multimodal models) - - Upload a reference file (PDF, TXT, MD, CSV, DOCX, or image) - - Enter a website URL for redesign (the app will extract and analyze the HTML and content) - - Enable web search for up-to-date information - - Choose a different AI model or code language -4. Click "Generate" to create your code -5. View the generated code in the Code tab or see it in action in the Preview tab -6. Use the History tab to review previous generations -7. **Deploy to Space**: Enter a title and click "šŸš€ Deploy App" to publish your application (OAuth login required) - the SDK is automatically matched to your selected code language - -## Supported Models - -- Moonshot Kimi-K2 -- Kimi K2 Turbo (Preview) -- Kimi K2 Thinking -- DeepSeek V3 -- DeepSeek V3.1 -- DeepSeek V3.1 Terminus -- DeepSeek V3.2-Exp -- DeepSeek R1 -- MiniMax M2 -- Qwen3-235B-A22B -- Qwen3-4B-Instruct-2507 -- Qwen3-4B-Thinking-2507 -- Qwen3-30B-A3B-Instruct-2507 (via DashScope) -- Qwen3-30B-A3B-Thinking-2507 (via DashScope) -- GPT-5 (via Poe) -- Grok-4 (via Poe) - - Claude-Opus-4.1 (via Poe) - - Gemini 2.5 Flash (OpenAI-compatible) - - Gemini 2.5 Pro (OpenAI-compatible) - -## Input Options - -- **Text Prompt**: Describe your app or code requirements -- **Image Upload**: For multimodal models, upload a UI design image to generate code from visuals -- **File Upload**: Provide a reference file (PDF, TXT, MD, CSV, DOCX, or image) for code generation or text extraction (OCR for images) -- **Website URL**: Enter a URL to extract and redesign the website (HTML and content are analyzed and modernized) - -## Code Generation & Modification - -- Generates code in HTML, Python, JS, and more (selectable via dropdown) -- Special support for transformers.js apps (outputs index.html, index.js, style.css) -- Svelte apps -- For HTML, provides a live preview in a sandboxed iframe -- For modification requests, uses a search/replace block format to update existing HTML - -## Deployment - -- Deploy generated apps to Hugging Face Spaces directly from the UI -- Supported SDKs: Gradio (Python), Streamlit (Python), Static (HTML), Transformers.js -- OAuth login with Hugging Face is required for deployment to user-owned Spaces - -## History & Examples - -- Maintains a chat-like history of user/assistant interactions -- Quick example prompts are available in the sidebar for fast prototyping - -## UI/UX - -- Built with Gradio 5.x, using only Gradio's built-in theming and styling (no custom CSS) -- Minimal, uncluttered sidebar and interface - -## Environment Variables - -- `HF_TOKEN`: Your Hugging Face API token (required) - - `GEMINI_API_KEY`: Your Google Gemini API key (required to use Gemini models) -- `MOONSHOT_API_KEY`: Your Moonshot AI API key (required to use Kimi models) -- `MINIMAX_API_KEY`: Your MiniMax API key (required to use MiniMax M2 model) - -## Project Structure - -``` -anycoder/ -ā”œā”€ā”€ app.py # Main application (all logic and UI) -ā”œā”€ā”€ requirements.txt -ā”œā”€ā”€ README.md # This file -``` - -## License - -[Add your license information here] \ No newline at end of file diff --git a/anycoder_app/__init__.py b/anycoder_app/__init__.py deleted file mode 100644 index 300c03ffafa027c87bd5bcdb70261c05690d6505..0000000000000000000000000000000000000000 --- a/anycoder_app/__init__.py +++ /dev/null @@ -1,27 +0,0 @@ -""" -AnyCoder - AI Code Generator Package -Modular structure for better code organization and maintainability. -""" - -__version__ = "1.0.0" - -from . import config -from . import prompts -from . import docs_manager -from . import models -from . import parsers -from . import deploy -from . import themes -from . import ui - -__all__ = [ - "config", - "prompts", - "docs_manager", - "models", - "parsers", - "deploy", - "themes", - "ui", -] - diff --git a/anycoder_app/agent.py b/anycoder_app/agent.py deleted file mode 100644 index 74b8f460889ad53151d7fbd5ac5f4cb229ea11d7..0000000000000000000000000000000000000000 --- a/anycoder_app/agent.py +++ /dev/null @@ -1,234 +0,0 @@ -""" -Agent functionality for interactive code generation with follow-up questions and task planning. -""" -import os -from typing import Dict, List, Optional, Tuple, Generator -import gradio as gr - -from .models import ( - get_inference_client, get_real_model_id, history_to_messages, - history_to_chatbot_messages, strip_thinking_tags -) -from .deploy import generation_code - - -def agent_generate_with_questions( - query: Optional[str], - setting: Dict[str, str], - history: List, - current_model: Dict, - language: str, - provider: str, - profile: Optional[gr.OAuthProfile] = None, - token: Optional[gr.OAuthToken] = None, - max_questions: int = 3 -) -> Generator[Tuple[List, List], None, None]: - """ - Agent that asks follow-up questions, creates a task list, and generates code. - - Args: - query: Initial user request - setting: System settings - history: Conversation history - current_model: Selected model configuration - language: Target programming language/framework - provider: Model provider - profile: User OAuth profile - token: User OAuth token - max_questions: Maximum number of follow-up questions to ask - - Yields: - Tuples of (history, chatbot_messages) at each step - """ - if not query or not query.strip(): - return - - # Initialize history with user's initial query - current_history = history + [[query, ""]] - - # Step 1: Agent analyzes the request and asks follow-up questions - agent_system_prompt = """You are a helpful coding assistant that helps users clarify their requirements before generating code. - -Your task is to: -1. Analyze the user's request -2. Ask 1-3 clarifying questions to better understand their needs -3. Focus on important details like: - - Target audience and use case - - Specific features or functionality needed - - Design preferences (colors, layout, style) - - Data sources or APIs to integrate - - Performance or scalability requirements - -Output ONLY the questions, numbered 1, 2, 3, etc. Keep questions concise and focused. -Do not generate code yet - just ask the questions.""" - - # Get LLM client - client = get_inference_client(current_model.get('model_id', 'Qwen/Qwen2.5-Coder-32B-Instruct'), provider) - model_id = get_real_model_id(current_model.get('model_id', 'Qwen/Qwen2.5-Coder-32B-Instruct')) - - # Prepare messages for follow-up questions - messages = [ - {'role': 'system', 'content': agent_system_prompt}, - {'role': 'user', 'content': f"User wants to create: {query}\n\nLanguage/Framework: {language}\n\nAsk clarifying questions."} - ] - - # Generate follow-up questions - questions_response = "" - try: - # Try to use the client (works for both InferenceClient and OpenAI-compatible clients) - stream = client.chat.completions.create( - model=model_id, - messages=messages, - temperature=0.7, - max_tokens=500, - stream=True - ) - for chunk in stream: - if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content: - questions_response += chunk.choices[0].delta.content - # Update display in real-time - temp_history = current_history[:-1] + [[query, f"šŸ¤” **Analyzing your request...**\n\n{questions_response}"]] - yield (temp_history, history_to_chatbot_messages(temp_history)) - except Exception as e: - error_msg = f"āŒ Error asking follow-up questions: {str(e)}" - temp_history = current_history[:-1] + [[query, error_msg]] - yield (temp_history, history_to_chatbot_messages(temp_history)) - return - - # Update history with agent's questions - current_history[-1][1] = f"šŸ¤” **Let me ask you a few questions to better understand your needs:**\n\n{questions_response}\n\nšŸ’¬ Please answer these questions in your next message." - yield (current_history, history_to_chatbot_messages(current_history)) - - # Wait for user response (this will be handled by the UI) - # For now, we'll return and let the user respond, then continue in the next call - return - - -def agent_process_answers_and_generate( - user_answers: str, - original_query: str, - questions: str, - setting: Dict[str, str], - history: List, - current_model: Dict, - language: str, - provider: str, - profile: Optional[gr.OAuthProfile] = None, - token: Optional[gr.OAuthToken] = None, - code_output=None, - history_output=None, - history_state=None -) -> Generator: - """ - Process user's answers, create task list, and generate code. - - Args: - user_answers: User's responses to the questions - original_query: Original user request - questions: Agent's questions - setting: System settings - history: Conversation history - current_model: Selected model configuration - language: Target programming language/framework - provider: Model provider - profile: User OAuth profile - token: User OAuth token - code_output: Code output component - history_output: History output component - history_state: History state - - Yields: - Updates to code output and history - """ - # Step 2: Create task list based on answers - task_planning_prompt = f"""Based on the user's request and their answers, create a detailed task list for implementing the solution. - -Original Request: {original_query} - -Questions Asked: -{questions} - -User's Answers: -{user_answers} - -Create a numbered task list with 5-8 specific, actionable tasks. Each task should be clear and focused. -Start with "šŸ“‹ **Task List:**" and then list the tasks.""" - - client = get_inference_client(current_model.get('model_id', 'Qwen/Qwen2.5-Coder-32B-Instruct'), provider) - model_id = get_real_model_id(current_model.get('model_id', 'Qwen/Qwen2.5-Coder-32B-Instruct')) - - messages = [ - {'role': 'system', 'content': 'You are a helpful coding assistant creating a task plan.'}, - {'role': 'user', 'content': task_planning_prompt} - ] - - # Generate task list - task_list = "" - try: - stream = client.chat.completions.create( - model=model_id, - messages=messages, - temperature=0.7, - max_tokens=800, - stream=True - ) - for chunk in stream: - if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content: - task_list += chunk.choices[0].delta.content - # Update display - temp_history = history + [[user_answers, f"šŸ“‹ **Creating task list...**\n\n{task_list}"]] - yield { - history_state: temp_history, - history_output: history_to_chatbot_messages(temp_history) - } - except Exception as e: - error_msg = f"āŒ Error creating task list: {str(e)}" - temp_history = history + [[user_answers, error_msg]] - yield { - history_state: temp_history, - history_output: history_to_chatbot_messages(temp_history) - } - return - - # Update history with task list - updated_history = history + [[user_answers, task_list]] - yield { - history_state: updated_history, - history_output: history_to_chatbot_messages(updated_history) - } - - # Step 3: Generate code based on refined requirements - refined_query = f"""{original_query} - -Additional Requirements (based on follow-up): -{user_answers} - -Task List: -{task_list} - -Please implement the above requirements following the task list.""" - - # Add a message indicating code generation is starting - code_gen_start_history = updated_history + [["[System]", "šŸš€ **Starting code generation based on your requirements...**"]] - yield { - history_state: code_gen_start_history, - history_output: history_to_chatbot_messages(code_gen_start_history) - } - - # Use the existing generation_code function for actual code generation - # We need to pass the refined query and updated history - for result in generation_code( - refined_query, - setting, - updated_history, - current_model, - language, - provider, - profile, - token, - code_output, - history_output, - history_state - ): - yield result - diff --git a/anycoder_app/config.py b/anycoder_app/config.py deleted file mode 100644 index eceb87b2361028d6db55b59d732f7e5a7f2fdd60..0000000000000000000000000000000000000000 --- a/anycoder_app/config.py +++ /dev/null @@ -1,190 +0,0 @@ -""" -Configuration constants for AnyCoder application. -""" -import os -from datetime import datetime -from typing import Optional - -# Gradio supported languages for syntax highlighting -GRADIO_SUPPORTED_LANGUAGES = [ - "python", "json", "html", "javascript" -] - -# Search/Replace Constants -SEARCH_START = "<<<<<<< SEARCH" -DIVIDER = "=======" -REPLACE_END = ">>>>>>> REPLACE" - -# Gradio Documentation Auto-Update System -GRADIO_LLMS_TXT_URL = "https://www.gradio.app/llms.txt" -GRADIO_DOCS_CACHE_FILE = ".gradio_docs_cache.txt" -GRADIO_DOCS_LAST_UPDATE_FILE = ".gradio_docs_last_update.txt" -GRADIO_DOCS_UPDATE_ON_APP_UPDATE = True # Only update when app is updated, not on a timer - -# Global variable to store the current Gradio documentation -_gradio_docs_content: Optional[str] = None -_gradio_docs_last_fetched: Optional[datetime] = None - -# ComfyUI Documentation Auto-Update System -COMFYUI_LLMS_TXT_URL = "https://docs.comfy.org/llms.txt" -COMFYUI_DOCS_CACHE_FILE = ".comfyui_docs_cache.txt" -COMFYUI_DOCS_LAST_UPDATE_FILE = ".comfyui_docs_last_update.txt" -COMFYUI_DOCS_UPDATE_ON_APP_UPDATE = True # Only update when app is updated, not on a timer - -# Global variable to store the current ComfyUI documentation -_comfyui_docs_content: Optional[str] = None -_comfyui_docs_last_fetched: Optional[datetime] = None - -# FastRTC Documentation Auto-Update System -FASTRTC_LLMS_TXT_URL = "https://fastrtc.org/llms.txt" -FASTRTC_DOCS_CACHE_FILE = ".fastrtc_docs_cache.txt" -FASTRTC_DOCS_LAST_UPDATE_FILE = ".fastrtc_docs_last_update.txt" -FASTRTC_DOCS_UPDATE_ON_APP_UPDATE = True # Only update when app is updated, not on a timer - -# Global variable to store the current FastRTC documentation -_fastrtc_docs_content: Optional[str] = None -_fastrtc_docs_last_fetched: Optional[datetime] = None - -# Available Models Configuration -AVAILABLE_MODELS = [ - { - "name": "Gemini 3.0 Pro", - "id": "gemini-3.0-pro", - "description": "Google Gemini 3.0 Pro via Poe with advanced reasoning" - }, - { - "name": "DeepSeek V3.2-Exp", - "id": "deepseek-ai/DeepSeek-V3.2-Exp", - "description": "DeepSeek V3.2 Experimental model for cutting-edge code generation and reasoning" - }, - { - "name": "DeepSeek R1", - "id": "deepseek-ai/DeepSeek-R1-0528", - "description": "DeepSeek R1 model for code generation" - }, - { - "name": "GLM-4.6", - "id": "zai-org/GLM-4.6", - "description": "GLM-4.6 model for advanced code generation and general tasks" - }, - { - "name": "Gemini Flash Latest", - "id": "gemini-flash-latest", - "description": "Google Gemini Flash Latest model via native Gemini API" - }, - { - "name": "Gemini Flash Lite Latest", - "id": "gemini-flash-lite-latest", - "description": "Google Gemini Flash Lite Latest model via OpenAI-compatible API" - }, - { - "name": "GPT-5", - "id": "gpt-5", - "description": "OpenAI GPT-5 model for advanced code generation and general tasks" - }, - { - "name": "GPT-5.1", - "id": "gpt-5.1", - "description": "OpenAI GPT-5.1 model via Poe for advanced code generation and general tasks" - }, - { - "name": "GPT-5.1 Instant", - "id": "gpt-5.1-instant", - "description": "OpenAI GPT-5.1 Instant model via Poe for fast responses" - }, - { - "name": "GPT-5.1 Codex", - "id": "gpt-5.1-codex", - "description": "OpenAI GPT-5.1 Codex model via Poe optimized for code generation" - }, - { - "name": "GPT-5.1 Codex Mini", - "id": "gpt-5.1-codex-mini", - "description": "OpenAI GPT-5.1 Codex Mini model via Poe for lightweight code generation" - }, - { - "name": "Grok-4", - "id": "grok-4", - "description": "Grok-4 model via Poe (OpenAI-compatible) for advanced tasks" - }, - { - "name": "Grok-Code-Fast-1", - "id": "Grok-Code-Fast-1", - "description": "Grok-Code-Fast-1 model via Poe (OpenAI-compatible) for fast code generation" - }, - { - "name": "Claude-Opus-4.1", - "id": "claude-opus-4.1", - "description": "Anthropic Claude Opus 4.1 via Poe (OpenAI-compatible)" - }, - { - "name": "Claude-Sonnet-4.5", - "id": "claude-sonnet-4.5", - "description": "Anthropic Claude Sonnet 4.5 via Poe (OpenAI-compatible)" - }, - { - "name": "Claude-Haiku-4.5", - "id": "claude-haiku-4.5", - "description": "Anthropic Claude Haiku 4.5 via Poe (OpenAI-compatible)" - }, - { - "name": "Qwen3 Max Preview", - "id": "qwen3-max-preview", - "description": "Qwen3 Max Preview model via DashScope International API" - }, - { - "name": "MiniMax M2", - "id": "MiniMaxAI/MiniMax-M2", - "description": "MiniMax M2 model via HuggingFace InferenceClient with Novita provider" - }, - { - "name": "Kimi K2 Thinking", - "id": "moonshotai/Kimi-K2-Thinking", - "description": "Moonshot Kimi K2 Thinking model for advanced reasoning and code generation" - }, - { - "name": "Grok 4.1 Fast", - "id": "x-ai/grok-4.1-fast", - "description": "Grok 4.1 Fast model via OpenRouter for advanced code generation and reasoning" - }, - { - "name": "Sherlock Think Alpha", - "id": "openrouter/sherlock-think-alpha", - "description": "Sherlock Think Alpha model via OpenRouter for advanced reasoning with thinking capabilities" - } -] - -k2_model_name_tag = "moonshotai/Kimi-K2-Thinking" - -# Default model selection -DEFAULT_MODEL_NAME = "MiniMax M2" -DEFAULT_MODEL = None -for _m in AVAILABLE_MODELS: - if _m.get("name") == DEFAULT_MODEL_NAME: - DEFAULT_MODEL = _m - break -if DEFAULT_MODEL is None and AVAILABLE_MODELS: - DEFAULT_MODEL = AVAILABLE_MODELS[0] - -# HF Inference Client -HF_TOKEN = os.getenv('HF_TOKEN') -# Note: HF_TOKEN is checked at runtime when needed, not at import time - -# Language choices for code generation -LANGUAGE_CHOICES = [ - "html", "gradio", "transformers.js", "streamlit", "comfyui", "react" -] - - -def get_gradio_language(language): - """Map composite options to a supported syntax highlighting.""" - if language == "streamlit": - return "python" - if language == "gradio": - return "python" - if language == "comfyui": - return "json" - if language == "react": - return "javascript" - return language if language in GRADIO_SUPPORTED_LANGUAGES else None - diff --git a/anycoder_app/deploy.py b/anycoder_app/deploy.py deleted file mode 100644 index 879800a4e1fdf6212b1dc8f2487d73e14ffeb5c9..0000000000000000000000000000000000000000 --- a/anycoder_app/deploy.py +++ /dev/null @@ -1,2583 +0,0 @@ -""" -Deployment utilities for publishing to HuggingFace Spaces. -Handles authentication, space creation, and code deployment. -""" -import os -import re -import json -import uuid -import tempfile -import shutil -from typing import Dict, List, Optional, Tuple -from urllib.parse import urlparse -import requests -from bs4 import BeautifulSoup -import html2text - -import gradio as gr -from huggingface_hub import HfApi, InferenceClient -from openai import OpenAI - -from .config import HF_TOKEN, get_gradio_language -from .parsers import ( - parse_transformers_js_output, parse_multipage_html_output, - parse_multi_file_python_output, parse_react_output, - remove_code_block, is_streamlit_code, is_gradio_code, - clean_requirements_txt_content, History, - format_transformers_js_output, build_transformers_inline_html, - send_transformers_to_sandbox, validate_and_autofix_files, - inline_multipage_into_single_preview, apply_search_replace_changes, - apply_transformers_js_search_replace_changes, send_to_sandbox, - format_multi_file_python_output, send_streamlit_to_stlite, - send_gradio_to_lite, extract_html_document -) -from .models import ( - get_inference_client, get_real_model_id, history_to_messages, - history_to_chatbot_messages, strip_placeholder_thinking, - is_placeholder_thinking_only, extract_last_thinking_line, - strip_thinking_tags -) -from . import prompts -from .prompts import ( - HTML_SYSTEM_PROMPT, - TRANSFORMERS_JS_SYSTEM_PROMPT, STREAMLIT_SYSTEM_PROMPT, - REACT_SYSTEM_PROMPT, REACT_FOLLOW_UP_SYSTEM_PROMPT, - JSON_SYSTEM_PROMPT, - GENERIC_SYSTEM_PROMPT, MULTIPAGE_HTML_SYSTEM_PROMPT, - DYNAMIC_MULTIPAGE_HTML_SYSTEM_PROMPT, - FollowUpSystemPrompt, GradioFollowUpSystemPrompt, - TransformersJSFollowUpSystemPrompt -) -from .docs_manager import get_comfyui_system_prompt, update_gradio_system_prompts, update_json_system_prompts - - -def check_authentication(profile: Optional[gr.OAuthProfile] = None, token: Optional[gr.OAuthToken] = None) -> Tuple[bool, str]: - """Check if user is authenticated and return status with message.""" - if not profile or not token: - return False, "Please log in with your Hugging Face account to use AnyCoder." - - if not token.token: - return False, "Authentication token is invalid. Please log in again." - - return True, f"Authenticated as {profile.username}" - - -def update_ui_for_auth_status(profile: Optional[gr.OAuthProfile] = None, token: Optional[gr.OAuthToken] = None): - """Update UI components based on authentication status.""" - is_authenticated, auth_message = check_authentication(profile, token) - - if is_authenticated: - # User is authenticated - enable all components - return ( - gr.update(interactive=True, placeholder="Describe your application..."), # input - gr.update(interactive=True, variant="primary") # btn - ) - else: - # User not authenticated - disable main components - return ( - gr.update( - interactive=False, - placeholder="šŸ”’ Click Sign in with Hugging Face button to use AnyCoder for free" - ), # input - gr.update(interactive=False, variant="secondary") # btn - ) - - -def generation_code(query: Optional[str], _setting: Dict[str, str], _history: Optional[History], _current_model: Dict, language: str = "html", provider: str = "auto", profile: Optional[gr.OAuthProfile] = None, token: Optional[gr.OAuthToken] = None, code_output=None, history_output=None, history=None): - # Check authentication first - is_authenticated, auth_message = check_authentication(profile, token) - if not is_authenticated: - error_message = f"šŸ”’ Authentication Required\n\n{auth_message}\n\nPlease click the 'Sign in with Hugging Face' button in the sidebar to continue." - if code_output is not None and history_output is not None: - yield { - code_output: error_message, - history_output: history_to_chatbot_messages(_history or []), - } - else: - yield (error_message, _history or [], history_to_chatbot_messages(_history or [])) - return - - # CRITICAL: Catch any HuggingFace API errors for non-HF models like Gemini 3 - try: - yield from _generation_code_impl(query, _setting, _history, _current_model, language, provider, profile, token, code_output, history_output, history) - except Exception as e: - import traceback - error_str = str(e) - if "Repository Not Found" in error_str and "inferenceProviderMapping" in error_str: - # This is a HuggingFace API error for a non-HF model - model_id = _current_model.get('id', 'unknown') - - # Get full traceback to see where the call originated - tb = traceback.format_exc() - print(f"DEBUG: HuggingFace API error for model {model_id}") - print(f"DEBUG: Full traceback:\n{tb}") - - error_message = f"""āŒ Error: Attempted to validate model '{model_id}' against HuggingFace API, but this is not a HuggingFace model. - -This error should not occur. Please check the server logs for the full traceback. - -- Model: {model_id} -- Error: {error_str} - -Try reloading the page and selecting the model again.""" - if code_output is not None and history_output is not None: - yield { - code_output: error_message, - history_output: history_to_chatbot_messages(_history or []), - } - else: - yield (error_message, _history or [], history_to_chatbot_messages(_history or [])) - return - else: - # Re-raise other errors - raise - -def _generation_code_impl(query: Optional[str], _setting: Dict[str, str], _history: Optional[History], _current_model: Dict, language: str = "html", provider: str = "auto", profile: Optional[gr.OAuthProfile] = None, token: Optional[gr.OAuthToken] = None, code_output=None, history_output=None, history=None): - """Internal implementation of generation_code""" - - if query is None: - query = '' - if _history is None: - _history = [] - # Ensure _history is always a list of lists with at least 2 elements per item - if not isinstance(_history, list): - _history = [] - _history = [h for h in _history if isinstance(h, list) and len(h) == 2] - - # Check if there's existing content in history to determine if this is a modification request - has_existing_content = False - last_assistant_msg = "" - if _history and len(_history[-1]) > 1: - last_assistant_msg = _history[-1][1] - - # Check if this is imported model code (should NOT be treated as existing content to modify) - is_imported_model_code = ( - "Imported model:" in _history[-1][0] or - "Imported inference provider code" in last_assistant_msg or - "Imported transformers/diffusers code" in last_assistant_msg or - "Switched code type" in _history[-1][0] - ) - - # Only treat as existing content if it's NOT imported model code - if not is_imported_model_code: - # Check for various content types that indicate an existing project - if ('' in last_assistant_msg or - '>>>>>> REPLACE -2. The SEARCH block must match the existing code EXACTLY (including whitespace, indentation, line breaks) -3. The REPLACE block should contain the modified version -4. Only include the specific lines that need to change, with enough context to make them unique -5. Generate multiple search/replace blocks if needed for different changes -6. Do NOT include any explanations or comments outside the blocks - -Example format: -<<<<<<< SEARCH - function oldFunction() { - return "old"; - } -======= - function newFunction() { - return "new"; - } ->>>>>>> REPLACE""" - - user_prompt = f"""Existing code: -{last_assistant_msg} -Modification instructions: -{query} - -Generate the exact search/replace blocks needed to make these changes.""" - - messages = [ - {"role": "system", "content": system_prompt}, - {"role": "user", "content": user_prompt} - ] - - # Generate search/replace instructions - if _current_model.get('type') == 'openai': - response = client.chat.completions.create( - model=get_real_model_id(_current_model['id']), - messages=messages, - max_tokens=10000, - temperature=0.1 - ) - changes_text = response.choices[0].message.content - elif _current_model.get('type') == 'mistral': - response = client.chat.complete( - model=get_real_model_id(_current_model['id']), - messages=messages, - max_tokens=10000, - temperature=0.1 - ) - changes_text = response.choices[0].message.content - else: # Hugging Face or other - completion = client.chat.completions.create( - model=get_real_model_id(_current_model['id']), - messages=messages, - max_tokens=10000, - temperature=0.1 - ) - changes_text = completion.choices[0].message.content - - # Apply the search/replace changes - if language == "transformers.js" and ('=== index.html ===' in last_assistant_msg): - modified_content = apply_transformers_js_search_replace_changes(last_assistant_msg, changes_text) - else: - modified_content = apply_search_replace_changes(last_assistant_msg, changes_text) - - # If changes were successfully applied, return the modified content - if modified_content != last_assistant_msg: - _history.append([query, modified_content]) - - # Generate deployment message instead of preview - deploy_message = f""" -
-

āœ… Code Updated Successfully!

-

Your {language.upper()} code has been modified and is ready for deployment.

-

šŸ‘‰ Use the Deploy button in the sidebar to publish your app!

-
- """ - - yield { - code_output: modified_content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - return - - except Exception as e: - print(f"Search/replace failed, falling back to normal generation: {e}") - # If search/replace fails, continue with normal generation - - # Create/lookup a session id for temp-file tracking and cleanup - if _setting is not None and isinstance(_setting, dict): - session_id = _setting.get("__session_id__") - if not session_id: - session_id = str(uuid.uuid4()) - _setting["__session_id__"] = session_id - else: - session_id = str(uuid.uuid4()) - - # Update system prompts if needed - if language == "gradio": - update_gradio_system_prompts() - print(f"[Generation] Updated Gradio system prompt (length: {len(prompts.GRADIO_SYSTEM_PROMPT)} chars)") - elif language == "json": - update_json_system_prompts() - print(f"[Generation] Updated JSON system prompt (length: {len(prompts.JSON_SYSTEM_PROMPT)} chars)") - - # Choose system prompt based on context - # Special case: If user is asking about model identity, use neutral prompt - if query and any(phrase in query.lower() for phrase in ["what model are you", "who are you", "identify yourself", "what ai are you", "which model"]): - system_prompt = "You are a helpful AI assistant. Please respond truthfully about your identity and capabilities." - elif has_existing_content: - # Use follow-up prompt for modifying existing content - if language == "transformers.js": - system_prompt = TransformersJSFollowUpSystemPrompt - elif language == "gradio": - system_prompt = GradioFollowUpSystemPrompt - elif language == "react": - system_prompt = REACT_FOLLOW_UP_SYSTEM_PROMPT - else: - system_prompt = FollowUpSystemPrompt - else: - # Use language-specific prompt - if language == "html": - # Dynamic file selection always enabled - system_prompt = DYNAMIC_MULTIPAGE_HTML_SYSTEM_PROMPT - elif language == "transformers.js": - system_prompt = TRANSFORMERS_JS_SYSTEM_PROMPT - elif language == "react": - system_prompt = REACT_SYSTEM_PROMPT - elif language == "gradio": - # Access GRADIO_SYSTEM_PROMPT from prompts module to get updated value - system_prompt = prompts.GRADIO_SYSTEM_PROMPT - elif language == "streamlit": - system_prompt = STREAMLIT_SYSTEM_PROMPT - elif language == "json": - # Access JSON_SYSTEM_PROMPT from prompts module to get updated value - system_prompt = prompts.JSON_SYSTEM_PROMPT - elif language == "comfyui": - system_prompt = get_comfyui_system_prompt() - else: - system_prompt = GENERIC_SYSTEM_PROMPT.format(language=language) - - # Debug: Log system prompt info - prompt_preview = system_prompt[:200] if system_prompt else "None" - print(f"[Generation] Using system prompt (first 200 chars): {prompt_preview}...") - print(f"[Generation] System prompt total length: {len(system_prompt) if system_prompt else 0} chars") - - messages = history_to_messages(_history, system_prompt) - - # Use the original query without any enhancements - let the system prompt handle everything - enhanced_query = query - - # Check if this is GLM-4.5 model and handle with simple HuggingFace InferenceClient - if _current_model["id"] == "zai-org/GLM-4.5": - messages.append({'role': 'user', 'content': enhanced_query}) - - try: - client = InferenceClient( - provider="auto", - api_key=os.environ["HF_TOKEN"], - bill_to="huggingface", - ) - - stream = client.chat.completions.create( - model="zai-org/GLM-4.5", - messages=messages, - stream=True, - max_tokens=16384, - ) - - content = "" - for chunk in stream: - if chunk.choices[0].delta.content: - content += chunk.choices[0].delta.content - clean_code = remove_code_block(content) - # Show generation progress message - progress_message = f""" -
-

āš” Generating Your {language.upper()} App...

-

Code is being generated in real-time!

-
-

Get ready to deploy once generation completes!

-
-
- """ - yield { - code_output: gr.update(value=clean_code, language=get_gradio_language(language)), - history_output: history_to_chatbot_messages(_history), - } - - except Exception as e: - content = f"Error with GLM-4.5: {str(e)}\n\nPlease make sure HF_TOKEN environment variable is set." - - clean_code = remove_code_block(content) - - # Use clean code as final content without media generation - final_content = clean_code - - _history.append([query, final_content]) - - if language == "transformers.js": - files = parse_transformers_js_output(clean_code) - if files['index.html'] and files['index.js'] and files['style.css']: - formatted_output = format_transformers_js_output(files) - yield { - code_output: formatted_output, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - else: - yield { - code_output: clean_code, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - else: - if has_existing_content and not (clean_code.strip().startswith("") or clean_code.strip().startswith(" 1 else "" - modified_content = apply_search_replace_changes(last_content, clean_code) - clean_content = remove_code_block(modified_content) - - # Use clean content without media generation - - yield { - code_output: clean_content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - else: - # Use clean code as final content without media generation - final_content = clean_code - - # Generate deployment message instead of preview - deploy_message = f""" -
-

šŸŽ‰ Code Generated Successfully!

-

Your {language.upper()} application is ready to deploy!

- -
-

šŸš€ Next Steps:

-
-

- 1 - Use the Deploy button in the sidebar -

-

- 2 - Enter your app name below -

-

- 3 - Click "Publish" -

-

- 4 - Share your creation! šŸŒ -

-
-
- -

- šŸ’” Your app will be live on Hugging Face Spaces in seconds! -

-
- """ - - yield { - code_output: final_content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - return - - # Use dynamic client based on selected model - client = get_inference_client(_current_model["id"], provider) - - messages.append({'role': 'user', 'content': enhanced_query}) - try: - # Handle Mistral API method difference - if _current_model["id"] in ("codestral-2508", "mistral-medium-2508"): - completion = client.chat.stream( - model=get_real_model_id(_current_model["id"]), - messages=messages, - max_tokens=16384 - ) - - else: - # Poe expects model id "GPT-5" and uses max_tokens - if _current_model["id"] == "gemini-3.0-pro": - completion = client.chat.completions.create( - model="Gemini-3.0-Pro", - messages=messages, - stream=True, - max_tokens=20000 - ) - elif _current_model["id"] == "gpt-5": - completion = client.chat.completions.create( - model="GPT-5", - messages=messages, - stream=True, - max_tokens=16384 - ) - elif _current_model["id"] == "grok-4": - completion = client.chat.completions.create( - model="Grok-4", - messages=messages, - stream=True, - max_tokens=16384 - ) - elif _current_model["id"] == "claude-opus-4.1": - completion = client.chat.completions.create( - model="Claude-Opus-4.1", - messages=messages, - stream=True, - max_tokens=16384 - ) - elif _current_model["id"] == "claude-sonnet-4.5": - completion = client.chat.completions.create( - model="Claude-Sonnet-4.5", - messages=messages, - stream=True, - max_tokens=16384 - ) - elif _current_model["id"] == "claude-haiku-4.5": - completion = client.chat.completions.create( - model="Claude-Haiku-4.5", - messages=messages, - stream=True, - max_tokens=16384 - ) - else: - completion = client.chat.completions.create( - model=get_real_model_id(_current_model["id"]), - messages=messages, - stream=True, - max_tokens=16384 - ) - content = "" - # For Poe/GPT-5, maintain a simple code-fence state machine to only accumulate code - poe_inside_code_block = False - poe_partial_buffer = "" - for chunk in completion: - # Handle different response formats for Mistral vs others - chunk_content = None - if _current_model["id"] in ("codestral-2508", "mistral-medium-2508"): - # Mistral format: chunk.data.choices[0].delta.content - if ( - hasattr(chunk, "data") and chunk.data and - hasattr(chunk.data, "choices") and chunk.data.choices and - hasattr(chunk.data.choices[0], "delta") and - hasattr(chunk.data.choices[0].delta, "content") and - chunk.data.choices[0].delta.content is not None - ): - chunk_content = chunk.data.choices[0].delta.content - else: - # OpenAI format: chunk.choices[0].delta.content - if ( - hasattr(chunk, "choices") and chunk.choices and - hasattr(chunk.choices[0], "delta") and - hasattr(chunk.choices[0].delta, "content") and - chunk.choices[0].delta.content is not None - ): - chunk_content = chunk.choices[0].delta.content - - if chunk_content: - # Ensure chunk_content is always a string to avoid regex errors - if not isinstance(chunk_content, str): - # Handle structured thinking chunks (like ThinkChunk objects from magistral) - chunk_str = str(chunk_content) if chunk_content is not None else "" - if '[ThinkChunk(' in chunk_str: - # This is a structured thinking chunk, skip it to avoid polluting output - continue - chunk_content = chunk_str - - # Strip thinking tags and tool call markers from all streaming chunks - chunk_content = strip_thinking_tags(chunk_content) - if _current_model["id"] == "gpt-5": - # If this chunk is only placeholder thinking, surface a status update without polluting content - if is_placeholder_thinking_only(chunk_content): - status_line = extract_last_thinking_line(chunk_content) - yield { - code_output: gr.update(value=(content or "") + "\n", language="html"), - history_output: history_to_chatbot_messages(_history), - } - continue - # Filter placeholders - incoming = strip_placeholder_thinking(chunk_content) - # Process code fences incrementally, only keep content inside fences - s = poe_partial_buffer + incoming - append_text = "" - i = 0 - # Find all triple backticks positions - for m in re.finditer(r"```", s): - if not poe_inside_code_block: - # Opening fence. Require a newline to confirm full opener so we can skip optional language line - nl = s.find("\n", m.end()) - if nl == -1: - # Incomplete opener; buffer from this fence and wait for more - poe_partial_buffer = s[m.start():] - s = None - break - # Enter code, skip past newline after optional language token - poe_inside_code_block = True - i = nl + 1 - else: - # Closing fence, append content inside and exit code - append_text += s[i:m.start()] - poe_inside_code_block = False - i = m.end() - if s is not None: - if poe_inside_code_block: - append_text += s[i:] - poe_partial_buffer = "" - else: - poe_partial_buffer = s[i:] - if append_text: - content += append_text - else: - # Append content, filtering out placeholder thinking lines - content += strip_placeholder_thinking(chunk_content) - search_status = "" - - # Handle transformers.js output differently - if language == "transformers.js": - files = parse_transformers_js_output(content) - - # Stream ALL code by merging current parts into a single HTML (inline CSS & JS) - has_any_part = any([files.get('index.html'), files.get('index.js'), files.get('style.css')]) - if has_any_part: - merged_html = build_transformers_inline_html(files) - preview_val = None - if files['index.html'] and files['index.js'] and files['style.css']: - preview_val = send_transformers_to_sandbox(files) - yield { - code_output: gr.update(value=merged_html, language="html"), - history_output: history_to_chatbot_messages(_history), - } - elif has_existing_content: - # Model is returning search/replace changes for transformers.js - apply them - last_content = _history[-1][1] if _history and len(_history[-1]) > 1 else "" - modified_content = apply_transformers_js_search_replace_changes(last_content, content) - _mf = parse_transformers_js_output(modified_content) - yield { - code_output: gr.update(value=modified_content, language="html"), - history_output: history_to_chatbot_messages(_history), - } - else: - # Still streaming, show partial content - yield { - code_output: gr.update(value=content, language="html"), - history_output: history_to_chatbot_messages(_history), - } - else: - clean_code = remove_code_block(content) - if has_existing_content: - # Handle modification of existing content - if clean_code.strip().startswith("") or clean_code.strip().startswith(" 1 else "" - modified_content = apply_search_replace_changes(last_content, clean_code) - clean_content = remove_code_block(modified_content) - preview_val = None - if language == "html": - _mpc4 = parse_multipage_html_output(clean_content) - _mpc4 = validate_and_autofix_files(_mpc4) - preview_val = send_to_sandbox(inline_multipage_into_single_preview(_mpc4)) if _mpc4.get('index.html') else send_to_sandbox(clean_content) - elif language == "python" and is_streamlit_code(clean_content): - preview_val = send_streamlit_to_stlite(clean_content) - elif language == "gradio" or (language == "python" and is_gradio_code(clean_content)): - preview_val = send_gradio_to_lite(clean_content) - yield { - code_output: gr.update(value=clean_content, language=get_gradio_language(language)), - history_output: history_to_chatbot_messages(_history), - } - else: - preview_val = None - if language == "html": - _mpc5 = parse_multipage_html_output(clean_code) - _mpc5 = validate_and_autofix_files(_mpc5) - preview_val = send_to_sandbox(inline_multipage_into_single_preview(_mpc5)) if _mpc5.get('index.html') else send_to_sandbox(clean_code) - elif language == "python" and is_streamlit_code(clean_code): - preview_val = send_streamlit_to_stlite(clean_code) - elif language == "gradio" or (language == "python" and is_gradio_code(clean_code)): - preview_val = send_gradio_to_lite(clean_code) - yield { - code_output: gr.update(value=clean_code, language=get_gradio_language(language)), - history_output: history_to_chatbot_messages(_history), - } - # Skip chunks with empty choices (end of stream) - # Do not treat as error - # Handle response based on whether this is a modification or new generation - if language == "transformers.js": - # Handle transformers.js output - files = parse_transformers_js_output(content) - if files['index.html'] and files['index.js'] and files['style.css']: - # Model returned complete transformers.js output - formatted_output = format_transformers_js_output(files) - _history.append([query, formatted_output]) - yield { - code_output: formatted_output, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - elif has_existing_content: - # Model returned search/replace changes for transformers.js - apply them - last_content = _history[-1][1] if _history and len(_history[-1]) > 1 else "" - modified_content = apply_transformers_js_search_replace_changes(last_content, content) - _history.append([query, modified_content]) - _mf = parse_transformers_js_output(modified_content) - yield { - code_output: modified_content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - else: - # Fallback if parsing failed - _history.append([query, content]) - yield { - code_output: content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - elif language == "gradio": - # Handle Gradio output - check if it's multi-file format or single file - if ('=== app.py ===' in content or '=== requirements.txt ===' in content): - # Model returned multi-file Gradio output - ensure requirements.txt is present - files = parse_multi_file_python_output(content) - if files and 'app.py' in files: - # Check if requirements.txt is missing and auto-generate it - if 'requirements.txt' not in files: - import_statements = extract_import_statements(files['app.py']) - requirements_content = generate_requirements_txt_with_llm(import_statements) - files['requirements.txt'] = requirements_content - - # Reformat with the auto-generated requirements.txt - content = format_multi_file_python_output(files) - - _history.append([query, content]) - yield { - code_output: content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - elif has_existing_content: - # Check if this is a followup that should maintain multi-file structure - last_content = _history[-1][1] if _history and len(_history[-1]) > 1 else "" - - # If the original was multi-file but the response isn't, try to convert it - if ('=== app.py ===' in last_content or '=== requirements.txt ===' in last_content): - # Original was multi-file, but response is single block - need to convert - if not ('=== app.py ===' in content or '=== requirements.txt ===' in content): - # Try to parse as single-block Gradio code and convert to multi-file format - clean_content = remove_code_block(content) - if 'import gradio' in clean_content or 'from gradio' in clean_content: - # This looks like Gradio code, convert to multi-file format - files = parse_multi_file_python_output(clean_content) - if not files: - # Single file - create multi-file structure - files = {'app.py': clean_content} - - # Extract requirements from imports - import_statements = extract_import_statements(clean_content) - requirements_content = generate_requirements_txt_with_llm(import_statements) - files['requirements.txt'] = requirements_content - - # Format as multi-file output - formatted_content = format_multi_file_python_output(files) - _history.append([query, formatted_content]) - yield { - code_output: formatted_content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - else: - # Not Gradio code, apply search/replace - modified_content = apply_search_replace_changes(last_content, content) - _history.append([query, modified_content]) - yield { - code_output: modified_content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - else: - # Response is already multi-file format - _history.append([query, content]) - yield { - code_output: content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - else: - # Original was single file, apply search/replace - modified_content = apply_search_replace_changes(last_content, content) - _history.append([query, modified_content]) - yield { - code_output: modified_content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - else: - # Fallback - treat as single file Gradio app - _history.append([query, content]) - yield { - code_output: content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - elif has_existing_content: - # Handle modification of existing content - final_code = remove_code_block(content) - if final_code.strip().startswith("") or final_code.strip().startswith(" 1 else "" - modified_content = apply_search_replace_changes(last_content, final_code) - clean_content = remove_code_block(modified_content) - - # Use clean content without media generation - - # Update history with the cleaned content - _history.append([query, clean_content]) - yield { - code_output: clean_content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - else: - # Regular generation - use the content as is - final_content = remove_code_block(content) - - # Use final content without media generation - - _history.append([query, final_content]) - - # Generate deployment message instead of preview - deploy_message = f""" -
-

šŸŽ‰ Code Generated Successfully!

-

Your {language.upper()} application is ready to deploy!

- -
-

šŸš€ Next Steps:

-
-

- 1 - Use the Deploy button in the sidebar -

-

- 2 - Enter your app name below -

-

- 3 - Click "Publish" -

-

- 4 - Share your creation! šŸŒ -

-
-
- -

- šŸ’” Your app will be live on Hugging Face Spaces in seconds! -

-
- """ - - yield { - code_output: final_content, - history: _history, - history_output: history_to_chatbot_messages(_history), - } - except Exception as e: - error_message = f"Error: {str(e)}" - yield { - code_output: error_message, - history_output: history_to_chatbot_messages(_history), - } - -# Deploy to Spaces logic - -def add_anycoder_tag_to_readme(api, repo_id, app_port=None): - """Download existing README, add anycoder tag and app_port if needed, and upload back. - - Args: - api: HuggingFace API client - repo_id: Repository ID - app_port: Optional port number to set for Docker spaces (e.g., 7860 for React apps) - """ - try: - import tempfile - import re - - # Download the existing README - readme_path = api.hf_hub_download( - repo_id=repo_id, - filename="README.md", - repo_type="space" - ) - - # Read the existing README content - with open(readme_path, 'r', encoding='utf-8') as f: - content = f.read() - - # Parse frontmatter and content - if content.startswith('---'): - # Split frontmatter and body - parts = content.split('---', 2) - if len(parts) >= 3: - frontmatter = parts[1].strip() - body = parts[2] if len(parts) > 2 else "" - - # Check if tags already exist - if 'tags:' in frontmatter: - # Add anycoder to existing tags if not present - if '- anycoder' not in frontmatter: - frontmatter = re.sub(r'(tags:\s*\n(?:\s*-\s*[^\n]+\n)*)', r'\1- anycoder\n', frontmatter) - else: - # Add tags section with anycoder - frontmatter += '\ntags:\n- anycoder' - - # Add app_port if specified and not already present - if app_port is not None and 'app_port:' not in frontmatter: - frontmatter += f'\napp_port: {app_port}' - - # Reconstruct the README - new_content = f"---\n{frontmatter}\n---{body}" - else: - # Malformed frontmatter, just add tags at the end of frontmatter - new_content = content.replace('---', '---\ntags:\n- anycoder\n---', 1) - else: - # No frontmatter, add it at the beginning - app_port_line = f'\napp_port: {app_port}' if app_port else '' - new_content = f"---\ntags:\n- anycoder{app_port_line}\n---\n\n{content}" - - # Upload the modified README - with tempfile.NamedTemporaryFile("w", suffix=".md", delete=False, encoding='utf-8') as f: - f.write(new_content) - temp_path = f.name - - api.upload_file( - path_or_fileobj=temp_path, - path_in_repo="README.md", - repo_id=repo_id, - repo_type="space" - ) - - import os - os.unlink(temp_path) - - except Exception as e: - print(f"Warning: Could not modify README.md to add anycoder tag: {e}") - -def extract_import_statements(code): - """Extract import statements from generated code.""" - import ast - import re - - import_statements = [] - - # Built-in Python modules to exclude - builtin_modules = { - 'os', 'sys', 'json', 'time', 'datetime', 'random', 'math', 're', 'collections', - 'itertools', 'functools', 'pathlib', 'urllib', 'http', 'email', 'html', 'xml', - 'csv', 'tempfile', 'shutil', 'subprocess', 'threading', 'multiprocessing', - 'asyncio', 'logging', 'typing', 'base64', 'hashlib', 'secrets', 'uuid', - 'copy', 'pickle', 'io', 'contextlib', 'warnings', 'sqlite3', 'gzip', 'zipfile', - 'tarfile', 'socket', 'ssl', 'platform', 'getpass', 'pwd', 'grp', 'stat', - 'glob', 'fnmatch', 'linecache', 'traceback', 'inspect', 'keyword', 'token', - 'tokenize', 'ast', 'code', 'codeop', 'dis', 'py_compile', 'compileall', - 'importlib', 'pkgutil', 'modulefinder', 'runpy', 'site', 'sysconfig' - } - - try: - # Try to parse as Python AST - tree = ast.parse(code) - - for node in ast.walk(tree): - if isinstance(node, ast.Import): - for alias in node.names: - module_name = alias.name.split('.')[0] - if module_name not in builtin_modules and not module_name.startswith('_'): - import_statements.append(f"import {alias.name}") - - elif isinstance(node, ast.ImportFrom): - if node.module: - module_name = node.module.split('.')[0] - if module_name not in builtin_modules and not module_name.startswith('_'): - names = [alias.name for alias in node.names] - import_statements.append(f"from {node.module} import {', '.join(names)}") - - except SyntaxError: - # Fallback: use regex to find import statements - for line in code.split('\n'): - line = line.strip() - if line.startswith('import ') or line.startswith('from '): - # Check if it's not a builtin module - if line.startswith('import '): - module_name = line.split()[1].split('.')[0] - elif line.startswith('from '): - module_name = line.split()[1].split('.')[0] - - if module_name not in builtin_modules and not module_name.startswith('_'): - import_statements.append(line) - - return list(set(import_statements)) # Remove duplicates - -def generate_requirements_txt_with_llm(import_statements): - """Generate requirements.txt content using LLM based on import statements.""" - if not import_statements: - return "# No additional dependencies required\n" - - # Use a lightweight model for this task - try: - client = get_inference_client("zai-org/GLM-4.6", "auto") - - imports_text = '\n'.join(import_statements) - - prompt = f"""Based on the following Python import statements, generate a comprehensive requirements.txt file with all necessary and commonly used related packages: - -{imports_text} - -Instructions: -- Include the direct packages needed for the imports -- Include commonly used companion packages and dependencies for better functionality -- Use correct PyPI package names (e.g., PIL -> Pillow, sklearn -> scikit-learn) -- IMPORTANT: For diffusers, ALWAYS use: git+https://github.com/huggingface/diffusers -- IMPORTANT: For transformers, ALWAYS use: git+https://github.com/huggingface/transformers -- IMPORTANT: If diffusers is installed, also include transformers and sentencepiece as they usually go together -- Examples of comprehensive dependencies: - * diffusers often needs: git+https://github.com/huggingface/transformers, sentencepiece, accelerate, torch, tokenizers - * transformers often needs: accelerate, torch, tokenizers, datasets - * gradio often needs: requests, Pillow for image handling - * pandas often needs: numpy, openpyxl for Excel files - * matplotlib often needs: numpy, pillow for image saving - * sklearn often needs: numpy, scipy, joblib - * streamlit often needs: pandas, numpy, requests - * opencv-python often needs: numpy, pillow - * fastapi often needs: uvicorn, pydantic - * torch often needs: torchvision, torchaudio (if doing computer vision/audio) -- Include packages for common file formats if relevant (openpyxl, python-docx, PyPDF2) -- Do not include Python built-in modules -- Do not specify versions unless there are known compatibility issues -- One package per line -- If no external packages are needed, return "# No additional dependencies required" - -šŸšØ CRITICAL OUTPUT FORMAT: -- Output ONLY the package names, one per line (plain text format) -- Do NOT use markdown formatting (no ```, no bold, no headings, no lists) -- Do NOT add any explanatory text before or after the package list -- Do NOT wrap the output in code blocks -- Just output raw package names as they would appear in requirements.txt - -Generate a comprehensive requirements.txt that ensures the application will work smoothly:""" - - messages = [ - {"role": "system", "content": "You are a Python packaging expert specializing in creating comprehensive, production-ready requirements.txt files. Output ONLY plain text package names without any markdown formatting, code blocks, or explanatory text. Your goal is to ensure applications work smoothly by including not just direct dependencies but also commonly needed companion packages, popular extensions, and supporting libraries that developers typically need together."}, - {"role": "user", "content": prompt} - ] - - response = client.chat.completions.create( - model="zai-org/GLM-4.6", - messages=messages, - max_tokens=1024, - temperature=0.1 - ) - - requirements_content = response.choices[0].message.content.strip() - - # Clean up the response in case it includes extra formatting - if '```' in requirements_content: - # Use the existing remove_code_block function for consistent cleaning - requirements_content = remove_code_block(requirements_content) - - # Enhanced cleanup for markdown and formatting - lines = requirements_content.split('\n') - clean_lines = [] - for line in lines: - stripped_line = line.strip() - - # Skip lines that are markdown formatting - if (stripped_line == '```' or - stripped_line.startswith('```') or - stripped_line.startswith('#') and not stripped_line.startswith('# ') or # Skip markdown headers but keep comments - stripped_line.startswith('**') or # Skip bold text - stripped_line.startswith('*') and not stripped_line[1:2].isalnum() or # Skip markdown lists but keep package names starting with * - stripped_line.startswith('-') and not stripped_line[1:2].isalnum() or # Skip markdown lists but keep package names starting with - - stripped_line.startswith('===') or # Skip section dividers - stripped_line.startswith('---') or # Skip horizontal rules - stripped_line.lower().startswith('here') or # Skip explanatory text - stripped_line.lower().startswith('this') or # Skip explanatory text - stripped_line.lower().startswith('the') or # Skip explanatory text - stripped_line.lower().startswith('based on') or # Skip explanatory text - stripped_line == ''): # Skip empty lines unless they're at natural boundaries - continue - - # Keep lines that look like valid package specifications - # Valid lines: package names, git+https://, comments starting with "# " - if (stripped_line.startswith('# ') or # Valid comments - stripped_line.startswith('git+') or # Git dependencies - stripped_line[0].isalnum() or # Package names start with alphanumeric - '==' in stripped_line or # Version specifications - '>=' in stripped_line or # Version specifications - '<=' in stripped_line): # Version specifications - clean_lines.append(line) - - requirements_content = '\n'.join(clean_lines).strip() - - # Ensure it ends with a newline - if requirements_content and not requirements_content.endswith('\n'): - requirements_content += '\n' - - return requirements_content if requirements_content else "# No additional dependencies required\n" - - except Exception as e: - # Fallback: simple extraction with basic mapping - dependencies = set() - special_cases = { - 'PIL': 'Pillow', - 'sklearn': 'scikit-learn', - 'skimage': 'scikit-image', - 'bs4': 'beautifulsoup4' - } - - for stmt in import_statements: - if stmt.startswith('import '): - module_name = stmt.split()[1].split('.')[0] - package_name = special_cases.get(module_name, module_name) - dependencies.add(package_name) - elif stmt.startswith('from '): - module_name = stmt.split()[1].split('.')[0] - package_name = special_cases.get(module_name, module_name) - dependencies.add(package_name) - - if dependencies: - return '\n'.join(sorted(dependencies)) + '\n' - else: - return "# No additional dependencies required\n" - -def wrap_html_in_gradio_app(html_code): - # Escape triple quotes for safe embedding - safe_html = html_code.replace('"""', r'\"\"\"') - - # Extract import statements and generate requirements.txt with LLM - import_statements = extract_import_statements(html_code) - requirements_comment = "" - if import_statements: - requirements_content = generate_requirements_txt_with_llm(import_statements) - requirements_comment = ( - "# Generated requirements.txt content (create this file manually if needed):\n" - + '\n'.join(f"# {line}" for line in requirements_content.strip().split('\n')) + '\n\n' - ) - - return ( - f'{requirements_comment}' - 'import gradio as gr\n\n' - 'def show_html():\n' - f' return """{safe_html}"""\n\n' - 'demo = gr.Interface(fn=show_html, inputs=None, outputs=gr.HTML())\n\n' - 'if __name__ == "__main__":\n' - ' demo.launch()\n' - ) -def deploy_to_spaces(code): - if not code or not code.strip(): - return # Do nothing if code is empty - # Wrap the HTML code in a Gradio app - app_py = wrap_html_in_gradio_app(code.strip()) - base_url = "https://huggingface.co/new-space" - params = urllib.parse.urlencode({ - "name": "new-space", - "sdk": "gradio" - }) - # Use urlencode for file params - files_params = urllib.parse.urlencode({ - "files[0][path]": "app.py", - "files[0][content]": app_py - }) - full_url = f"{base_url}?{params}&{files_params}" - webbrowser.open_new_tab(full_url) - -def wrap_html_in_static_app(html_code): - # For static Spaces, just use the HTML code as-is - return html_code - -def prettify_comfyui_json_for_html(json_content: str) -> str: - """Convert ComfyUI JSON to prettified HTML display""" - try: - import json - # Parse and prettify the JSON - parsed_json = json.loads(json_content) - prettified_json = json.dumps(parsed_json, indent=2, ensure_ascii=False) - - # Create HTML wrapper with syntax highlighting - html_content = f""" - - - - - ComfyUI Workflow - - - -
-

ComfyUI Workflow

-

Built with anycoder

-
- - - - -
- 
{prettified_json}
-
- - - -""" - return html_content - except json.JSONDecodeError: - # If it's not valid JSON, return as-is - return json_content - except Exception as e: - print(f"Error prettifying ComfyUI JSON: {e}") - return json_content - -def check_hf_space_url(url: str) -> Tuple[bool, Optional[str], Optional[str]]: - """Check if URL is a valid Hugging Face Spaces URL and extract username/project""" - import re - - # Pattern to match HF Spaces URLs (allows dots in space names) - url_pattern = re.compile( - r'^(https?://)?(huggingface\.co|hf\.co)/spaces/([\w.-]+)/([\w.-]+)$', - re.IGNORECASE - ) - - match = url_pattern.match(url.strip()) - if match: - username = match.group(3) - project_name = match.group(4) - return True, username, project_name - return False, None, None - -def detect_transformers_js_space(api, username: str, project_name: str) -> bool: - """Check if a space is a transformers.js app by looking for the three key files""" - try: - from huggingface_hub import list_repo_files - files = list_repo_files(repo_id=f"{username}/{project_name}", repo_type="space") - - # Check for the three transformers.js files - has_index_html = any('index.html' in f for f in files) - has_index_js = any('index.js' in f for f in files) - has_style_css = any('style.css' in f for f in files) - - return has_index_html and has_index_js and has_style_css - except: - return False - -def fetch_transformers_js_files(api, username: str, project_name: str) -> dict: - """Fetch all three transformers.js files from a space""" - files = {} - file_names = ['index.html', 'index.js', 'style.css'] - - for file_name in file_names: - try: - content_path = api.hf_hub_download( - repo_id=f"{username}/{project_name}", - filename=file_name, - repo_type="space" - ) - - with open(content_path, 'r', encoding='utf-8') as f: - files[file_name] = f.read() - except: - files[file_name] = "" - - return files - -def combine_transformers_js_files(files: dict, username: str, project_name: str) -> str: - """Combine transformers.js files into the expected format for the LLM""" - combined = f"""IMPORTED PROJECT FROM HUGGING FACE SPACE -============================================== - -Space: {username}/{project_name} -SDK: static (transformers.js) -Type: Transformers.js Application - -""" - - if files.get('index.html'): - combined += f"=== index.html ===\n{files['index.html']}\n\n" - - if files.get('index.js'): - combined += f"=== index.js ===\n{files['index.js']}\n\n" - - if files.get('style.css'): - combined += f"=== style.css ===\n{files['style.css']}\n\n" - - return combined - -def fetch_all_space_files(api, username: str, project_name: str, sdk: str) -> dict: - """Fetch all relevant files from a Hugging Face Space""" - files = {} - - try: - from huggingface_hub import list_repo_files - all_files = list_repo_files(repo_id=f"{username}/{project_name}", repo_type="space") - - # Filter out unwanted files - relevant_files = [] - for file in all_files: - # Skip hidden files, git files, and certain extensions - if (file.startswith('.') or - file.endswith('.md') or - (file.endswith('.txt') and file not in ['requirements.txt', 'packages.txt']) or - file.endswith('.log') or - file.endswith('.pyc') or - '__pycache__' in file): - continue - relevant_files.append(file) - - # Define priority files based on SDK - priority_files = [] - if sdk == "gradio": - priority_files = ["app.py", "main.py", "gradio_app.py", "requirements.txt", "packages.txt"] - elif sdk == "streamlit": - priority_files = ["streamlit_app.py", "app.py", "main.py", "requirements.txt", "packages.txt"] - elif sdk == "static": - priority_files = ["index.html", "index.js", "style.css", "script.js"] - - # Add priority files first, then other Python files, then other files - files_to_fetch = [] - - # Add priority files that exist - for pfile in priority_files: - if pfile in relevant_files: - files_to_fetch.append(pfile) - relevant_files.remove(pfile) - - # Add other Python files - python_files = [f for f in relevant_files if f.endswith('.py')] - files_to_fetch.extend(python_files) - for pf in python_files: - if pf in relevant_files: - relevant_files.remove(pf) - - # Add other important files (JS, CSS, JSON, etc.) - other_important = [f for f in relevant_files if any(f.endswith(ext) for ext in ['.js', '.css', '.json', '.html', '.yml', '.yaml'])] - files_to_fetch.extend(other_important) - - # Limit to reasonable number of files to avoid overwhelming - files_to_fetch = files_to_fetch[:20] # Max 20 files - - # Download each file - for file_name in files_to_fetch: - try: - content_path = api.hf_hub_download( - repo_id=f"{username}/{project_name}", - filename=file_name, - repo_type="space" - ) - - # Read file content with appropriate encoding - try: - with open(content_path, 'r', encoding='utf-8') as f: - files[file_name] = f.read() - except UnicodeDecodeError: - # For binary files or files with different encoding - with open(content_path, 'rb') as f: - content = f.read() - # Skip binary files that are too large or not text - if len(content) > 100000: # Skip files > 100KB - files[file_name] = f"[Binary file: {file_name} - {len(content)} bytes]" - else: - try: - files[file_name] = content.decode('utf-8') - except: - files[file_name] = f"[Binary file: {file_name} - {len(content)} bytes]" - except Exception as e: - files[file_name] = f"[Error loading {file_name}: {str(e)}]" - - except Exception as e: - # Fallback to single file loading - return {} - - return files - -def format_multi_file_space(files: dict, username: str, project_name: str, sdk: str) -> str: - """Format multiple files from a space into a readable format""" - if not files: - return "" - - header = f"""IMPORTED PROJECT FROM HUGGING FACE SPACE -============================================== - -Space: {username}/{project_name} -SDK: {sdk} -Files: {len(files)} files loaded - -""" - - # Sort files to show main files first - main_files = [] - other_files = [] - - priority_order = ["app.py", "main.py", "streamlit_app.py", "gradio_app.py", "index.html", "requirements.txt"] - - for priority_file in priority_order: - if priority_file in files: - main_files.append(priority_file) - - for file_name in sorted(files.keys()): - if file_name not in main_files: - other_files.append(file_name) - - content = header - - # Add main files first - for file_name in main_files: - content += f"=== {file_name} ===\n{files[file_name]}\n\n" - - # Add other files - for file_name in other_files: - content += f"=== {file_name} ===\n{files[file_name]}\n\n" - - return content - -def fetch_hf_space_content(username: str, project_name: str) -> str: - """Fetch content from a Hugging Face Space""" - try: - import requests - from huggingface_hub import HfApi - - # Try to get space info first - api = HfApi() - space_info = api.space_info(f"{username}/{project_name}") - - # Check if this is a transformers.js space first - if space_info.sdk == "static" and detect_transformers_js_space(api, username, project_name): - files = fetch_transformers_js_files(api, username, project_name) - return combine_transformers_js_files(files, username, project_name) - - # Use the new multi-file loading approach for all space types - sdk = space_info.sdk - files = fetch_all_space_files(api, username, project_name, sdk) - - if files: - # Use the multi-file format - return format_multi_file_space(files, username, project_name, sdk) - else: - # Fallback to single file loading for compatibility - main_file = None - - # Define file patterns to try based on SDK - if sdk == "static": - file_patterns = ["index.html"] - elif sdk == "gradio": - file_patterns = ["app.py", "main.py", "gradio_app.py"] - elif sdk == "streamlit": - file_patterns = ["streamlit_app.py", "src/streamlit_app.py", "app.py", "src/app.py", "main.py", "src/main.py", "Home.py", "src/Home.py", "šŸ _Home.py", "src/šŸ _Home.py", "1_šŸ _Home.py", "src/1_šŸ _Home.py"] - else: - # Try common files for unknown SDKs - file_patterns = ["app.py", "src/app.py", "index.html", "streamlit_app.py", "src/streamlit_app.py", "main.py", "src/main.py", "Home.py", "src/Home.py"] - - # Try to find and download the main file - for file in file_patterns: - try: - content = api.hf_hub_download( - repo_id=f"{username}/{project_name}", - filename=file, - repo_type="space" - ) - main_file = file - break - except: - continue - - if main_file: - content = api.hf_hub_download( - repo_id=f"{username}/{project_name}", - filename=main_file, - repo_type="space" - ) - - # Read the file content - with open(content, 'r', encoding='utf-8') as f: - file_content = f.read() - - return f"""IMPORTED PROJECT FROM HUGGING FACE SPACE -============================================== - -Space: {username}/{project_name} -SDK: {sdk} -Main File: {main_file} - -{file_content}""" - else: - # Try to get more information about available files for debugging - try: - from huggingface_hub import list_repo_files - files_list = list_repo_files(repo_id=f"{username}/{project_name}", repo_type="space") - available_files = [f for f in files_list if not f.startswith('.') and not f.endswith('.md')] - return f"Error: Could not find main file in space {username}/{project_name}.\n\nSDK: {sdk}\nAvailable files: {', '.join(available_files[:10])}{'...' if len(available_files) > 10 else ''}\n\nTried looking for: {', '.join(file_patterns)}" - except: - return f"Error: Could not find main file in space {username}/{project_name}. Expected files for {sdk} SDK: {', '.join(file_patterns) if 'file_patterns' in locals() else 'standard files'}" - - except Exception as e: - return f"Error fetching space content: {str(e)}" - -def load_project_from_url(url: str) -> Tuple[str, str]: - """Load project from Hugging Face Space URL""" - # Validate URL - is_valid, username, project_name = check_hf_space_url(url) - - if not is_valid: - return "Error: Please enter a valid Hugging Face Spaces URL.\n\nExpected format: https://huggingface.co/spaces/username/project", "" - - # Fetch content - content = fetch_hf_space_content(username, project_name) - - if content.startswith("Error:"): - return content, "" - - # Extract the actual code content by removing metadata - lines = content.split('\n') - code_start = 0 - for i, line in enumerate(lines): - # Skip metadata lines and find the start of actual code - if (line.strip() and - not line.startswith('=') and - not line.startswith('IMPORTED PROJECT') and - not line.startswith('Space:') and - not line.startswith('SDK:') and - not line.startswith('Main File:')): - code_start = i - break - - code_content = '\n'.join(lines[code_start:]) - - return f"āœ… Successfully imported project from {username}/{project_name}", code_content - -# -------- Repo/Model Import (GitHub & Hugging Face model) -------- -def _parse_repo_or_model_url(url: str) -> Tuple[str, Optional[dict]]: - """Parse a URL and detect if it's a GitHub repo, HF Space, or HF Model. - - Returns a tuple of (kind, meta) where kind in {"github", "hf_space", "hf_model", "unknown"} - Meta contains parsed identifiers. - """ - try: - parsed = urlparse(url.strip()) - netloc = (parsed.netloc or "").lower() - path = (parsed.path or "").strip("/") - # Hugging Face spaces - if ("huggingface.co" in netloc or netloc.endswith("hf.co")) and path.startswith("spaces/"): - parts = path.split("/") - if len(parts) >= 3: - return "hf_space", {"username": parts[1], "project": parts[2]} - # Hugging Face model repo (default) - if ("huggingface.co" in netloc or netloc.endswith("hf.co")) and not path.startswith(("spaces/", "datasets/", "organizations/")): - parts = path.split("/") - if len(parts) >= 2: - repo_id = f"{parts[0]}/{parts[1]}" - return "hf_model", {"repo_id": repo_id} - # GitHub repo - if "github.com" in netloc: - parts = path.split("/") - if len(parts) >= 2: - return "github", {"owner": parts[0], "repo": parts[1]} - except Exception: - pass - return "unknown", None - -def _fetch_hf_model_readme(repo_id: str) -> Optional[str]: - """Fetch README.md (model card) for a Hugging Face model repo.""" - try: - api = HfApi() - # Try direct README.md first - try: - local_path = api.hf_hub_download(repo_id=repo_id, filename="README.md", repo_type="model") - with open(local_path, "r", encoding="utf-8") as f: - return f.read() - except Exception: - # Some repos use README at root without explicit type - local_path = api.hf_hub_download(repo_id=repo_id, filename="README.md") - with open(local_path, "r", encoding="utf-8") as f: - return f.read() - except Exception: - return None - -def _fetch_github_readme(owner: str, repo: str) -> Optional[str]: - """Fetch README.md from a GitHub repo via raw URLs, trying HEAD/main/master.""" - bases = [ - f"https://raw.githubusercontent.com/{owner}/{repo}/HEAD/README.md", - f"https://raw.githubusercontent.com/{owner}/{repo}/main/README.md", - f"https://raw.githubusercontent.com/{owner}/{repo}/master/README.md", - ] - for url in bases: - try: - resp = requests.get(url, timeout=10) - if resp.status_code == 200 and resp.text: - return resp.text - except Exception: - continue - return None - -def _extract_transformers_or_diffusers_snippet(markdown_text: str) -> Tuple[Optional[str], Optional[str]]: - """Extract the most relevant Python code block referencing transformers/diffusers from markdown. - - Returns (language, code). If not found, returns (None, None). - """ - if not markdown_text: - return None, None - # Find fenced code blocks - code_blocks = [] - import re as _re - for match in _re.finditer(r"```([\w+-]+)?\s*\n([\s\S]*?)```", markdown_text, _re.IGNORECASE): - lang = (match.group(1) or "").lower() - code = match.group(2) or "" - code_blocks.append((lang, code.strip())) - # Filter for transformers/diffusers relevance - def score_block(code: str) -> int: - score = 0 - kws = [ - "from transformers", "import transformers", "pipeline(", - "AutoModel", "AutoTokenizer", "text-generation", - "from diffusers", "import diffusers", "DiffusionPipeline", - "StableDiffusion", "UNet", "EulerDiscreteScheduler" - ] - for kw in kws: - if kw in code: - score += 1 - # Prefer longer, self-contained snippets - score += min(len(code) // 200, 5) - return score - scored = sorted( - [cb for cb in code_blocks if any(kw in cb[1] for kw in ["transformers", "diffusers", "pipeline(", "StableDiffusion"])], - key=lambda x: score_block(x[1]), - reverse=True, - ) - if scored: - return scored[0][0] or None, scored[0][1] - return None, None - -def _infer_task_from_context(snippet: Optional[str], pipeline_tag: Optional[str]) -> str: - """Infer a task string for transformers pipeline; fall back to provided pipeline_tag or 'text-generation'.""" - if pipeline_tag: - return pipeline_tag - if not snippet: - return "text-generation" - lowered = snippet.lower() - task_hints = { - "text-generation": ["text-generation", "automodelforcausallm"], - "text2text-generation": ["text2text-generation", "t5forconditionalgeneration"], - "fill-mask": ["fill-mask", "automodelformaskedlm"], - "summarization": ["summarization"], - "translation": ["translation"], - "text-classification": ["text-classification", "sequenceclassification"], - "automatic-speech-recognition": ["speechrecognition", "automatic-speech-recognition", "asr"], - "image-classification": ["image-classification"], - "zero-shot-image-classification": ["zero-shot-image-classification"], - } - for task, hints in task_hints.items(): - if any(h in lowered for h in hints): - return task - # Inspect explicit pipeline("task") - import re as _re - m = _re.search(r"pipeline\(\s*['\"]([\w\-]+)['\"]", snippet) - if m: - return m.group(1) - return "text-generation" - -def _generate_gradio_app_from_transformers(repo_id: str, task: str) -> str: - """Build a minimal Gradio app using transformers.pipeline for a given model and task.""" - # Map simple UI per task; default to text in/out - if task in {"text-generation", "text2text-generation", "summarization", "translation", "fill-mask"}: - return ( - "import gradio as gr\n" - "from transformers import pipeline\n\n" - f"pipe = pipeline(task='{task}', model='{repo_id}')\n\n" - "def infer(prompt, max_new_tokens=256, temperature=0.7, top_p=0.95):\n" - " if '\u2047' in prompt:\n" - " # Fill-mask often uses [MASK]; keep generic handling\n" - " pass\n" - " out = pipe(prompt, max_new_tokens=max_new_tokens, do_sample=True, temperature=temperature, top_p=top_p)\n" - " if isinstance(out, list):\n" - " if isinstance(out[0], dict):\n" - " return next(iter(out[0].values())) if out[0] else str(out)\n" - " return str(out[0])\n" - " return str(out)\n\n" - "demo = gr.Interface(\n" - " fn=infer,\n" - " inputs=[gr.Textbox(label='Input', lines=8), gr.Slider(1, 2048, value=256, label='max_new_tokens'), gr.Slider(0.0, 1.5, value=0.7, step=0.01, label='temperature'), gr.Slider(0.0, 1.0, value=0.95, step=0.01, label='top_p')],\n" - " outputs=gr.Textbox(label='Output', lines=8),\n" - " title='Transformers Demo'\n" - ")\n\n" - "if __name__ == '__main__':\n" - " demo.launch()\n" - ) - elif task in {"text-classification"}: - return ( - "import gradio as gr\n" - "from transformers import pipeline\n\n" - f"pipe = pipeline(task='{task}', model='{repo_id}')\n\n" - "def infer(text):\n" - " out = pipe(text)\n" - " # Expect list of dicts with label/score\n" - " return {o['label']: float(o['score']) for o in out}\n\n" - "demo = gr.Interface(fn=infer, inputs=gr.Textbox(lines=6), outputs=gr.Label(), title='Text Classification')\n\n" - "if __name__ == '__main__':\n" - " demo.launch()\n" - ) - else: - # Fallback generic text pipeline (pipeline infers task from model config) - return ( - "import gradio as gr\n" - "from transformers import pipeline\n\n" - f"pipe = pipeline(model='{repo_id}')\n\n" - "def infer(prompt):\n" - " out = pipe(prompt)\n" - " if isinstance(out, list):\n" - " if isinstance(out[0], dict):\n" - " return next(iter(out[0].values())) if out[0] else str(out)\n" - " return str(out[0])\n" - " return str(out)\n\n" - "demo = gr.Interface(fn=infer, inputs=gr.Textbox(lines=8), outputs=gr.Textbox(lines=8), title='Transformers Demo')\n\n" - "if __name__ == '__main__':\n" - " demo.launch()\n" - ) - -def _generate_gradio_app_from_diffusers(repo_id: str) -> str: - """Build a minimal Gradio app for text-to-image using diffusers.""" - return ( - "import gradio as gr\n" - "import torch\n" - "from diffusers import DiffusionPipeline\n\n" - f"pipe = DiffusionPipeline.from_pretrained('{repo_id}')\n" - "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n" - "pipe = pipe.to(device)\n\n" - "def infer(prompt, guidance_scale=7.0, num_inference_steps=30, seed=0):\n" - " generator = None if seed == 0 else torch.Generator(device=device).manual_seed(int(seed))\n" - " image = pipe(prompt, guidance_scale=float(guidance_scale), num_inference_steps=int(num_inference_steps), generator=generator).images[0]\n" - " return image\n\n" - "demo = gr.Interface(\n" - " fn=infer,\n" - " inputs=[gr.Textbox(label='Prompt'), gr.Slider(0.0, 15.0, value=7.0, step=0.1, label='guidance_scale'), gr.Slider(1, 100, value=30, step=1, label='num_inference_steps'), gr.Slider(0, 2**32-1, value=0, step=1, label='seed')],\n" - " outputs=gr.Image(type='pil'),\n" - " title='Diffusers Text-to-Image'\n" - ")\n\n" - "if __name__ == '__main__':\n" - " demo.launch()\n" - ) - -def get_trending_models(limit: int = 10) -> List[Tuple[str, str]]: - """ - Fetch top trending models from HuggingFace Hub. - - Returns a list of tuples: (display_name, model_id) - Display name format: "model_name (task)" - """ - try: - # Use the HuggingFace trending API endpoint directly - response = requests.get("https://huggingface.co/api/trending") - - if response.status_code != 200: - print(f"Failed to fetch trending models: HTTP {response.status_code}") - return [("Unable to load trending models", "")] - - trending_data = response.json() - - # The API returns {"recentlyTrending": [...]} - recently_trending = trending_data.get("recentlyTrending", []) - - if not recently_trending: - print("No trending items found in API response") - return [("No trending models available", "")] - - trending_list = [] - count = 0 - - # Process trending items, filter for models only - for item in recently_trending: - if count >= limit: - break - - try: - # Check if this is a model (not a space or dataset) - repo_type = item.get("repoType") - if repo_type != "model": - continue - - # Extract model data - repo_data = item.get("repoData", {}) - model_id = repo_data.get("id") - - if not model_id: - continue - - # Get pipeline tag (task type) - pipeline_tag = repo_data.get("pipeline_tag") - - # Default to "general" if no task found - task = pipeline_tag or "general" - - # Clean up task name for display - task_display = task.replace("-", " ").title() if task != "general" else "General" - - # Create display name: "model_name (Task)" - display_name = f"{model_id} ({task_display})" - trending_list.append((display_name, model_id)) - count += 1 - - except Exception as model_error: - print(f"Error processing trending item: {model_error}") - continue - - if not trending_list: - print("No models found in trending list, using fallback") - # Fallback: use list_models with downloads sort - try: - api = HfApi() - models = api.list_models(sort="downloads", limit=limit) - for model in models: - model_id = model.id - task = getattr(model, "pipeline_tag", None) or "general" - task_display = task.replace("-", " ").title() if task != "general" else "General" - display_name = f"{model_id} ({task_display})" - trending_list.append((display_name, model_id)) - except Exception as fallback_error: - print(f"Fallback also failed: {fallback_error}") - return [("No models available", "")] - - return trending_list - - except Exception as e: - print(f"Error fetching trending models: {e}") - # Fallback to most downloaded models - try: - api = HfApi() - models = api.list_models(sort="downloads", limit=limit) - trending_list = [] - for model in models: - model_id = model.id - task = getattr(model, "pipeline_tag", None) or "general" - task_display = task.replace("-", " ").title() if task != "general" else "General" - display_name = f"{model_id} ({task_display})" - trending_list.append((display_name, model_id)) - return trending_list - except Exception: - return [("Error loading models", "")] - - -def get_trending_spaces(limit: int = 10) -> List[Tuple[str, str]]: - """ - Fetch top trending spaces from HuggingFace Hub. - - Returns a list of tuples: (display_name, space_id) - Display name format: "space_name (category)" - """ - try: - # Use the HuggingFace trending API endpoint for spaces - response = requests.get("https://huggingface.co/api/trending?type=space") - - if response.status_code != 200: - print(f"Failed to fetch trending spaces: HTTP {response.status_code}") - return [("Unable to load trending spaces", "")] - - trending_data = response.json() - - # The API returns {"recentlyTrending": [...]} - recently_trending = trending_data.get("recentlyTrending", []) - - if not recently_trending: - print("No trending spaces found in API response") - return [("No trending spaces available", "")] - - trending_list = [] - count = 0 - - # Process trending items - for item in recently_trending: - if count >= limit: - break - - try: - # Check if this is a space - repo_type = item.get("repoType") - if repo_type != "space": - continue - - # Extract space data - repo_data = item.get("repoData", {}) - space_id = repo_data.get("id") - - if not space_id: - continue - - # Get title and category - title = repo_data.get("title") or space_id - category = repo_data.get("ai_category") or repo_data.get("shortDescription", "Space") - - # Create display name: "title (category)" - # Truncate long titles - if len(title) > 40: - title = title[:37] + "..." - - display_name = f"{title} ({category})" - trending_list.append((display_name, space_id)) - count += 1 - - except Exception as space_error: - print(f"Error processing trending space: {space_error}") - continue - - if not trending_list: - return [("No spaces available", "")] - - return trending_list - - except Exception as e: - print(f"Error fetching trending spaces: {e}") - return [("Error loading spaces", "")] - - -def import_space_from_hf(space_id: str) -> Tuple[str, str, str, str]: - """ - Import a HuggingFace space by ID and extract its code. - - Returns: (status, code, language, space_url) - """ - if not space_id or space_id == "": - return "Please select a space.", "", "html", "" - - # Build space URL - space_url = f"https://huggingface.co/spaces/{space_id}" - - # Use existing load_project_from_url function - status, code = load_project_from_url(space_url) - - # Determine language based on code content - code_lang = "html" # default - language = "html" # for language dropdown - - # Check imports to determine framework for Python code - if is_streamlit_code(code): - code_lang = "python" - language = "streamlit" - elif is_gradio_code(code): - code_lang = "python" - language = "gradio" - elif "=== index.html ===" in code and "=== index.js ===" in code: - code_lang = "html" - language = "transformers.js" - elif ("import " in code or "def " in code) and not ("" in code or " Optional[str]: - """ - Generate inference provider code template based on model's pipeline tag. - - Args: - model_id: The HuggingFace model ID - pipeline_tag: The model's pipeline tag (e.g., "text-generation", "text-to-image") - has_inference_providers: Whether the model has inference providers available - - Returns: - Generated code snippet or None - """ - if not has_inference_providers: - return None - - # Map pipeline tags to code templates based on HuggingFace Inference Providers docs - # https://huggingface.co/docs/inference-providers - - # Chat Completion / Text Generation models - if pipeline_tag in ["text-generation", "conversational"]: - return f'''import os -from huggingface_hub import InferenceClient - -client = InferenceClient( - api_key=os.environ["HF_TOKEN"], -) - -completion = client.chat.completions.create( - model="{model_id}", - messages=[ - {{ - "role": "user", - "content": "What is the capital of France?" - }} - ], -) - -print(completion.choices[0].message)''' - - # Vision-Language Models (Image-Text to Text) - elif pipeline_tag in ["image-text-to-text", "visual-question-answering"]: - return f'''import os -from huggingface_hub import InferenceClient - -client = InferenceClient( - api_key=os.environ["HF_TOKEN"], -) - -completion = client.chat.completions.create( - model="{model_id}", - messages=[ - {{ - "role": "user", - "content": [ - {{ - "type": "text", - "text": "Describe this image in one sentence." - }}, - {{ - "type": "image_url", - "image_url": {{ - "url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg" - }} - }} - ] - }} - ], -) - -print(completion.choices[0].message)''' - - # Text to Image models - elif pipeline_tag == "text-to-image": - return f'''import os -from huggingface_hub import InferenceClient - -client = InferenceClient( - api_key=os.environ["HF_TOKEN"], -) - -# output is a PIL.Image object -image = client.text_to_image( - "Astronaut riding a horse", - model="{model_id}", -) - -# Save the image -image.save("output.png")''' - - # Text to Video models - elif pipeline_tag == "text-to-video": - return f'''import os -from huggingface_hub import InferenceClient - -client = InferenceClient( - api_key=os.environ["HF_TOKEN"], -) - -video = client.text_to_video( - "A young man walking on the street", - model="{model_id}", -) - -# Save the video -with open("output.mp4", "wb") as f: - f.write(video)''' - - # Image to Image models - elif pipeline_tag == "image-to-image": - return f'''import os -from huggingface_hub import InferenceClient -from PIL import Image - -client = InferenceClient( - api_key=os.environ["HF_TOKEN"], -) - -# Load input image -input_image = Image.open("input.jpg") - -# output is a PIL.Image object -output_image = client.image_to_image( - input_image, - model="{model_id}", - prompt="Make it more vibrant" -) - -# Save the output -output_image.save("output.png")''' - - # Text to Speech models - elif pipeline_tag == "text-to-speech": - return f'''import os -from huggingface_hub import InferenceClient - -client = InferenceClient( - api_key=os.environ["HF_TOKEN"], -) - -audio = client.text_to_speech( - "Hello world", - model="{model_id}", -) - -# Save the audio -with open("output.mp3", "wb") as f: - f.write(audio)''' - - # Automatic Speech Recognition - elif pipeline_tag == "automatic-speech-recognition": - return f'''import os -from huggingface_hub import InferenceClient - -client = InferenceClient( - api_key=os.environ["HF_TOKEN"], -) - -with open("audio.mp3", "rb") as f: - audio_data = f.read() - -result = client.automatic_speech_recognition( - audio_data, - model="{model_id}", -) - -print(result)''' - - # Feature Extraction / Embeddings - elif pipeline_tag == "feature-extraction": - return f'''import os -from huggingface_hub import InferenceClient - -client = InferenceClient( - api_key=os.environ["HF_TOKEN"], -) - -embeddings = client.feature_extraction( - "Hello world", - model="{model_id}", -) - -print(embeddings)''' - - # Default: try chat completion for conversational models - else: - # If it has inference providers but unknown task, try chat completion - return f'''import os -from huggingface_hub import InferenceClient - -client = InferenceClient( - api_key=os.environ["HF_TOKEN"], -) - -completion = client.chat.completions.create( - model="{model_id}", - messages=[ - {{ - "role": "user", - "content": "Hello, how are you?" - }} - ], -) - -print(completion.choices[0].message)''' - - -def _fetch_inference_provider_code(model_id: str) -> Optional[str]: - """ - Fetch inference provider information from HuggingFace API and generate code template. - - Args: - model_id: The HuggingFace model ID (e.g., "moonshotai/Kimi-K2-Thinking") - - Returns: - The code snippet if model has inference providers, None otherwise - """ - # Skip non-HuggingFace models (external APIs) - non_hf_models = [ - "gemini-3.0-pro", "gemini-2.5-flash", "gemini-2.5-pro", - "gemini-flash-latest", "gemini-flash-lite-latest", - "gpt-5", "gpt-5.1", "gpt-5.1-instant", "gpt-5.1-codex", "gpt-5.1-codex-mini", - "grok-4", "Grok-Code-Fast-1", - "claude-opus-4.1", "claude-sonnet-4.5", "claude-haiku-4.5", - "qwen3-30b-a3b-instruct-2507", "qwen3-30b-a3b-thinking-2507", - "qwen3-coder-30b-a3b-instruct", "qwen3-max-preview", - "kimi-k2-turbo-preview", "step-3", - "codestral-2508", "mistral-medium-2508", - "stealth-model-1", - "openrouter/sonoma-dusk-alpha", "openrouter/sonoma-sky-alpha", - "x-ai/grok-4.1-fast", "openrouter/sherlock-think-alpha" - ] - - if model_id in non_hf_models: - return None - - try: - # Fetch trending models data from HuggingFace API - response = requests.get("https://huggingface.co/api/trending", timeout=10) - - if response.status_code != 200: - print(f"Failed to fetch trending models API: HTTP {response.status_code}") - return None - - trending_data = response.json() - recently_trending = trending_data.get("recentlyTrending", []) - - # Find the specific model in trending data - model_info = None - for item in recently_trending: - repo_data = item.get("repoData", {}) - if repo_data.get("id") == model_id: - model_info = repo_data - break - - # If not found in trending, try to get model info directly from API - if not model_info: - try: - api = HfApi() - info = api.model_info(model_id) - pipeline_tag = getattr(info, "pipeline_tag", None) - - # Check if model has inference providers via model info - # Note: The direct API might not have availableInferenceProviders - # In this case, we'll generate a generic template - has_inference = pipeline_tag is not None - - if has_inference: - return _generate_inference_code_template(model_id, pipeline_tag, True) - except Exception as e: - print(f"Could not fetch model info for {model_id}: {e}") - return None - else: - # Extract pipeline tag and inference providers info - pipeline_tag = model_info.get("pipeline_tag") - inference_providers = model_info.get("availableInferenceProviders", []) - has_inference_providers = len(inference_providers) > 0 - - # Generate code template based on pipeline tag - return _generate_inference_code_template(model_id, pipeline_tag, has_inference_providers) - - return None - - except Exception as e: - print(f"Error fetching inference provider code: {e}") - return None - - -# Global storage for code alternatives (used when both inference and local code are available) -_model_code_alternatives = {} - - -def store_model_code_alternatives(model_id: str, inference_code: Optional[str], local_code: Optional[str]): - """Store both code alternatives for a model for later retrieval.""" - global _model_code_alternatives - _model_code_alternatives[model_id] = { - 'inference': inference_code, - 'local': local_code - } - - -def get_model_code_alternatives(model_id: str) -> Dict[str, Optional[str]]: - """Retrieve stored code alternatives for a model.""" - global _model_code_alternatives - return _model_code_alternatives.get(model_id, {'inference': None, 'local': None}) - - -def import_model_from_hf(model_id: str, prefer_local: bool = False) -> Tuple[str, str, str, str]: - """ - Import a HuggingFace model by ID and extract code snippet. - Tries to fetch both inference provider code and transformers/diffusers code from README. - - Args: - model_id: The HuggingFace model ID - prefer_local: If True and both options available, return local code instead of inference code - - Returns: (status, code, language, model_url) - """ - if not model_id or model_id == "": - return "Please select a model.", "", "python", "" - - # Skip non-HuggingFace models (external APIs) - these are not importable - non_hf_models = [ - "gemini-3.0-pro", "gemini-2.5-flash", "gemini-2.5-pro", - "gemini-flash-latest", "gemini-flash-lite-latest", - "gpt-5", "gpt-5.1", "gpt-5.1-instant", "gpt-5.1-codex", "gpt-5.1-codex-mini", - "grok-4", "Grok-Code-Fast-1", - "claude-opus-4.1", "claude-sonnet-4.5", "claude-haiku-4.5", - "qwen3-30b-a3b-instruct-2507", "qwen3-30b-a3b-thinking-2507", - "qwen3-coder-30b-a3b-instruct", "qwen3-max-preview", - "kimi-k2-turbo-preview", "step-3", - "codestral-2508", "mistral-medium-2508", - "stealth-model-1", - "openrouter/sonoma-dusk-alpha", "openrouter/sonoma-sky-alpha", - "x-ai/grok-4.1-fast", "openrouter/sherlock-think-alpha" - ] - - if model_id in non_hf_models: - return f"āŒ `{model_id}` is not a HuggingFace model and cannot be imported. This model is accessed via external API.", "", "python", "" - - # Build model URL - model_url = f"https://huggingface.co/{model_id}" - - # Try to fetch both types of code - inference_code = _fetch_inference_provider_code(model_id) - - # Also try to extract transformers/diffusers code from README - readme_status, readme_code, _ = import_repo_to_app(model_url) - has_readme_code = readme_code and ("transformers" in readme_code or "diffusers" in readme_code) - - # Store both alternatives for later switching - store_model_code_alternatives(model_id, inference_code, readme_code if has_readme_code else None) - - # Build status message and code based on what's available - if inference_code and has_readme_code: - # Both available - provide choice - if prefer_local: - status = f"""āœ… **Found multiple code options for `{model_id}`** - -**Currently showing:** Local Transformers/Diffusers Code (Option 2) šŸ’» - -**Option 1: Inference Provider Code (Serverless)** āš” -- Uses HuggingFace Inference API (serverless, pay-per-use) -- No GPU required, instant startup -- Requires `HF_TOKEN` environment variable - -**Option 2: Local Transformers/Diffusers Code (Currently Active)** šŸ’» -- Runs locally on your hardware -- Requires GPU for optimal performance -- Full control over model parameters - ---- - -To switch to inference provider code, click the button below or ask: "Show me the inference provider code instead" -""" - code = readme_code - else: - status = f"""āœ… **Found multiple code options for `{model_id}`** - -**Currently showing:** Inference Provider Code (Option 1) āš” *Recommended* - -**Option 1: Inference Provider Code (Serverless - Currently Active)** āš” -- Uses HuggingFace Inference API (serverless, pay-per-use) -- No GPU required, instant startup -- Requires `HF_TOKEN` environment variable - -**Option 2: Local Transformers/Diffusers Code** šŸ’» -- Runs locally on your hardware -- Requires GPU for optimal performance -- Full control over model parameters - ---- - -To switch to local transformers/diffusers code, click the button below or ask: "Show me the local transformers code instead" -""" - code = inference_code - - language = "gradio" - return status, code, language, model_url - - elif inference_code: - # Only inference provider code available - status = f"āœ… Imported inference provider code for `{model_id}` (serverless inference)" - language = "gradio" - return status, inference_code, language, model_url - - elif has_readme_code: - # Only README code available - status = f"āœ… Imported transformers/diffusers code from README for `{model_id}` (local inference)" - language = "gradio" - return status, readme_code, language, model_url - - else: - # No code found - status = f"āš ļø No inference provider or transformers/diffusers code found for `{model_id}`" - return status, "", "python", model_url - - -def switch_model_code_type(model_id: str, current_code: str) -> Tuple[str, str]: - """ - Switch between inference provider code and local transformers/diffusers code. - - Args: - model_id: The model ID - current_code: The currently displayed code - - Returns: (status_message, new_code) - """ - alternatives = get_model_code_alternatives(model_id) - inference_code = alternatives['inference'] - local_code = alternatives['local'] - - if not inference_code and not local_code: - return "āš ļø No alternative code available for this model.", current_code - - # Determine which code is currently shown - is_showing_inference = current_code == inference_code - - if is_showing_inference and local_code: - # Switch to local code - status = f"āœ… Switched to **Local Transformers/Diffusers Code** for `{model_id}` šŸ’»\n\nThis code runs locally on your hardware." - return status, local_code - elif not is_showing_inference and inference_code: - # Switch to inference provider code - status = f"āœ… Switched to **Inference Provider Code** for `{model_id}` āš”\n\nThis code uses serverless HuggingFace Inference API." - return status, inference_code - else: - return "āš ļø Alternative code type not available for this model.", current_code - - -def import_repo_to_app(url: str, framework: str = "Gradio") -> Tuple[str, str, str]: - """Import a GitHub or HF model repo and return the raw code snippet from README/model card. - - Returns (status_markdown, code_snippet, preview_html). Preview left empty; UI will decide. - """ - if not url or not url.strip(): - return "Please enter a repository URL.", "", "" - kind, meta = _parse_repo_or_model_url(url) - if kind == "hf_space" and meta: - # Spaces already contain runnable apps; keep existing behavior to fetch main file raw - status, code = load_project_from_url(url) - return status, code, "" - # Fetch markdown - markdown = None - repo_id = None - pipeline_tag = None - library_name = None - if kind == "hf_model" and meta: - repo_id = meta.get("repo_id") - # Try model info to get pipeline tag/library - try: - api = HfApi() - info = api.model_info(repo_id) - pipeline_tag = getattr(info, "pipeline_tag", None) - library_name = getattr(info, "library_name", None) - except Exception: - pass - markdown = _fetch_hf_model_readme(repo_id) - elif kind == "github" and meta: - markdown = _fetch_github_readme(meta.get("owner"), meta.get("repo")) - else: - return "Error: Unsupported or invalid URL. Provide a GitHub repo or Hugging Face model URL.", "", "" - - if not markdown: - return "Error: Could not fetch README/model card.", "", "" - - lang, snippet = _extract_transformers_or_diffusers_snippet(markdown) - if not snippet: - return "Error: No relevant transformers/diffusers code block found in README/model card.", "", "" - - status = "āœ… Imported code snippet from README/model card. Use it as a starting point." - return status, snippet, "" - diff --git a/anycoder_app/docs_manager.py b/anycoder_app/docs_manager.py deleted file mode 100644 index bba1726a6a34ec6df0ca7bf1e442c56939048035..0000000000000000000000000000000000000000 --- a/anycoder_app/docs_manager.py +++ /dev/null @@ -1,1484 +0,0 @@ -""" -Documentation management for Gradio, ComfyUI, and FastRTC. -Handles fetching, caching, and updating documentation from llms.txt files. -""" -import os -import requests -import re -from datetime import datetime, timedelta -from typing import Optional - -from .config import ( - GRADIO_LLMS_TXT_URL, GRADIO_DOCS_CACHE_FILE, GRADIO_DOCS_LAST_UPDATE_FILE, - GRADIO_DOCS_UPDATE_ON_APP_UPDATE, _gradio_docs_content, _gradio_docs_last_fetched, - COMFYUI_LLMS_TXT_URL, COMFYUI_DOCS_CACHE_FILE, COMFYUI_DOCS_LAST_UPDATE_FILE, - COMFYUI_DOCS_UPDATE_ON_APP_UPDATE, _comfyui_docs_content, _comfyui_docs_last_fetched, - FASTRTC_LLMS_TXT_URL, FASTRTC_DOCS_CACHE_FILE, FASTRTC_DOCS_LAST_UPDATE_FILE, - FASTRTC_DOCS_UPDATE_ON_APP_UPDATE, _fastrtc_docs_content, _fastrtc_docs_last_fetched -) -from . import prompts - -def fetch_gradio_docs() -> Optional[str]: - """Fetch the latest Gradio documentation from llms.txt""" - try: - response = requests.get(GRADIO_LLMS_TXT_URL, timeout=10) - response.raise_for_status() - return response.text - except Exception as e: - print(f"Warning: Failed to fetch Gradio docs from {GRADIO_LLMS_TXT_URL}: {e}") - return None - -def fetch_comfyui_docs() -> Optional[str]: - """Fetch the latest ComfyUI documentation from llms.txt""" - try: - response = requests.get(COMFYUI_LLMS_TXT_URL, timeout=10) - response.raise_for_status() - return response.text - except Exception as e: - print(f"Warning: Failed to fetch ComfyUI docs from {COMFYUI_LLMS_TXT_URL}: {e}") - return None - -def fetch_fastrtc_docs() -> Optional[str]: - """Fetch the latest FastRTC documentation from llms.txt""" - try: - response = requests.get(FASTRTC_LLMS_TXT_URL, timeout=10) - response.raise_for_status() - return response.text - except Exception as e: - print(f"Warning: Failed to fetch FastRTC docs from {FASTRTC_LLMS_TXT_URL}: {e}") - return None - -def filter_problematic_instructions(content: str) -> str: - """Filter out problematic instructions that cause LLM to stop generation prematurely""" - if not content: - return content - - # List of problematic phrases that cause early termination when LLM encounters ``` in user code - problematic_patterns = [ - r"Output ONLY the code inside a ``` code block, and do not include any explanations or extra text", - r"output only the code inside a ```.*?``` code block", - r"Always output only the.*?code.*?inside.*?```.*?```.*?block", - r"Return ONLY the code inside a.*?```.*?``` code block", - r"Do NOT add the language name at the top of the code output", - r"do not include any explanations or extra text", - r"Always output only the.*?code blocks.*?shown above, and do not include any explanations", - r"Output.*?ONLY.*?code.*?inside.*?```.*?```", - r"Return.*?ONLY.*?code.*?inside.*?```.*?```", - r"Generate.*?ONLY.*?code.*?inside.*?```.*?```", - r"Provide.*?ONLY.*?code.*?inside.*?```.*?```", - ] - - # Remove problematic patterns - filtered_content = content - for pattern in problematic_patterns: - # Use case-insensitive matching - filtered_content = re.sub(pattern, "", filtered_content, flags=re.IGNORECASE | re.DOTALL) - - # Clean up any double newlines or extra whitespace left by removals - filtered_content = re.sub(r'\n\s*\n\s*\n', '\n\n', filtered_content) - filtered_content = re.sub(r'^\s+', '', filtered_content, flags=re.MULTILINE) - - return filtered_content - -def load_cached_gradio_docs() -> Optional[str]: - """Load cached Gradio documentation from file""" - try: - if os.path.exists(GRADIO_DOCS_CACHE_FILE): - with open(GRADIO_DOCS_CACHE_FILE, 'r', encoding='utf-8') as f: - return f.read() - except Exception as e: - print(f"Warning: Failed to load cached Gradio docs: {e}") - return None - -def save_gradio_docs_cache(content: str): - """Save Gradio documentation to cache file""" - try: - with open(GRADIO_DOCS_CACHE_FILE, 'w', encoding='utf-8') as f: - f.write(content) - with open(GRADIO_DOCS_LAST_UPDATE_FILE, 'w', encoding='utf-8') as f: - f.write(datetime.now().isoformat()) - except Exception as e: - print(f"Warning: Failed to save Gradio docs cache: {e}") - -def load_comfyui_docs_cache() -> Optional[str]: - """Load ComfyUI documentation from cache file""" - try: - if os.path.exists(COMFYUI_DOCS_CACHE_FILE): - with open(COMFYUI_DOCS_CACHE_FILE, 'r', encoding='utf-8') as f: - return f.read() - except Exception as e: - print(f"Warning: Failed to load cached ComfyUI docs: {e}") - return None - -def save_comfyui_docs_cache(content: str): - """Save ComfyUI documentation to cache file""" - try: - with open(COMFYUI_DOCS_CACHE_FILE, 'w', encoding='utf-8') as f: - f.write(content) - with open(COMFYUI_DOCS_LAST_UPDATE_FILE, 'w', encoding='utf-8') as f: - f.write(datetime.now().isoformat()) - except Exception as e: - print(f"Warning: Failed to save ComfyUI docs cache: {e}") - -def load_fastrtc_docs_cache() -> Optional[str]: - """Load FastRTC documentation from cache file""" - try: - if os.path.exists(FASTRTC_DOCS_CACHE_FILE): - with open(FASTRTC_DOCS_CACHE_FILE, 'r', encoding='utf-8') as f: - return f.read() - except Exception as e: - print(f"Warning: Failed to load cached FastRTC docs: {e}") - return None - -def save_fastrtc_docs_cache(content: str): - """Save FastRTC documentation to cache file""" - try: - with open(FASTRTC_DOCS_CACHE_FILE, 'w', encoding='utf-8') as f: - f.write(content) - with open(FASTRTC_DOCS_LAST_UPDATE_FILE, 'w', encoding='utf-8') as f: - f.write(datetime.now().isoformat()) - except Exception as e: - print(f"Warning: Failed to save FastRTC docs cache: {e}") - -def get_last_update_time() -> Optional[datetime]: - """Get the last update time from file""" - try: - if os.path.exists(GRADIO_DOCS_LAST_UPDATE_FILE): - with open(GRADIO_DOCS_LAST_UPDATE_FILE, 'r', encoding='utf-8') as f: - return datetime.fromisoformat(f.read().strip()) - except Exception as e: - print(f"Warning: Failed to read last update time: {e}") - return None - -def should_update_gradio_docs() -> bool: - """Check if Gradio documentation should be updated""" - # Only update if we don't have cached content (first run or cache deleted) - return not os.path.exists(GRADIO_DOCS_CACHE_FILE) - -def should_update_comfyui_docs() -> bool: - """Check if ComfyUI documentation should be updated""" - # Only update if we don't have cached content (first run or cache deleted) - return not os.path.exists(COMFYUI_DOCS_CACHE_FILE) - -def should_update_fastrtc_docs() -> bool: - """Check if FastRTC documentation should be updated""" - # Only update if we don't have cached content (first run or cache deleted) - return not os.path.exists(FASTRTC_DOCS_CACHE_FILE) - -def force_update_gradio_docs(): - """ - Force an update of Gradio documentation (useful when app is updated). - - To manually refresh docs, you can call this function or simply delete the cache file: - rm .gradio_docs_cache.txt && restart the app - """ - global _gradio_docs_content, _gradio_docs_last_fetched - - print("šŸ”„ Forcing Gradio documentation update...") - latest_content = fetch_gradio_docs() - - if latest_content: - # Filter out problematic instructions that cause early termination - filtered_content = filter_problematic_instructions(latest_content) - _gradio_docs_content = filtered_content - _gradio_docs_last_fetched = datetime.now() - save_gradio_docs_cache(filtered_content) - update_gradio_system_prompts() - print("āœ… Gradio documentation updated successfully") - return True - else: - print("āŒ Failed to update Gradio documentation") - return False - -def force_update_comfyui_docs(): - """ - Force an update of ComfyUI documentation (useful when app is updated). - - To manually refresh docs, you can call this function or simply delete the cache file: - rm .comfyui_docs_cache.txt && restart the app - """ - global _comfyui_docs_content, _comfyui_docs_last_fetched - - print("šŸ”„ Forcing ComfyUI documentation update...") - latest_content = fetch_comfyui_docs() - - if latest_content: - # Filter out problematic instructions that cause early termination - filtered_content = filter_problematic_instructions(latest_content) - _comfyui_docs_content = filtered_content - _comfyui_docs_last_fetched = datetime.now() - save_comfyui_docs_cache(filtered_content) - update_json_system_prompts() - print("āœ… ComfyUI documentation updated successfully") - return True - else: - print("āŒ Failed to update ComfyUI documentation") - return False - -def force_update_fastrtc_docs(): - """ - Force an update of FastRTC documentation (useful when app is updated). - - To manually refresh docs, you can call this function or simply delete the cache file: - rm .fastrtc_docs_cache.txt && restart the app - """ - global _fastrtc_docs_content, _fastrtc_docs_last_fetched - - print("šŸ”„ Forcing FastRTC documentation update...") - latest_content = fetch_fastrtc_docs() - - if latest_content: - # Filter out problematic instructions that cause early termination - filtered_content = filter_problematic_instructions(latest_content) - _fastrtc_docs_content = filtered_content - _fastrtc_docs_last_fetched = datetime.now() - save_fastrtc_docs_cache(filtered_content) - update_gradio_system_prompts() - print("āœ… FastRTC documentation updated successfully") - return True - else: - print("āŒ Failed to update FastRTC documentation") - return False - -def get_gradio_docs_content() -> str: - """Get the current Gradio documentation content, updating if necessary""" - global _gradio_docs_content, _gradio_docs_last_fetched - - # Check if we need to update - if (_gradio_docs_content is None or - _gradio_docs_last_fetched is None or - should_update_gradio_docs()): - - print("Updating Gradio documentation...") - - # Try to fetch latest content - latest_content = fetch_gradio_docs() - - if latest_content: - # Filter out problematic instructions that cause early termination - filtered_content = filter_problematic_instructions(latest_content) - _gradio_docs_content = filtered_content - _gradio_docs_last_fetched = datetime.now() - save_gradio_docs_cache(filtered_content) - print("āœ… Gradio documentation updated successfully") - else: - # Fallback to cached content - cached_content = load_cached_gradio_docs() - if cached_content: - _gradio_docs_content = cached_content - _gradio_docs_last_fetched = datetime.now() - print("āš ļø Using cached Gradio documentation (network fetch failed)") - else: - # Fallback to minimal content - _gradio_docs_content = """ - # Gradio API Reference (Offline Fallback) - - This is a minimal fallback when documentation cannot be fetched. - Please check your internet connection for the latest API reference. - - Basic Gradio components: Button, Textbox, Slider, Image, Audio, Video, File, etc. - Use gr.Blocks() for custom layouts and gr.Interface() for simple apps. - """ - print("āŒ Using minimal fallback documentation") - - return _gradio_docs_content or "" - -def get_comfyui_docs_content() -> str: - """Get the current ComfyUI documentation content, updating if necessary""" - global _comfyui_docs_content, _comfyui_docs_last_fetched - - # Check if we need to update - if (_comfyui_docs_content is None or - _comfyui_docs_last_fetched is None or - should_update_comfyui_docs()): - - print("Updating ComfyUI documentation...") - - # Try to fetch latest content - latest_content = fetch_comfyui_docs() - - if latest_content: - # Filter out problematic instructions that cause early termination - filtered_content = filter_problematic_instructions(latest_content) - _comfyui_docs_content = filtered_content - _comfyui_docs_last_fetched = datetime.now() - save_comfyui_docs_cache(filtered_content) - print("āœ… ComfyUI documentation updated successfully") - else: - # Fallback to cached content - cached_content = load_comfyui_docs_cache() - if cached_content: - _comfyui_docs_content = cached_content - _comfyui_docs_last_fetched = datetime.now() - print("āš ļø Using cached ComfyUI documentation (network fetch failed)") - else: - # Fallback to minimal content - _comfyui_docs_content = """ - # ComfyUI API Reference (Offline Fallback) - - This is a minimal fallback when documentation cannot be fetched. - Please check your internet connection for the latest API reference. - - Basic ComfyUI workflow structure: nodes, connections, inputs, outputs. - Use CheckpointLoaderSimple, CLIPTextEncode, KSampler for basic workflows. - """ - print("āŒ Using minimal fallback documentation") - - return _comfyui_docs_content or "" - -def get_fastrtc_docs_content() -> str: - """Get the current FastRTC documentation content, updating if necessary""" - global _fastrtc_docs_content, _fastrtc_docs_last_fetched - - # Check if we need to update - if (_fastrtc_docs_content is None or - _fastrtc_docs_last_fetched is None or - should_update_fastrtc_docs()): - - print("Updating FastRTC documentation...") - - # Try to fetch latest content - latest_content = fetch_fastrtc_docs() - - if latest_content: - # Filter out problematic instructions that cause early termination - filtered_content = filter_problematic_instructions(latest_content) - _fastrtc_docs_content = filtered_content - _fastrtc_docs_last_fetched = datetime.now() - save_fastrtc_docs_cache(filtered_content) - print("āœ… FastRTC documentation updated successfully") - else: - # Fallback to cached content - cached_content = load_fastrtc_docs_cache() - if cached_content: - _fastrtc_docs_content = cached_content - _fastrtc_docs_last_fetched = datetime.now() - print("āš ļø Using cached FastRTC documentation (network fetch failed)") - else: - # Fallback to minimal content - _fastrtc_docs_content = """ - # FastRTC API Reference (Offline Fallback) - - This is a minimal fallback when documentation cannot be fetched. - Please check your internet connection for the latest API reference. - - Basic FastRTC usage: Stream class, handlers, real-time audio/video processing. - Use Stream(handler, modality, mode) for real-time communication apps. - """ - print("āŒ Using minimal fallback documentation") - - return _fastrtc_docs_content or "" - -def update_gradio_system_prompts(): - """Update the global Gradio system prompts with latest documentation""" - docs_content = get_gradio_docs_content() - fastrtc_content = get_fastrtc_docs_content() - - # Base system prompt - base_prompt = """You are an expert Gradio developer. Create a complete, working Gradio application based on the user's request. Generate all necessary code to make the application functional and runnable. - -šŸšØ CRITICAL OUTPUT RULES: -- DO NOT use tags or thinking blocks in your output -- DO NOT use [TOOL_CALL] or any tool call markers -- Generate ONLY the requested code files and requirements.txt -- No explanatory text outside the code blocks - -## šŸŽÆ Working with Imported Model Code - -**CRITICAL: If the user has imported model code in the conversation history (InferenceClient, transformers, diffusers), you MUST integrate it into your Gradio application!** - -**For InferenceClient Code (HuggingFace Inference API):** -- DO NOT just copy the standalone inference code -- Create a complete Gradio application that wraps the inference code -- Use `gr.ChatInterface()` for chat models or appropriate interface for other tasks -- Extract the model name from the imported code -- Implement proper streaming if the model supports it -- Handle conversation history correctly - -**Example Structure for Chatbot:** -```python -import gradio as gr -import os -from huggingface_hub import InferenceClient - -# Use the InferenceClient configuration from imported code -client = InferenceClient(api_key=os.environ["HF_TOKEN"]) - -def respond(message, history): - # Build messages from history - messages = [{"role": "system", "content": "You are a helpful assistant."}] - for user_msg, assistant_msg in history: - messages.append({"role": "user", "content": user_msg}) - messages.append({"role": "assistant", "content": assistant_msg}) - messages.append({"role": "user", "content": message}) - - # Call the model (use model name from imported code) - response = "" - for chunk in client.chat.completions.create( - model="MODEL_NAME_FROM_IMPORTED_CODE", - messages=messages, - stream=True, - max_tokens=1024, - ): - if chunk.choices[0].delta.content: - response += chunk.choices[0].delta.content - yield response - -demo = gr.ChatInterface(respond, title="Chatbot", description="Chat with the model") -demo.launch() -``` - -**For Transformers/Diffusers Code:** -- Extract model loading and inference logic -- Wrap it in appropriate Gradio interface -- For chat models: use gr.ChatInterface -- For image generation: use gr.Interface with image output -- For other tasks: choose appropriate interface type -- Include proper error handling and loading states - -**Key Requirements:** -1. āœ… ALWAYS create a complete Gradio application, not just inference code -2. āœ… Extract model configuration from imported code -3. āœ… Use appropriate Gradio interface for the task -4. āœ… Include demo.launch() at the end -5. āœ… Add requirements.txt with necessary dependencies - -## Multi-File Application Structure - -When creating complex Gradio applications, organize your code into multiple files for better maintainability: - -**File Organization:** -- `app.py` - Main application entry point with Gradio interface -- `utils.py` - Utility functions and helpers -- `models.py` - Model loading and inference functions -- `config.py` - Configuration and constants -- `requirements.txt` - Python dependencies -- Additional modules as needed (e.g., `data_processing.py`, `ui_components.py`) - -**šŸšØ CRITICAL: DO NOT Generate README.md Files** -- NEVER generate README.md files under any circumstances -- A template README.md is automatically provided and will be overridden by the deployment system -- 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: - -``` -=== app.py === -[main application code] - -=== utils.py === -[utility functions] - -=== requirements.txt === -[dependencies] -``` - -**šŸšØ CRITICAL: Always Generate requirements.txt for New Applications** -- ALWAYS include requirements.txt when creating new Gradio applications -- Generate comprehensive, production-ready dependencies based on your code -- Include not just direct imports but also commonly needed companion packages -- Use correct PyPI package names (e.g., PIL ā†’ Pillow, sklearn ā†’ scikit-learn) -- For diffusers: use `git+https://github.com/huggingface/diffusers` -- For transformers: use `git+https://github.com/huggingface/transformers` -- Include supporting packages (accelerate, torch, tokenizers, etc.) when using ML libraries -- Your requirements.txt should ensure the application works smoothly in production - -**šŸšØ CRITICAL: requirements.txt Formatting Rules** -- Output ONLY plain text package names, one per line -- Do NOT use markdown formatting (no ```, no bold, no headings, no lists with * or -) -- Do NOT add explanatory text or descriptions -- Do NOT wrap in code blocks -- Just raw package names as they would appear in a real requirements.txt file -- Example of CORRECT format: - gradio - torch - transformers -- Example of INCORRECT format (DO NOT DO THIS): - ``` - gradio # For web interface - **Core dependencies:** - - torch - ``` - -**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 models or processing pipelines - - Extensive utility functions - - Complex UI with many components - - Data processing workflows - - When user specifically requests modular structure - -šŸšØ IMPORTANT: If the user is asking to use external APIs (like OpenRouter, OpenAI API, Hugging Face Inference API, etc.), DO NOT use @spaces.GPU decorators or any ZeroGPU features. External APIs handle the model inference remotely, so GPU allocation on the Spaces instance is not needed. - -šŸšØ CRITICAL REQUIREMENT: If the user provides ANY diffusion model code (FLUX, Stable Diffusion, etc.) that runs locally (not via API), you MUST implement ZeroGPU ahead-of-time (AoT) compilation. This is mandatory and provides 1.3x-1.8x performance improvements. Do not create basic Gradio apps without AoT optimization for diffusion models. - -## ZeroGPU Integration (MANDATORY) - -ALWAYS use ZeroGPU for GPU-dependent functions in Gradio apps: - -1. Import the spaces module: `import spaces` -2. Decorate GPU-dependent functions with `@spaces.GPU` -3. Specify appropriate duration based on expected runtime: - - Quick inference (< 30s): `@spaces.GPU(duration=30)` - - Standard generation (30-60s): `@spaces.GPU` (default 60s) - - Complex generation (60-120s): `@spaces.GPU(duration=120)` - - Heavy processing (120-180s): `@spaces.GPU(duration=180)` - -Example usage: -```python -import spaces -from diffusers import DiffusionPipeline - -pipe = DiffusionPipeline.from_pretrained(...) -pipe.to('cuda') - -@spaces.GPU(duration=120) -def generate(prompt): - return pipe(prompt).images - -gr.Interface( - fn=generate, - inputs=gr.Text(), - outputs=gr.Gallery(), -).launch() -``` - -Duration Guidelines: -- Shorter durations improve queue priority for users -- Text-to-image: typically 30-60 seconds -- Image-to-image: typically 20-40 seconds -- Video generation: typically 60-180 seconds -- Audio/music generation: typically 30-90 seconds -- Model loading + inference: add 10-30s buffer -- AoT compilation during startup: use @spaces.GPU(duration=1500) for maximum allowed duration - -Functions that typically need @spaces.GPU: -- Image generation (text-to-image, image-to-image) -- Video generation -- Audio/music generation -- Model inference with transformers, diffusers -- Any function using .to('cuda') or GPU operations - -## CRITICAL: Use ZeroGPU AoT Compilation for ALL Diffusion Models - -FOR ANY DIFFUSION MODEL (FLUX, Stable Diffusion, etc.), YOU MUST IMPLEMENT AHEAD-OF-TIME COMPILATION. -This is NOT optional - it provides 1.3x-1.8x speedup and is essential for production ZeroGPU Spaces. - -ALWAYS implement this pattern for diffusion models: - -### MANDATORY: Basic AoT Compilation Pattern -YOU MUST USE THIS EXACT PATTERN for any diffusion model (FLUX, Stable Diffusion, etc.): - -1. ALWAYS add AoT compilation function with @spaces.GPU(duration=1500) -2. ALWAYS use spaces.aoti_capture to capture inputs -3. ALWAYS use torch.export.export to export the transformer -4. ALWAYS use spaces.aoti_compile to compile -5. ALWAYS use spaces.aoti_apply to apply to pipeline - -### Required AoT Implementation -```python -import spaces -import torch -from diffusers import DiffusionPipeline - -MODEL_ID = 'black-forest-labs/FLUX.1-dev' -pipe = DiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16) -pipe.to('cuda') - -@spaces.GPU(duration=1500) # Maximum duration allowed during startup -def compile_transformer(): - # 1. Capture example inputs - with spaces.aoti_capture(pipe.transformer) as call: - pipe("arbitrary example prompt") - - # 2. Export the model - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - ) - - # 3. Compile the exported model - return spaces.aoti_compile(exported) - -# 4. Apply compiled model to pipeline -compiled_transformer = compile_transformer() -spaces.aoti_apply(compiled_transformer, pipe.transformer) - -@spaces.GPU -def generate(prompt): - return pipe(prompt).images -``` - -### Advanced Optimizations - -#### FP8 Quantization (Additional 1.2x speedup on H200) -```python -from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig - -@spaces.GPU(duration=1500) -def compile_transformer_with_quantization(): - # Quantize before export for FP8 speedup - quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig()) - - with spaces.aoti_capture(pipe.transformer) as call: - pipe("arbitrary example prompt") - - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - ) - return spaces.aoti_compile(exported) -``` - -#### Dynamic Shapes (Variable input sizes) -```python -from torch.utils._pytree import tree_map - -@spaces.GPU(duration=1500) -def compile_transformer_dynamic(): - with spaces.aoti_capture(pipe.transformer) as call: - pipe("arbitrary example prompt") - - # Define dynamic dimension ranges (model-dependent) - transformer_hidden_dim = torch.export.Dim('hidden', min=4096, max=8212) - - # Map argument names to dynamic dimensions - transformer_dynamic_shapes = { - "hidden_states": {1: transformer_hidden_dim}, - "img_ids": {0: transformer_hidden_dim}, - } - - # Create dynamic shapes structure - dynamic_shapes = tree_map(lambda v: None, call.kwargs) - dynamic_shapes.update(transformer_dynamic_shapes) - - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - dynamic_shapes=dynamic_shapes, - ) - return spaces.aoti_compile(exported) -``` - -#### Multi-Compile for Different Resolutions -```python -@spaces.GPU(duration=1500) -def compile_multiple_resolutions(): - compiled_models = {} - resolutions = [(512, 512), (768, 768), (1024, 1024)] - - for width, height in resolutions: - # Capture inputs for specific resolution - with spaces.aoti_capture(pipe.transformer) as call: - pipe(f"test prompt {width}x{height}", width=width, height=height) - - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - ) - compiled_models[f"{width}x{height}"] = spaces.aoti_compile(exported) - - return compiled_models - -# Usage with resolution dispatch -compiled_models = compile_multiple_resolutions() - -@spaces.GPU -def generate_with_resolution(prompt, width=1024, height=1024): - resolution_key = f"{width}x{height}" - if resolution_key in compiled_models: - # Temporarily apply the right compiled model - spaces.aoti_apply(compiled_models[resolution_key], pipe.transformer) - return pipe(prompt, width=width, height=height).images -``` - -#### FlashAttention-3 Integration -```python -from kernels import get_kernel - -# Load pre-built FA3 kernel compatible with H200 -try: - vllm_flash_attn3 = get_kernel("kernels-community/vllm-flash-attn3") - print("āœ… FlashAttention-3 kernel loaded successfully") -except Exception as e: - print(f"āš ļø FlashAttention-3 not available: {e}") - -# Custom attention processor example -class FlashAttention3Processor: - def __call__(self, attn, hidden_states, encoder_hidden_states=None, attention_mask=None): - # Use FA3 kernel for attention computation - return vllm_flash_attn3(hidden_states, encoder_hidden_states, attention_mask) - -# Apply FA3 processor to model -if 'vllm_flash_attn3' in locals(): - for name, module in pipe.transformer.named_modules(): - if hasattr(module, 'processor'): - module.processor = FlashAttention3Processor() -``` - -### Complete Optimized Example -```python -import spaces -import torch -from diffusers import DiffusionPipeline -from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig - -MODEL_ID = 'black-forest-labs/FLUX.1-dev' -pipe = DiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16) -pipe.to('cuda') - -@spaces.GPU(duration=1500) -def compile_optimized_transformer(): - # Apply FP8 quantization - quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig()) - - # Capture inputs - with spaces.aoti_capture(pipe.transformer) as call: - pipe("optimization test prompt") - - # Export and compile - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - ) - return spaces.aoti_compile(exported) - -# Compile during startup -compiled_transformer = compile_optimized_transformer() -spaces.aoti_apply(compiled_transformer, pipe.transformer) - -@spaces.GPU -def generate(prompt): - return pipe(prompt).images -``` - -**Expected Performance Gains:** -- Basic AoT: 1.3x-1.8x speedup -- + FP8 Quantization: Additional 1.2x speedup -- + FlashAttention-3: Additional attention speedup -- Total potential: 2x-3x faster inference -**Hardware Requirements:** -- FP8 quantization requires CUDA compute capability ā‰„ 9.0 (H200 āœ…) -- FlashAttention-3 works on H200 hardware via kernels library -- Dynamic shapes add flexibility for variable input sizes -## MCP Server Integration - -When the user requests an MCP-enabled Gradio app or asks for tool calling capabilities, you MUST enable MCP server functionality. - -**šŸšØ CRITICAL: Enabling MCP Server** -To make your Gradio app function as an MCP (Model Control Protocol) server: -1. Set `mcp_server=True` in the `.launch()` method -2. Add `"gradio[mcp]"` to requirements.txt (not just `gradio`) -3. Ensure all functions have detailed docstrings with proper Args sections -4. Use type hints for all function parameters - -**Example:** -``` -import gradio as gr - -def letter_counter(word: str, letter: str) -> int: - \"\"\" - Count the number of occurrences of a letter in a word or text. - - Args: - word (str): The input text to search through - letter (str): The letter to search for - - Returns: - int: The number of times the letter appears - \"\"\" - return word.lower().count(letter.lower()) - -demo = gr.Interface( - fn=letter_counter, - inputs=[gr.Textbox("strawberry"), gr.Textbox("r")], - outputs=[gr.Number()], - title="Letter Counter", - description="Count letter occurrences in text." -) - -if __name__ == "__main__": - demo.launch(mcp_server=True) -``` - -**When to Enable MCP:** -- User explicitly requests "MCP server" or "MCP-enabled app" -- User wants tool calling capabilities for LLMs -- User mentions Claude Desktop, Cursor, or Cline integration -- User wants to expose functions as tools for AI assistants - -**MCP Requirements:** -1. **Dependencies:** Always use `gradio[mcp]` in requirements.txt (not plain `gradio`) -2. **Docstrings:** Every function must have a detailed docstring with: - - Brief description on first line - - Args section listing each parameter with type and description - - Returns section (optional but recommended) -3. **Type Hints:** All parameters must have type hints (e.g., `word: str`, `count: int`) -4. **Default Values:** Use default values in components to provide examples - -**Best Practices for MCP Tools:** -- Use descriptive function names (they become tool names) -- Keep functions focused and single-purpose -- Accept string parameters when possible for better compatibility -- Return simple types (str, int, float, list, dict) rather than complex objects -- Use gr.Header for authentication headers when needed -- Use gr.Progress() for long-running operations - -**Multiple Tools Example:** -``` -import gradio as gr - -def add_numbers(a: str, b: str) -> str: - \"\"\" - Add two numbers together. - - Args: - a (str): First number - b (str): Second number - - Returns: - str: Sum of the two numbers - \"\"\" - return str(int(a) + int(b)) - -def multiply_numbers(a: str, b: str) -> str: - \"\"\" - Multiply two numbers. - - Args: - a (str): First number - b (str): Second number - - Returns: - str: Product of the two numbers - \"\"\" - return str(int(a) * int(b)) - -with gr.Blocks() as demo: - gr.Markdown("# Math Tools MCP Server") - - with gr.Tab("Add"): - gr.Interface(add_numbers, [gr.Textbox("5"), gr.Textbox("3")], gr.Textbox()) - - with gr.Tab("Multiply"): - gr.Interface(multiply_numbers, [gr.Textbox("4"), gr.Textbox("7")], gr.Textbox()) - -if __name__ == "__main__": - demo.launch(mcp_server=True) -``` - -**REMEMBER:** If MCP is requested, ALWAYS: -1. Set `mcp_server=True` in `.launch()` -2. Use `gradio[mcp]` in requirements.txt -3. Include complete docstrings with Args sections -4. Add type hints to all parameters - -## Complete Gradio API Reference - -This reference is automatically synced from https://www.gradio.app/llms.txt to ensure accuracy. - -""" - - # Search-enabled prompt - search_prompt = """You are an expert Gradio developer with access to real-time web search. Create a complete, working Gradio application based on the user's request. When needed, use web search to find current best practices or verify latest Gradio features. Generate all necessary code to make the application functional and runnable. - -## Multi-File Application Structure - -When creating complex Gradio applications, organize your code into multiple files for better maintainability: - -**File Organization:** -- `app.py` - Main application entry point with Gradio interface -- `utils.py` - Utility functions and helpers -- `models.py` - Model loading and inference functions -- `config.py` - Configuration and constants -- `requirements.txt` - Python dependencies -- Additional modules as needed (e.g., `data_processing.py`, `ui_components.py`) - -**šŸšØ CRITICAL: DO NOT Generate README.md Files** -- NEVER generate README.md files under any circumstances -- A template README.md is automatically provided and will be overridden by the deployment system -- 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: - -``` -=== app.py === -[main application code] - -=== utils.py === -[utility functions] - -=== requirements.txt === -[dependencies] -``` - -**šŸšØ CRITICAL: requirements.txt Formatting Rules** -- Output ONLY plain text package names, one per line -- Do NOT use markdown formatting (no ```, no bold, no headings, no lists with * or -) -- Do NOT add explanatory text or descriptions -- Do NOT wrap in code blocks -- Just raw package names as they would appear in a real requirements.txt file -- Example of CORRECT format: - gradio - torch - transformers -- Example of INCORRECT format (DO NOT DO THIS): - ``` - gradio # For web interface - **Core dependencies:** - - torch - ``` - -**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 models or processing pipelines - - Extensive utility functions - - Complex UI with many components - - Data processing workflows - - When user specifically requests modular structure - -šŸšØ IMPORTANT: If the user is asking to use external APIs (like OpenRouter, OpenAI API, Hugging Face Inference API, etc.), DO NOT use @spaces.GPU decorators or any ZeroGPU features. External APIs handle the model inference remotely, so GPU allocation on the Spaces instance is not needed. - -šŸšØ CRITICAL REQUIREMENT: If the user provides ANY diffusion model code (FLUX, Stable Diffusion, etc.) that runs locally (not via API), you MUST implement ZeroGPU ahead-of-time (AoT) compilation. This is mandatory and provides 1.3x-1.8x performance improvements. Do not create basic Gradio apps without AoT optimization for diffusion models. - -## ZeroGPU Integration (MANDATORY) - -ALWAYS use ZeroGPU for GPU-dependent functions in Gradio apps: - -1. Import the spaces module: `import spaces` -2. Decorate GPU-dependent functions with `@spaces.GPU` -3. Specify appropriate duration based on expected runtime: - - Quick inference (< 30s): `@spaces.GPU(duration=30)` - - Standard generation (30-60s): `@spaces.GPU` (default 60s) - - Complex generation (60-120s): `@spaces.GPU(duration=120)` - - Heavy processing (120-180s): `@spaces.GPU(duration=180)` - -Example usage: -``` -import spaces -from diffusers import DiffusionPipeline - -pipe = DiffusionPipeline.from_pretrained(...) -pipe.to('cuda') - -@spaces.GPU(duration=120) -def generate(prompt): - return pipe(prompt).images - -gr.Interface( - fn=generate, - inputs=gr.Text(), - outputs=gr.Gallery(), -).launch() -``` - -Duration Guidelines: -- Shorter durations improve queue priority for users -- Text-to-image: typically 30-60 seconds -- Image-to-image: typically 20-40 seconds -- Video generation: typically 60-180 seconds -- Audio/music generation: typically 30-90 seconds -- Model loading + inference: add 10-30s buffer -- AoT compilation during startup: use @spaces.GPU(duration=1500) for maximum allowed duration - -Functions that typically need @spaces.GPU: -- Image generation (text-to-image, image-to-image) -- Video generation -- Audio/music generation -- Model inference with transformers, diffusers -- Any function using .to('cuda') or GPU operations - -## CRITICAL: Use ZeroGPU AoT Compilation for ALL Diffusion Models - -FOR ANY DIFFUSION MODEL (FLUX, Stable Diffusion, etc.), YOU MUST IMPLEMENT AHEAD-OF-TIME COMPILATION. -This is NOT optional - it provides 1.3x-1.8x speedup and is essential for production ZeroGPU Spaces. - -ALWAYS implement this pattern for diffusion models: - -### MANDATORY: Basic AoT Compilation Pattern -YOU MUST USE THIS EXACT PATTERN for any diffusion model (FLUX, Stable Diffusion, etc.): - -1. ALWAYS add AoT compilation function with @spaces.GPU(duration=1500) -2. ALWAYS use spaces.aoti_capture to capture inputs -3. ALWAYS use torch.export.export to export the transformer -4. ALWAYS use spaces.aoti_compile to compile -5. ALWAYS use spaces.aoti_apply to apply to pipeline - -### Required AoT Implementation - -For production Spaces with heavy models, use ahead-of-time (AoT) compilation for 1.3x-1.8x speedups: - -### Basic AoT Compilation -``` -import spaces -import torch -from diffusers import DiffusionPipeline - -MODEL_ID = 'black-forest-labs/FLUX.1-dev' -pipe = DiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16) -pipe.to('cuda') - -@spaces.GPU(duration=1500) # Maximum duration allowed during startup -def compile_transformer(): - # 1. Capture example inputs - with spaces.aoti_capture(pipe.transformer) as call: - pipe("arbitrary example prompt") - - # 2. Export the model - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - ) - - # 3. Compile the exported model - return spaces.aoti_compile(exported) - -# 4. Apply compiled model to pipeline -compiled_transformer = compile_transformer() -spaces.aoti_apply(compiled_transformer, pipe.transformer) - -@spaces.GPU -def generate(prompt): - return pipe(prompt).images -``` - -### Advanced Optimizations - -#### FP8 Quantization (Additional 1.2x speedup on H200) -``` -from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig - -@spaces.GPU(duration=1500) -def compile_transformer_with_quantization(): - # Quantize before export for FP8 speedup - quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig()) - - with spaces.aoti_capture(pipe.transformer) as call: - pipe("arbitrary example prompt") - - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - ) - return spaces.aoti_compile(exported) -``` - -#### Dynamic Shapes (Variable input sizes) -``` -from torch.utils._pytree import tree_map - -@spaces.GPU(duration=1500) -def compile_transformer_dynamic(): - with spaces.aoti_capture(pipe.transformer) as call: - pipe("arbitrary example prompt") - - # Define dynamic dimension ranges (model-dependent) - transformer_hidden_dim = torch.export.Dim('hidden', min=4096, max=8212) - - # Map argument names to dynamic dimensions - transformer_dynamic_shapes = { - "hidden_states": {1: transformer_hidden_dim}, - "img_ids": {0: transformer_hidden_dim}, - } - - # Create dynamic shapes structure - dynamic_shapes = tree_map(lambda v: None, call.kwargs) - dynamic_shapes.update(transformer_dynamic_shapes) - - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - dynamic_shapes=dynamic_shapes, - ) - return spaces.aoti_compile(exported) -``` - -#### Multi-Compile for Different Resolutions -``` -@spaces.GPU(duration=1500) -def compile_multiple_resolutions(): - compiled_models = {} - resolutions = [(512, 512), (768, 768), (1024, 1024)] - - for width, height in resolutions: - # Capture inputs for specific resolution - with spaces.aoti_capture(pipe.transformer) as call: - pipe(f"test prompt {width}x{height}", width=width, height=height) - - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - ) - compiled_models[f"{width}x{height}"] = spaces.aoti_compile(exported) - - return compiled_models - -# Usage with resolution dispatch -compiled_models = compile_multiple_resolutions() - -@spaces.GPU -def generate_with_resolution(prompt, width=1024, height=1024): - resolution_key = f"{width}x{height}" - if resolution_key in compiled_models: - # Temporarily apply the right compiled model - spaces.aoti_apply(compiled_models[resolution_key], pipe.transformer) - return pipe(prompt, width=width, height=height).images -``` - -#### FlashAttention-3 Integration -``` -from kernels import get_kernel - -# Load pre-built FA3 kernel compatible with H200 -try: - vllm_flash_attn3 = get_kernel("kernels-community/vllm-flash-attn3") - print("āœ… FlashAttention-3 kernel loaded successfully") -except Exception as e: - print(f"āš ļø FlashAttention-3 not available: {e}") - -# Custom attention processor example -class FlashAttention3Processor: - def __call__(self, attn, hidden_states, encoder_hidden_states=None, attention_mask=None): - # Use FA3 kernel for attention computation - return vllm_flash_attn3(hidden_states, encoder_hidden_states, attention_mask) - -# Apply FA3 processor to model -if 'vllm_flash_attn3' in locals(): - for name, module in pipe.transformer.named_modules(): - if hasattr(module, 'processor'): - module.processor = FlashAttention3Processor() -``` - -### Complete Optimized Example -``` -import spaces -import torch -from diffusers import DiffusionPipeline -from torchao.quantization import quantize_, Float8DynamicActivationFloat8WeightConfig - -MODEL_ID = 'black-forest-labs/FLUX.1-dev' -pipe = DiffusionPipeline.from_pretrained(MODEL_ID, torch_dtype=torch.bfloat16) -pipe.to('cuda') - -@spaces.GPU(duration=1500) -def compile_optimized_transformer(): - # Apply FP8 quantization - quantize_(pipe.transformer, Float8DynamicActivationFloat8WeightConfig()) - - # Capture inputs - with spaces.aoti_capture(pipe.transformer) as call: - pipe("optimization test prompt") - - # Export and compile - exported = torch.export.export( - pipe.transformer, - args=call.args, - kwargs=call.kwargs, - ) - return spaces.aoti_compile(exported) - -# Compile during startup -compiled_transformer = compile_optimized_transformer() -spaces.aoti_apply(compiled_transformer, pipe.transformer) - -@spaces.GPU -def generate(prompt): - return pipe(prompt).images -``` - -**Expected Performance Gains:** -- Basic AoT: 1.3x-1.8x speedup -- + FP8 Quantization: Additional 1.2x speedup -- + FlashAttention-3: Additional attention speedup -- Total potential: 2x-3x faster inference - -**Hardware Requirements:** -- FP8 quantization requires CUDA compute capability ā‰„ 9.0 (H200 āœ…) -- FlashAttention-3 works on H200 hardware via kernels library -- Dynamic shapes add flexibility for variable input sizes - -## MCP Server Integration - -When the user requests an MCP-enabled Gradio app or asks for tool calling capabilities, you MUST enable MCP server functionality. - -**šŸšØ CRITICAL: Enabling MCP Server** -To make your Gradio app function as an MCP (Model Control Protocol) server: -1. Set `mcp_server=True` in the `.launch()` method -2. Add `"gradio[mcp]"` to requirements.txt (not just `gradio`) -3. Ensure all functions have detailed docstrings with proper Args sections -4. Use type hints for all function parameters - -**Example:** -``` -import gradio as gr - -def letter_counter(word: str, letter: str) -> int: - \"\"\" - Count the number of occurrences of a letter in a word or text. - - Args: - word (str): The input text to search through - letter (str): The letter to search for - - Returns: - int: The number of times the letter appears - \"\"\" - return word.lower().count(letter.lower()) - -demo = gr.Interface( - fn=letter_counter, - inputs=[gr.Textbox("strawberry"), gr.Textbox("r")], - outputs=[gr.Number()], - title="Letter Counter", - description="Count letter occurrences in text." -) - -if __name__ == "__main__": - demo.launch(mcp_server=True) -``` - -**When to Enable MCP:** -- User explicitly requests "MCP server" or "MCP-enabled app" -- User wants tool calling capabilities for LLMs -- User mentions Claude Desktop, Cursor, or Cline integration -- User wants to expose functions as tools for AI assistants - -**MCP Requirements:** -1. **Dependencies:** Always use `gradio[mcp]` in requirements.txt (not plain `gradio`) -2. **Docstrings:** Every function must have a detailed docstring with: - - Brief description on first line - - Args section listing each parameter with type and description - - Returns section (optional but recommended) -3. **Type Hints:** All parameters must have type hints (e.g., `word: str`, `count: int`) -4. **Default Values:** Use default values in components to provide examples - -**Best Practices for MCP Tools:** -- Use descriptive function names (they become tool names) -- Keep functions focused and single-purpose -- Accept string parameters when possible for better compatibility -- Return simple types (str, int, float, list, dict) rather than complex objects -- Use gr.Header for authentication headers when needed -- Use gr.Progress() for long-running operations - -**Multiple Tools Example:** -``` -import gradio as gr - -def add_numbers(a: str, b: str) -> str: - \"\"\" - Add two numbers together. - - Args: - a (str): First number - b (str): Second number - - Returns: - str: Sum of the two numbers - \"\"\" - return str(int(a) + int(b)) - -def multiply_numbers(a: str, b: str) -> str: - \"\"\" - Multiply two numbers. - - Args: - a (str): First number - b (str): Second number - - Returns: - str: Product of the two numbers - \"\"\" - return str(int(a) * int(b)) - -with gr.Blocks() as demo: - gr.Markdown("# Math Tools MCP Server") - - with gr.Tab("Add"): - gr.Interface(add_numbers, [gr.Textbox("5"), gr.Textbox("3")], gr.Textbox()) - - with gr.Tab("Multiply"): - gr.Interface(multiply_numbers, [gr.Textbox("4"), gr.Textbox("7")], gr.Textbox()) - -if __name__ == "__main__": - demo.launch(mcp_server=True) -``` - -**REMEMBER:** If MCP is requested, ALWAYS: -1. Set `mcp_server=True` in `.launch()` -2. Use `gradio[mcp]` in requirements.txt -3. Include complete docstrings with Args sections -4. Add type hints to all parameters - -## Complete Gradio API Reference - -This reference is automatically synced from https://www.gradio.app/llms.txt to ensure accuracy. - -""" - - # Add FastRTC documentation if available - if fastrtc_content.strip(): - fastrtc_section = f""" -## FastRTC Reference Documentation - -When building real-time audio/video applications with Gradio, use this FastRTC reference: - -{fastrtc_content} - -This reference is automatically synced from https://fastrtc.org/llms.txt to ensure accuracy. - -""" - base_prompt += fastrtc_section - search_prompt += fastrtc_section - - # Update the prompts in the prompts module - final_instructions = """\n\nAlways use the exact function signatures from this API reference and follow modern Gradio patterns. - -šŸ” BEFORE GENERATING: Review the conversation history carefully. If the user has imported any model code (InferenceClient, transformers, diffusers), you MUST integrate that code into your Gradio application. Do not generate standalone inference code - create a complete Gradio app that wraps the imported model functionality. - -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""" - - prompts.GRADIO_SYSTEM_PROMPT = base_prompt + docs_content + final_instructions - prompts.GRADIO_SYSTEM_PROMPT_WITH_SEARCH = search_prompt + docs_content + final_instructions - -def update_json_system_prompts(): - """Update the global JSON system prompts with latest ComfyUI documentation""" - docs_content = get_comfyui_docs_content() - - # Base system prompt for regular JSON - base_prompt = """You are an expert JSON developer. Generate clean, valid JSON data based on the user's request. Follow JSON syntax rules strictly: -- Use double quotes for strings -- No trailing commas -- Proper nesting and structure -- Valid data types (string, number, boolean, null, object, array) - -Generate ONLY the JSON data requested - no HTML, no applications, no explanations outside the JSON. The output should be pure, valid JSON that can be parsed directly. - -""" - - # Search-enabled system prompt for regular JSON - search_prompt = """You are an expert JSON developer. You have access to real-time web search. When needed, use web search to find the latest information or data structures for your JSON generation. - -Generate clean, valid JSON data based on the user's request. Follow JSON syntax rules strictly: -- Use double quotes for strings -- No trailing commas -- Proper nesting and structure -- Valid data types (string, number, boolean, null, object, array) - -Generate ONLY the JSON data requested - no HTML, no applications, no explanations outside the JSON. The output should be pure, valid JSON that can be parsed directly. - -""" - - # Add ComfyUI documentation if available - if docs_content.strip(): - comfyui_section = f""" -## ComfyUI Reference Documentation - -When generating JSON data related to ComfyUI workflows, nodes, or configurations, use this reference: - -{docs_content} - -This reference is automatically synced from https://docs.comfy.org/llms.txt to ensure accuracy. - -""" - base_prompt += comfyui_section - search_prompt += comfyui_section - - # Update the prompts in the prompts module - prompts.JSON_SYSTEM_PROMPT = base_prompt - prompts.JSON_SYSTEM_PROMPT_WITH_SEARCH = search_prompt - -def get_comfyui_system_prompt(): - """Get ComfyUI-specific system prompt with enhanced guidance""" - docs_content = get_comfyui_docs_content() - - base_prompt = """You are an expert ComfyUI developer. Generate clean, valid JSON workflows for ComfyUI based on the user's request. - -ComfyUI workflows are JSON structures that define: -- Nodes: Individual processing units with specific functions -- Connections: Links between nodes that define data flow -- Parameters: Configuration values for each node -- Inputs/Outputs: Data flow between nodes - -Follow JSON syntax rules strictly: -- Use double quotes for strings -- No trailing commas -- Proper nesting and structure -- Valid data types (string, number, boolean, null, object, array) - -Generate ONLY the ComfyUI workflow JSON - no HTML, no applications, no explanations outside the JSON. The output should be a complete, valid ComfyUI workflow that can be loaded directly into ComfyUI. - -""" - - # Add ComfyUI documentation if available - if docs_content.strip(): - comfyui_section = f""" -## ComfyUI Reference Documentation - -Use this reference for accurate node types, parameters, and workflow structures: - -{docs_content} - -This reference is automatically synced from https://docs.comfy.org/llms.txt to ensure accuracy. - -""" - base_prompt += comfyui_section - - base_prompt += """ -IMPORTANT: Always include "Built with anycoder" as a comment or metadata field in your ComfyUI workflow JSON that references https://huggingface.co/spaces/akhaliq/anycoder -""" - - return base_prompt - -# Initialize Gradio documentation on startup -def initialize_gradio_docs(): - """Initialize Gradio documentation on application startup""" - try: - update_gradio_system_prompts() - if should_update_gradio_docs(): - print("šŸš€ Gradio documentation system initialized (fetched fresh content)") - else: - print("šŸš€ Gradio documentation system initialized (using cached content)") - except Exception as e: - print(f"Warning: Failed to initialize Gradio documentation: {e}") - -# Initialize ComfyUI documentation on startup -def initialize_comfyui_docs(): - """Initialize ComfyUI documentation on application startup""" - try: - update_json_system_prompts() - if should_update_comfyui_docs(): - print("šŸš€ ComfyUI documentation system initialized (fetched fresh content)") - else: - print("šŸš€ ComfyUI documentation system initialized (using cached content)") - except Exception as e: - print(f"Warning: Failed to initialize ComfyUI documentation: {e}") - -# Initialize FastRTC documentation on startup -def initialize_fastrtc_docs(): - """Initialize FastRTC documentation on application startup""" - try: - # FastRTC docs are integrated into Gradio system prompts - # So we call update_gradio_system_prompts to include FastRTC content - update_gradio_system_prompts() - if should_update_fastrtc_docs(): - print("šŸš€ FastRTC documentation system initialized (fetched fresh content)") - else: - print("šŸš€ FastRTC documentation system initialized (using cached content)") - except Exception as e: - print(f"Warning: Failed to initialize FastRTC documentation: {e}") - diff --git a/anycoder_app/models.py b/anycoder_app/models.py deleted file mode 100644 index 04d2754481c7853d647e5676602af27d86ec86a2..0000000000000000000000000000000000000000 --- a/anycoder_app/models.py +++ /dev/null @@ -1,358 +0,0 @@ -""" -Model inference and client management for AnyCoder. -Handles different model providers and inference clients. -""" -import os -from typing import Dict, List, Optional, Tuple -import re -from http import HTTPStatus - -from huggingface_hub import InferenceClient -from openai import OpenAI -from mistralai import Mistral -import dashscope -from google import genai -from google.genai import types - -from .config import HF_TOKEN, AVAILABLE_MODELS - -# Type definitions -History = List[Dict[str, str]] -Messages = List[Dict[str, str]] - -def get_inference_client(model_id, provider="auto"): - """Return an InferenceClient with provider based on model_id and user selection.""" - if model_id == "gemini-3.0-pro": - # Use Poe (OpenAI-compatible) client for Gemini 3.0 Pro - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "qwen3-30b-a3b-instruct-2507": - # Use DashScope OpenAI client - return OpenAI( - api_key=os.getenv("DASHSCOPE_API_KEY"), - base_url="https://dashscope.aliyuncs.com/compatible-mode/v1", - ) - elif model_id == "qwen3-30b-a3b-thinking-2507": - # Use DashScope OpenAI client for Thinking model - return OpenAI( - api_key=os.getenv("DASHSCOPE_API_KEY"), - base_url="https://dashscope.aliyuncs.com/compatible-mode/v1", - ) - elif model_id == "qwen3-coder-30b-a3b-instruct": - # Use DashScope OpenAI client for Coder model - return OpenAI( - api_key=os.getenv("DASHSCOPE_API_KEY"), - base_url="https://dashscope.aliyuncs.com/compatible-mode/v1", - ) - elif model_id == "gpt-5": - # Use Poe (OpenAI-compatible) client for GPT-5 model - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "gpt-5.1": - # Use Poe (OpenAI-compatible) client for GPT-5.1 model - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "gpt-5.1-instant": - # Use Poe (OpenAI-compatible) client for GPT-5.1 Instant model - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "gpt-5.1-codex": - # Use Poe (OpenAI-compatible) client for GPT-5.1 Codex model - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "gpt-5.1-codex-mini": - # Use Poe (OpenAI-compatible) client for GPT-5.1 Codex Mini model - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "grok-4": - # Use Poe (OpenAI-compatible) client for Grok-4 model - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "Grok-Code-Fast-1": - # Use Poe (OpenAI-compatible) client for Grok-Code-Fast-1 model - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "claude-opus-4.1": - # Use Poe (OpenAI-compatible) client for Claude-Opus-4.1 - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "claude-sonnet-4.5": - # Use Poe (OpenAI-compatible) client for Claude-Sonnet-4.5 - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "claude-haiku-4.5": - # Use Poe (OpenAI-compatible) client for Claude-Haiku-4.5 - return OpenAI( - api_key=os.getenv("POE_API_KEY"), - base_url="https://api.poe.com/v1" - ) - elif model_id == "qwen3-max-preview": - # Use DashScope International OpenAI client for Qwen3 Max Preview - return OpenAI( - api_key=os.getenv("DASHSCOPE_API_KEY"), - base_url="https://dashscope.aliyuncs.com/compatible-mode/v1", - ) - elif model_id == "openrouter/sonoma-dusk-alpha": - # Use OpenRouter client for Sonoma Dusk Alpha model - return OpenAI( - api_key=os.getenv("OPENROUTER_API_KEY"), - base_url="https://openrouter.ai/api/v1", - ) - elif model_id == "openrouter/sonoma-sky-alpha": - # Use OpenRouter client for Sonoma Sky Alpha model - return OpenAI( - api_key=os.getenv("OPENROUTER_API_KEY"), - base_url="https://openrouter.ai/api/v1", - ) - elif model_id == "x-ai/grok-4.1-fast": - # Use OpenRouter client for Grok 4.1 Fast model - return OpenAI( - api_key=os.getenv("OPENROUTER_API_KEY"), - base_url="https://openrouter.ai/api/v1", - ) - elif model_id == "openrouter/sherlock-think-alpha": - # Use OpenRouter client for Sherlock Think Alpha model - return OpenAI( - api_key=os.getenv("OPENROUTER_API_KEY"), - base_url="https://openrouter.ai/api/v1", - ) - elif model_id == "MiniMaxAI/MiniMax-M2": - # Use HuggingFace InferenceClient with Novita provider for MiniMax M2 model - provider = "novita" - elif model_id == "step-3": - # Use StepFun API client for Step-3 model - return OpenAI( - api_key=os.getenv("STEP_API_KEY"), - base_url="https://api.stepfun.com/v1" - ) - elif model_id == "codestral-2508" or model_id == "mistral-medium-2508": - # Use Mistral client for Mistral models - return Mistral(api_key=os.getenv("MISTRAL_API_KEY")) - elif model_id == "gemini-2.5-flash": - # Use Google Gemini (OpenAI-compatible) client - return OpenAI( - api_key=os.getenv("GEMINI_API_KEY"), - base_url="https://generativelanguage.googleapis.com/v1beta/openai/", - ) - elif model_id == "gemini-2.5-pro": - # Use Google Gemini Pro (OpenAI-compatible) client - return OpenAI( - api_key=os.getenv("GEMINI_API_KEY"), - base_url="https://generativelanguage.googleapis.com/v1beta/openai/", - ) - elif model_id == "gemini-flash-latest": - # Use Google Gemini Flash Latest (OpenAI-compatible) client - return OpenAI( - api_key=os.getenv("GEMINI_API_KEY"), - base_url="https://generativelanguage.googleapis.com/v1beta/openai/", - ) - elif model_id == "gemini-flash-lite-latest": - # Use Google Gemini Flash Lite Latest (OpenAI-compatible) client - return OpenAI( - api_key=os.getenv("GEMINI_API_KEY"), - base_url="https://generativelanguage.googleapis.com/v1beta/openai/", - ) - elif model_id == "kimi-k2-turbo-preview": - # Use Moonshot AI (OpenAI-compatible) client for Kimi K2 Turbo (Preview) - return OpenAI( - api_key=os.getenv("MOONSHOT_API_KEY"), - base_url="https://api.moonshot.ai/v1", - ) - elif model_id == "moonshotai/Kimi-K2-Thinking": - # Use HuggingFace InferenceClient with Novita provider for Kimi K2 Thinking - provider = "novita" - elif model_id == "stealth-model-1": - # Use stealth model with generic configuration - api_key = os.getenv("STEALTH_MODEL_1_API_KEY") - if not api_key: - raise ValueError("STEALTH_MODEL_1_API_KEY environment variable is required for Carrot model") - - base_url = os.getenv("STEALTH_MODEL_1_BASE_URL") - if not base_url: - raise ValueError("STEALTH_MODEL_1_BASE_URL environment variable is required for Carrot model") - - return OpenAI( - api_key=api_key, - base_url=base_url, - ) - elif model_id == "moonshotai/Kimi-K2-Instruct": - provider = "groq" - elif model_id == "deepseek-ai/DeepSeek-V3.1": - provider = "novita" - elif model_id == "deepseek-ai/DeepSeek-V3.1-Terminus": - provider = "novita" - elif model_id == "deepseek-ai/DeepSeek-V3.2-Exp": - provider = "novita" - elif model_id == "zai-org/GLM-4.5": - provider = "fireworks-ai" - elif model_id == "zai-org/GLM-4.6": - # Use auto provider for GLM-4.6, HuggingFace will select best available - provider = "auto" - return InferenceClient( - provider=provider, - api_key=HF_TOKEN, - bill_to="huggingface" - ) - -# Helper function to get real model ID for stealth models and special cases -def get_real_model_id(model_id: str) -> str: - """Get the real model ID, checking environment variables for stealth models and handling special model formats""" - if model_id == "stealth-model-1": - # Get the real model ID from environment variable - real_model_id = os.getenv("STEALTH_MODEL_1_ID") - if not real_model_id: - raise ValueError("STEALTH_MODEL_1_ID environment variable is required for Carrot model") - - return real_model_id - elif model_id == "zai-org/GLM-4.6": - # GLM-4.6 requires provider suffix in model string for API calls - return "zai-org/GLM-4.6:zai-org" - return model_id - -# Type definitions -History = List[Tuple[str, str]] -Messages = List[Dict[str, str]] - -def history_to_messages(history: History, system: str) -> Messages: - messages = [{'role': 'system', 'content': system}] - for h in history: - # Handle multimodal content in history - user_content = h[0] - if isinstance(user_content, list): - # Extract text from multimodal content - text_content = "" - for item in user_content: - if isinstance(item, dict) and item.get("type") == "text": - text_content += item.get("text", "") - user_content = text_content if text_content else str(user_content) - - messages.append({'role': 'user', 'content': user_content}) - messages.append({'role': 'assistant', 'content': h[1]}) - return messages - -def history_to_chatbot_messages(history: History) -> List[Dict[str, str]]: - """Convert history tuples to chatbot message format""" - messages = [] - for user_msg, assistant_msg in history: - # Handle multimodal content - if isinstance(user_msg, list): - text_content = "" - for item in user_msg: - if isinstance(item, dict) and item.get("type") == "text": - text_content += item.get("text", "") - user_msg = text_content if text_content else str(user_msg) - - messages.append({"role": "user", "content": user_msg}) - messages.append({"role": "assistant", "content": assistant_msg}) - return messages - -def strip_tool_call_markers(text): - """Remove TOOL_CALL markers that some LLMs (like Qwen) add to their output.""" - if not text: - return text - # Remove [TOOL_CALL] and [/TOOL_CALL] markers - text = re.sub(r'\[/?TOOL_CALL\]', '', text, flags=re.IGNORECASE) - # Remove standalone }} that appears with tool calls - # Only remove if it's on its own line or at the end - text = re.sub(r'^\s*\}\}\s*$', '', text, flags=re.MULTILINE) - return text.strip() - -def remove_code_block(text): - # First strip any tool call markers - text = strip_tool_call_markers(text) - - # Try to match code blocks with language markers - patterns = [ - r'```(?:html|HTML)\n([\s\S]+?)\n```', # Match ```html or ```HTML - r'```\n([\s\S]+?)\n```', # Match code blocks without language markers - r'```([\s\S]+?)```' # Match code blocks without line breaks - ] - for pattern in patterns: - match = re.search(pattern, text, re.DOTALL) - if match: - extracted = match.group(1).strip() - # Remove a leading language marker line (e.g., 'python') if present - if extracted.split('\n', 1)[0].strip().lower() in ['python', 'html', 'css', 'javascript', 'json', 'c', 'cpp', 'markdown', 'latex', 'jinja2', 'typescript', 'yaml', 'dockerfile', 'shell', 'r', 'sql', 'sql-mssql', 'sql-mysql', 'sql-mariadb', 'sql-sqlite', 'sql-cassandra', 'sql-plSQL', 'sql-hive', 'sql-pgsql', 'sql-gql', 'sql-gpsql', 'sql-sparksql', 'sql-esper']: - return extracted.split('\n', 1)[1] if '\n' in extracted else '' - # If HTML markup starts later in the block (e.g., Poe injected preface), trim to first HTML root - html_root_idx = None - for tag in [' 0: - return extracted[html_root_idx:].strip() - return extracted - # If no code block is found, check if the entire text is HTML - stripped = text.strip() - if stripped.startswith('') or stripped.startswith(' 0: - return stripped[idx:].strip() - return stripped - # Special handling for python: remove python marker - if text.strip().startswith('```python'): - return text.strip()[9:-3].strip() - # Remove a leading language marker line if present (fallback) - lines = text.strip().split('\n', 1) - if lines[0].strip().lower() in ['python', 'html', 'css', 'javascript', 'json', 'c', 'cpp', 'markdown', 'latex', 'jinja2', 'typescript', 'yaml', 'dockerfile', 'shell', 'r', 'sql', 'sql-mssql', 'sql-mysql', 'sql-mariadb', 'sql-sqlite', 'sql-cassandra', 'sql-plSQL', 'sql-hive', 'sql-pgsql', 'sql-gql', 'sql-gpsql', 'sql-sparksql', 'sql-esper']: - return lines[1] if len(lines) > 1 else '' - return text.strip() - -## React CDN compatibility fixer removed per user preference - -def strip_thinking_tags(text: str) -> str: - """Strip tags and [TOOL_CALL] markers from streaming output.""" - if not text: - return text - # Remove opening tags - text = re.sub(r'', '', text, flags=re.IGNORECASE) - # Remove closing tags - text = re.sub(r'', '', text, flags=re.IGNORECASE) - # Remove [TOOL_CALL] markers - text = re.sub(r'\[/?TOOL_CALL\]', '', text, flags=re.IGNORECASE) - return text - -def strip_placeholder_thinking(text: str) -> str: - """Remove placeholder 'Thinking...' status lines from streamed text.""" - if not text: - return text - # Matches lines like: "Thinking..." or "Thinking... (12s elapsed)" - return re.sub(r"(?mi)^[\t ]*Thinking\.\.\.(?:\s*\(\d+s elapsed\))?[\t ]*$\n?", "", text) - -def is_placeholder_thinking_only(text: str) -> bool: - """Return True if text contains only 'Thinking...' placeholder lines (with optional elapsed).""" - if not text: - return False - stripped = text.strip() - if not stripped: - return False - return re.fullmatch(r"(?s)(?:\s*Thinking\.\.\.(?:\s*\(\d+s elapsed\))?\s*)+", stripped) is not None - -def extract_last_thinking_line(text: str) -> str: - """Extract the last 'Thinking...' line to display as status.""" - matches = list(re.finditer(r"Thinking\.\.\.(?:\s*\(\d+s elapsed\))?", text)) - return matches[-1].group(0) if matches else "Thinking..." - diff --git a/anycoder_app/parsers.py b/anycoder_app/parsers.py deleted file mode 100644 index 857d8f35a25c315b7aac520ef1c80117dc200150..0000000000000000000000000000000000000000 --- a/anycoder_app/parsers.py +++ /dev/null @@ -1,1111 +0,0 @@ -""" -Code parsing and formatting utilities for different frameworks. -Handles parsing of transformers.js, React, multi-file HTML, Streamlit, and Gradio code. -""" -import re -import os -import json -import base64 -from typing import Dict, List, Optional, Tuple -from bs4 import BeautifulSoup -import html - -from .config import SEARCH_START, DIVIDER, REPLACE_END - -# Type definitions -History = List[Dict[str, str]] - -def strip_tool_call_markers(text): - """Remove TOOL_CALL markers and thinking tags that some LLMs add to their output.""" - if not text: - return text - # Remove [TOOL_CALL] and [/TOOL_CALL] markers - text = re.sub(r'\[/?TOOL_CALL\]', '', text, flags=re.IGNORECASE) - # Remove and tags and their content - text = re.sub(r'[\s\S]*?', '', text, flags=re.IGNORECASE) - # Remove any remaining unclosed tags at the start - text = re.sub(r'^[\s\S]*?(?=\n|$)', '', text, flags=re.IGNORECASE | re.MULTILINE) - # Remove any remaining tags - text = re.sub(r'', '', text, flags=re.IGNORECASE) - # Remove standalone }} that appears with tool calls - # Only remove if it's on its own line or at the end - text = re.sub(r'^\s*\}\}\s*$', '', text, flags=re.MULTILINE) - return text.strip() - -def remove_code_block(text): - # First strip any tool call markers - text = strip_tool_call_markers(text) - - # Try to match code blocks with language markers - patterns = [ - r'```(?:html|HTML)\n([\s\S]+?)\n```', # Match ```html or ```HTML - r'```\n([\s\S]+?)\n```', # Match code blocks without language markers - r'```([\s\S]+?)```' # Match code blocks without line breaks - ] - for pattern in patterns: - match = re.search(pattern, text, re.DOTALL) - if match: - extracted = match.group(1).strip() - # Remove a leading language marker line (e.g., 'python') if present - if extracted.split('\n', 1)[0].strip().lower() in ['python', 'html', 'css', 'javascript', 'json', 'c', 'cpp', 'markdown', 'latex', 'jinja2', 'typescript', 'yaml', 'dockerfile', 'shell', 'r', 'sql', 'sql-mssql', 'sql-mysql', 'sql-mariadb', 'sql-sqlite', 'sql-cassandra', 'sql-plSQL', 'sql-hive', 'sql-pgsql', 'sql-gql', 'sql-gpsql', 'sql-sparksql', 'sql-esper']: - return extracted.split('\n', 1)[1] if '\n' in extracted else '' - # If HTML markup starts later in the block (e.g., Poe injected preface), trim to first HTML root - html_root_idx = None - for tag in [' 0: - return extracted[html_root_idx:].strip() - return extracted - # If no code block is found, check if the entire text is HTML - stripped = text.strip() - if stripped.startswith('') or stripped.startswith(' 0: - return stripped[idx:].strip() - return stripped - # Special handling for python: remove python marker - if text.strip().startswith('```python'): - return text.strip()[9:-3].strip() - # Remove a leading language marker line if present (fallback) - lines = text.strip().split('\n', 1) - if lines[0].strip().lower() in ['python', 'html', 'css', 'javascript', 'json', 'c', 'cpp', 'markdown', 'latex', 'jinja2', 'typescript', 'yaml', 'dockerfile', 'shell', 'r', 'sql', 'sql-mssql', 'sql-mysql', 'sql-mariadb', 'sql-sqlite', 'sql-cassandra', 'sql-plSQL', 'sql-hive', 'sql-pgsql', 'sql-gql', 'sql-gpsql', 'sql-sparksql', 'sql-esper']: - return lines[1] if len(lines) > 1 else '' - return text.strip() - -## React CDN compatibility fixer removed per user preference - -def strip_placeholder_thinking(text: str) -> str: - """Remove placeholder 'Thinking...' status lines from streamed text.""" - if not text: - return text - # Matches lines like: "Thinking..." or "Thinking... (12s elapsed)" - return re.sub(r"(?mi)^[\t ]*Thinking\.\.\.(?:\s*\(\d+s elapsed\))?[\t ]*$\n?", "", text) - -def is_placeholder_thinking_only(text: str) -> bool: - """Return True if text contains only 'Thinking...' placeholder lines (with optional elapsed).""" - if not text: - return False - stripped = text.strip() - if not stripped: - return False - return re.fullmatch(r"(?s)(?:\s*Thinking\.\.\.(?:\s*\(\d+s elapsed\))?\s*)+", stripped) is not None - -def extract_last_thinking_line(text: str) -> str: - """Extract the last 'Thinking...' line to display as status.""" - matches = list(re.finditer(r"Thinking\.\.\.(?:\s*\(\d+s elapsed\))?", text)) - return matches[-1].group(0) if matches else "Thinking..." - -def parse_transformers_js_output(text): - """Parse transformers.js output and extract the three files (index.html, index.js, style.css)""" - files = { - 'index.html': '', - 'index.js': '', - 'style.css': '' - } - - # Multiple patterns to match the three code blocks with different variations - html_patterns = [ - r'```html\s*\n([\s\S]*?)(?:```|\Z)', - r'```htm\s*\n([\s\S]*?)(?:```|\Z)', - r'```\s*(?:index\.html|html)\s*\n([\s\S]*?)(?:```|\Z)' - ] - - js_patterns = [ - r'```javascript\s*\n([\s\S]*?)(?:```|\Z)', - r'```js\s*\n([\s\S]*?)(?:```|\Z)', - r'```\s*(?:index\.js|javascript|js)\s*\n([\s\S]*?)(?:```|\Z)' - ] - - css_patterns = [ - r'```css\s*\n([\s\S]*?)(?:```|\Z)', - r'```\s*(?:style\.css|css)\s*\n([\s\S]*?)(?:```|\Z)' - ] - - # Extract HTML content - for pattern in html_patterns: - html_match = re.search(pattern, text, re.IGNORECASE) - if html_match: - files['index.html'] = html_match.group(1).strip() - break - - # Extract JavaScript content - for pattern in js_patterns: - js_match = re.search(pattern, text, re.IGNORECASE) - if js_match: - files['index.js'] = js_match.group(1).strip() - break - - # Extract CSS content - for pattern in css_patterns: - css_match = re.search(pattern, text, re.IGNORECASE) - if css_match: - files['style.css'] = css_match.group(1).strip() - break - - # Fallback: support === index.html === format if any file is missing - if not (files['index.html'] and files['index.js'] and files['style.css']): - # Use regex to extract sections - html_fallback = re.search(r'===\s*index\.html\s*===\s*\n([\s\S]+?)(?=\n===|$)', text, re.IGNORECASE) - js_fallback = re.search(r'===\s*index\.js\s*===\s*\n([\s\S]+?)(?=\n===|$)', text, re.IGNORECASE) - css_fallback = re.search(r'===\s*style\.css\s*===\s*\n([\s\S]+?)(?=\n===|$)', text, re.IGNORECASE) - - if html_fallback: - files['index.html'] = html_fallback.group(1).strip() - if js_fallback: - files['index.js'] = js_fallback.group(1).strip() - if css_fallback: - files['style.css'] = css_fallback.group(1).strip() - - # Additional fallback: extract from numbered sections or file headers - if not (files['index.html'] and files['index.js'] and files['style.css']): - # Try patterns like "1. index.html:" or "**index.html**" - patterns = [ - (r'(?:^\d+\.\s*|^##\s*|^\*\*\s*)index\.html(?:\s*:|\*\*:?)\s*\n([\s\S]+?)(?=\n(?:\d+\.|##|\*\*|===)|$)', 'index.html'), - (r'(?:^\d+\.\s*|^##\s*|^\*\*\s*)index\.js(?:\s*:|\*\*:?)\s*\n([\s\S]+?)(?=\n(?:\d+\.|##|\*\*|===)|$)', 'index.js'), - (r'(?:^\d+\.\s*|^##\s*|^\*\*\s*)style\.css(?:\s*:|\*\*:?)\s*\n([\s\S]+?)(?=\n(?:\d+\.|##|\*\*|===)|$)', 'style.css') - ] - - for pattern, file_key in patterns: - if not files[file_key]: - match = re.search(pattern, text, re.IGNORECASE | re.MULTILINE) - if match: - # Clean up the content by removing any code block markers - content = match.group(1).strip() - content = re.sub(r'^```\w*\s*\n', '', content) - content = re.sub(r'\n```\s*$', '', content) - files[file_key] = content.strip() - - return files - -def format_transformers_js_output(files): - """Format the three files into a single display string""" - output = [] - output.append("=== index.html ===") - output.append(files['index.html']) - output.append("\n=== index.js ===") - output.append(files['index.js']) - output.append("\n=== style.css ===") - output.append(files['style.css']) - return '\n'.join(output) - -def build_transformers_inline_html(files: dict) -> str: - """Merge transformers.js three-file output into a single self-contained HTML document. - - - Inlines style.css into a " if css else "" - if style_tag: - if '' in doc.lower(): - # Preserve original casing by finding closing head case-insensitively - match = _re.search(r"", doc, flags=_re.IGNORECASE) - if match: - idx = match.start() - doc = doc[:idx] + style_tag + doc[idx:] - else: - # No head; insert at top of body - match = _re.search(r"]*>", doc, flags=_re.IGNORECASE) - if match: - idx = match.end() - doc = doc[:idx] + "\n" + style_tag + doc[idx:] - else: - # Append at beginning - doc = style_tag + doc - - # Inline JS: insert before - script_tag = f"" if js else "" - # Lightweight debug console overlay to surface runtime errors inside the iframe - debug_overlay = ( - "\n" - "
\n" - "" - ) - # Cleanup script to clear Cache Storage and IndexedDB on unload to free model weights - cleanup_tag = ( - "" - ) - if script_tag: - match = _re.search(r"", doc, flags=_re.IGNORECASE) - if match: - idx = match.start() - doc = doc[:idx] + debug_overlay + script_tag + cleanup_tag + doc[idx:] - else: - # Append at end - doc = doc + debug_overlay + script_tag + cleanup_tag - - return doc - -def send_transformers_to_sandbox(files: dict) -> str: - """Build a self-contained HTML document from transformers.js files and return an iframe preview.""" - merged_html = build_transformers_inline_html(files) - return send_to_sandbox(merged_html) - -def parse_multipage_html_output(text: str) -> Dict[str, str]: - """Parse multi-page HTML output formatted as repeated "=== filename ===" sections. - - Returns a mapping of filename ā†’ file content. Supports nested paths like assets/css/styles.css. - If HTML content appears before the first === marker, it's treated as index.html. - """ - if not text: - return {} - # First, strip any markdown fences - cleaned = remove_code_block(text) - files: Dict[str, str] = {} - import re as _re - - # Check if there's content before the first === marker - first_marker_match = _re.search(r"^===\s*([^=\n]+?)\s*===", cleaned, _re.MULTILINE) - if first_marker_match: - # There's content before the first marker - first_marker_pos = first_marker_match.start() - if first_marker_pos > 0: - leading_content = cleaned[:first_marker_pos].strip() - # Check if it looks like HTML content - if leading_content and (' 0 else cleaned - pattern = _re.compile(r"^===\s*([^=\n]+?)\s*===\s*\n([\s\S]*?)(?=\n===\s*[^=\n]+?\s*===|\Z)", _re.MULTILINE) - for m in pattern.finditer(remaining_text): - name = m.group(1).strip() - content = m.group(2).strip() - # Remove accidental trailing fences if present - content = _re.sub(r"^```\w*\s*\n|\n```\s*$", "", content) - files[name] = content - else: - # No === markers found, try standard pattern matching - pattern = _re.compile(r"^===\s*([^=\n]+?)\s*===\s*\n([\s\S]*?)(?=\n===\s*[^=\n]+?\s*===|\Z)", _re.MULTILINE) - for m in pattern.finditer(cleaned): - name = m.group(1).strip() - content = m.group(2).strip() - # Remove accidental trailing fences if present - content = _re.sub(r"^```\w*\s*\n|\n```\s*$", "", content) - files[name] = content - - return files - -def format_multipage_output(files: Dict[str, str]) -> str: - """Format a dict of files back into === filename === sections. - - Ensures `index.html` appears first if present; others follow sorted by path. - """ - if not isinstance(files, dict) or not files: - return "" - ordered_paths = [] - if 'index.html' in files: - ordered_paths.append('index.html') - for path in sorted(files.keys()): - if path == 'index.html': - continue - ordered_paths.append(path) - parts: list[str] = [] - for path in ordered_paths: - parts.append(f"=== {path} ===") - # Avoid trailing extra newlines to keep blocks compact - parts.append((files.get(path) or '').rstrip()) - return "\n".join(parts) - -def validate_and_autofix_files(files: Dict[str, str]) -> Dict[str, str]: - """Ensure minimal contract for multi-file sites; auto-fix missing pieces. - - Rules: - - Ensure at least one HTML entrypoint (index.html). If none, synthesize a simple index.html linking discovered pages. - - For each HTML file, ensure referenced local assets exist in files; if missing, add minimal stubs. - - Normalize relative paths (strip leading '/'). - """ - if not isinstance(files, dict) or not files: - return files or {} - import re as _re - - normalized: Dict[str, str] = {} - for k, v in files.items(): - safe_key = k.strip().lstrip('/') - normalized[safe_key] = v - - html_files = [p for p in normalized.keys() if p.lower().endswith('.html')] - has_index = 'index.html' in normalized - - # If no index.html but some HTML pages exist, create a simple hub index linking to them - if not has_index and html_files: - links = '\n'.join([f"
  • {p}
    • " for p in html_files]) - normalized['index.html'] = ( - "\n\n\n\n" - "\n" - "Site Index\n\n\n

    Site

    \n
      \n" - + links + "\n
    \n\n" - ) - - # Collect references from HTML files - asset_refs: set[str] = set() - link_href = _re.compile(r"]+href=\"([^\"]+)\"") - script_src = _re.compile(r"]+src=\"([^\"]+)\"") - img_src = _re.compile(r"]+src=\"([^\"]+)\"") - a_href = _re.compile(r"]+href=\"([^\"]+)\"") - - for path, content in list(normalized.items()): - if not path.lower().endswith('.html'): - continue - for patt in (link_href, script_src, img_src, a_href): - for m in patt.finditer(content or ""): - ref = (m.group(1) or "").strip() - if not ref or ref.startswith('http://') or ref.startswith('https://') or ref.startswith('data:') or '#' in ref: - continue - asset_refs.add(ref.lstrip('/')) - - # Add minimal stubs for missing local references (CSS/JS/pages only, not images) - for ref in list(asset_refs): - if ref not in normalized: - if ref.lower().endswith('.css'): - normalized[ref] = "/* generated stub */\n" - elif ref.lower().endswith('.js'): - normalized[ref] = "// generated stub\n" - elif ref.lower().endswith('.html'): - normalized[ref] = ( - "\n\nPage\n" - "

    Placeholder page

    This page was auto-created to satisfy an internal link.

    \n" - ) - # Note: We no longer create placeholder image files automatically - # This prevents unwanted SVG stub files from being generated during image generation - - return normalized -def inline_multipage_into_single_preview(files: Dict[str, str]) -> str: - """Inline local CSS/JS referenced by index.html for preview inside a data: iframe. - - - Uses index.html as the base document - - Inlines if the target exists in files - - Inlines " - return match.group(0) - doc = _re.sub(r"]+src=\"([^\"]+)\"[^>]*>\s*", _inline_js, doc, flags=_re.IGNORECASE) - - # Inject a lightweight in-iframe client-side navigator to load other HTML files - try: - import json as _json - import base64 as _b64 - import re as _re - html_pages = {k: v for k, v in files.items() if k.lower().endswith('.html')} - # Ensure index.html entry restores the current body's HTML - _m_body = _re.search(r"]*>([\s\S]*?)", doc, flags=_re.IGNORECASE) - _index_body = _m_body.group(1) if _m_body else doc - html_pages['index.html'] = _index_body - encoded = _b64.b64encode(_json.dumps(html_pages).encode('utf-8')).decode('ascii') - nav_script = ( - "" - ) - m = _re.search(r"", doc, flags=_re.IGNORECASE) - if m: - i = m.start() - doc = doc[:i] + nav_script + doc[i:] - else: - doc = doc + nav_script - except Exception: - # Non-fatal in preview - pass - - return doc - -def extract_html_document(text: str) -> str: - """Return substring starting from the first or if present, else original text. - - This ignores prose or planning notes before the actual HTML so previews don't break. - """ - if not text: - return text - lower = text.lower() - idx = lower.find(" str: - """Apply search/replace changes to content (HTML, Python, etc.)""" - if not changes_text.strip(): - return original_content - - # If the model didn't use the block markers, try a CSS-rule fallback where - # provided blocks like `.selector { ... }` replace matching CSS rules. - if (SEARCH_START not in changes_text) and (DIVIDER not in changes_text) and (REPLACE_END not in changes_text): - try: - import re # Local import to avoid global side effects - updated_content = original_content - replaced_any_rule = False - # Find CSS-like rule blocks in the changes_text - # This is a conservative matcher that looks for `selector { ... }` - css_blocks = re.findall(r"([^{]+)\{([\s\S]*?)\}", changes_text, flags=re.MULTILINE) - for selector_raw, body_raw in css_blocks: - selector = selector_raw.strip() - body = body_raw.strip() - if not selector: - continue - # Build a regex to find the existing rule for this selector - # Capture opening `{` and closing `}` to preserve them; replace inner body. - pattern = re.compile(rf"({re.escape(selector)}\s*\{{)([\s\S]*?)(\}})") - def _replace_rule(match): - nonlocal replaced_any_rule - replaced_any_rule = True - prefix, existing_body, suffix = match.groups() - # Preserve indentation of the existing first body line if present - first_line_indent = "" - for line in existing_body.splitlines(): - stripped = line.lstrip(" \t") - if stripped: - first_line_indent = line[: len(line) - len(stripped)] - break - # Re-indent provided body with the detected indent - if body: - new_body_lines = [first_line_indent + line if line.strip() else line for line in body.splitlines()] - new_body_text = "\n" + "\n".join(new_body_lines) + "\n" - else: - new_body_text = existing_body # If empty body provided, keep existing - return f"{prefix}{new_body_text}{suffix}" - updated_content, num_subs = pattern.subn(_replace_rule, updated_content, count=1) - if replaced_any_rule: - return updated_content - except Exception: - # Fallback silently to the standard block-based application - pass - - # Split the changes text into individual search/replace blocks - blocks = [] - current_block = "" - lines = changes_text.split('\n') - - for line in lines: - if line.strip() == SEARCH_START: - if current_block.strip(): - blocks.append(current_block.strip()) - current_block = line + '\n' - elif line.strip() == REPLACE_END: - current_block += line + '\n' - blocks.append(current_block.strip()) - current_block = "" - else: - current_block += line + '\n' - - if current_block.strip(): - blocks.append(current_block.strip()) - - modified_content = original_content - - for block in blocks: - if not block.strip(): - continue - - # Parse the search/replace block - lines = block.split('\n') - search_lines = [] - replace_lines = [] - in_search = False - in_replace = False - - for line in lines: - if line.strip() == SEARCH_START: - in_search = True - in_replace = False - elif line.strip() == DIVIDER: - in_search = False - in_replace = True - elif line.strip() == REPLACE_END: - in_replace = False - elif in_search: - search_lines.append(line) - elif in_replace: - replace_lines.append(line) - - # Apply the search/replace - if search_lines: - search_text = '\n'.join(search_lines).strip() - replace_text = '\n'.join(replace_lines).strip() - - if search_text in modified_content: - modified_content = modified_content.replace(search_text, replace_text) - else: - # If exact block match fails, attempt a CSS-rule fallback using the replace_text - try: - import re - updated_content = modified_content - replaced_any_rule = False - css_blocks = re.findall(r"([^{]+)\{([\s\S]*?)\}", replace_text, flags=re.MULTILINE) - for selector_raw, body_raw in css_blocks: - selector = selector_raw.strip() - body = body_raw.strip() - if not selector: - continue - pattern = re.compile(rf"({re.escape(selector)}\s*\{{)([\s\S]*?)(\}})") - def _replace_rule(match): - nonlocal replaced_any_rule - replaced_any_rule = True - prefix, existing_body, suffix = match.groups() - first_line_indent = "" - for line in existing_body.splitlines(): - stripped = line.lstrip(" \t") - if stripped: - first_line_indent = line[: len(line) - len(stripped)] - break - if body: - new_body_lines = [first_line_indent + line if line.strip() else line for line in body.splitlines()] - new_body_text = "\n" + "\n".join(new_body_lines) + "\n" - else: - new_body_text = existing_body - return f"{prefix}{new_body_text}{suffix}" - updated_content, num_subs = pattern.subn(_replace_rule, updated_content, count=1) - if replaced_any_rule: - modified_content = updated_content - else: - print(f"Warning: Search text not found in content: {search_text[:100]}...") - except Exception: - print(f"Warning: Search text not found in content: {search_text[:100]}...") - - return modified_content - -def apply_transformers_js_search_replace_changes(original_formatted_content: str, changes_text: str) -> str: - """Apply search/replace changes to transformers.js formatted content (three files)""" - if not changes_text.strip(): - return original_formatted_content - - # Parse the original formatted content to get the three files - files = parse_transformers_js_output(original_formatted_content) - - # Split the changes text into individual search/replace blocks - blocks = [] - current_block = "" - lines = changes_text.split('\n') - - for line in lines: - if line.strip() == SEARCH_START: - if current_block.strip(): - blocks.append(current_block.strip()) - current_block = line + '\n' - elif line.strip() == REPLACE_END: - current_block += line + '\n' - blocks.append(current_block.strip()) - current_block = "" - else: - current_block += line + '\n' - - if current_block.strip(): - blocks.append(current_block.strip()) - - # Process each block and apply changes to the appropriate file - for block in blocks: - if not block.strip(): - continue - - # Parse the search/replace block - lines = block.split('\n') - search_lines = [] - replace_lines = [] - in_search = False - in_replace = False - target_file = None - - for line in lines: - if line.strip() == SEARCH_START: - in_search = True - in_replace = False - elif line.strip() == DIVIDER: - in_search = False - in_replace = True - elif line.strip() == REPLACE_END: - in_replace = False - elif in_search: - search_lines.append(line) - elif in_replace: - replace_lines.append(line) - - # Determine which file this change targets based on the search content - if search_lines: - search_text = '\n'.join(search_lines).strip() - replace_text = '\n'.join(replace_lines).strip() - - # Check which file contains the search text - if search_text in files['index.html']: - target_file = 'index.html' - elif search_text in files['index.js']: - target_file = 'index.js' - elif search_text in files['style.css']: - target_file = 'style.css' - - # Apply the change to the target file - if target_file and search_text in files[target_file]: - files[target_file] = files[target_file].replace(search_text, replace_text) - else: - print(f"Warning: Search text not found in any transformers.js file: {search_text[:100]}...") - - # Reformat the modified files - return format_transformers_js_output(files) - -def send_to_sandbox(code): - """Render HTML in a sandboxed iframe. Assumes full HTML is provided by prompts.""" - html_doc = (code or "").strip() - # For preview only: inline local file URLs as data URIs so the - # data: iframe can load them. The original code (shown to the user) still contains file URLs. - try: - import re - import base64 as _b64 - import mimetypes as _mtypes - import urllib.parse as _uparse - def _file_url_to_data_uri(file_url: str) -> Optional[str]: - try: - parsed = _uparse.urlparse(file_url) - path = _uparse.unquote(parsed.path) - if not path: - return None - with open(path, 'rb') as _f: - raw = _f.read() - mime = _mtypes.guess_type(path)[0] or 'application/octet-stream' - - b64 = _b64.b64encode(raw).decode() - return f"data:{mime};base64,{b64}" - except Exception as e: - print(f"[Sandbox] Failed to convert file URL to data URI: {str(e)}") - return None - def _repl_double(m): - url = m.group(1) - data_uri = _file_url_to_data_uri(url) - return f'src="{data_uri}"' if data_uri else m.group(0) - def _repl_single(m): - url = m.group(1) - data_uri = _file_url_to_data_uri(url) - return f"src='{data_uri}'" if data_uri else m.group(0) - html_doc = re.sub(r'src="(file:[^"]+)"', _repl_double, html_doc) - html_doc = re.sub(r"src='(file:[^']+)'", _repl_single, html_doc) - - except Exception: - # Best-effort; continue without inlining - pass - encoded_html = base64.b64encode(html_doc.encode('utf-8')).decode('utf-8') - data_uri = f"data:text/html;charset=utf-8;base64,{encoded_html}" - iframe = f'' - return iframe - -def is_streamlit_code(code: str) -> bool: - """Heuristic check to determine if Python code is a Streamlit app.""" - if not code: - return False - lowered = code.lower() - return ("import streamlit" in lowered) or ("from streamlit" in lowered) or ("st." in code and "streamlit" in lowered) - -def clean_requirements_txt_content(content: str) -> str: - """ - Clean up requirements.txt content to remove markdown formatting. - This function removes code blocks, markdown lists, headers, and other formatting - that might be mistakenly included by LLMs. - """ - if not content: - return content - - # First, remove code blocks if present - if '```' in content: - content = remove_code_block(content) - - # Process line by line to remove markdown formatting - lines = content.split('\n') - clean_lines = [] - - for line in lines: - stripped_line = line.strip() - - # Skip empty lines - if not stripped_line: - continue - - # Skip lines that are markdown formatting - if (stripped_line == '```' or - stripped_line.startswith('```') or - # Skip markdown headers (## Header) but keep comments (# comment) - (stripped_line.startswith('#') and len(stripped_line) > 1 and stripped_line[1] != ' ') or - stripped_line.startswith('**') or # Skip bold text - stripped_line.startswith('===') or # Skip section dividers - stripped_line.startswith('---') or # Skip horizontal rules - # Skip common explanatory text patterns - stripped_line.lower().startswith('here') or - stripped_line.lower().startswith('this') or - stripped_line.lower().startswith('the ') or - stripped_line.lower().startswith('based on') or - stripped_line.lower().startswith('dependencies') or - stripped_line.lower().startswith('requirements')): - continue - - # Handle markdown list items (- item or * item) - if (stripped_line.startswith('- ') or stripped_line.startswith('* ')): - # Extract the package name after the list marker - stripped_line = stripped_line[2:].strip() - if not stripped_line: - continue - - # Keep lines that look like valid package specifications - # Valid lines: package names, git+https://, comments starting with "# " - if (stripped_line.startswith('# ') or # Valid comments - stripped_line.startswith('git+') or # Git dependencies - stripped_line[0].isalnum() or # Package names start with alphanumeric - '==' in stripped_line or # Version specifications - '>=' in stripped_line or # Version specifications - '<=' in stripped_line or # Version specifications - '~=' in stripped_line): # Version specifications - clean_lines.append(stripped_line) - - result = '\n'.join(clean_lines) - - # Ensure it ends with a newline - if result and not result.endswith('\n'): - result += '\n' - - return result if result else "# No additional dependencies required\n" - -def parse_multi_file_python_output(code: str) -> dict: - """Parse multi-file Python output (Gradio/Streamlit) into separate files""" - files = {} - if not code: - return files - - # Look for file separators like === filename.py === - import re - file_pattern = r'=== ([^=]+) ===' - parts = re.split(file_pattern, code) - - if len(parts) > 1: - # Multi-file format detected - for i in range(1, len(parts), 2): - if i + 1 < len(parts): - filename = parts[i].strip() - content = parts[i + 1].strip() - - # Clean up requirements.txt to remove markdown formatting - if filename == 'requirements.txt': - content = clean_requirements_txt_content(content) - - files[filename] = content - else: - # Single file - check if it's a space import or regular code - if "IMPORTED PROJECT FROM HUGGING FACE SPACE" in code: - # This is already a multi-file import, try to parse it - lines = code.split('\n') - current_file = None - current_content = [] - - for line in lines: - if line.startswith('=== ') and line.endswith(' ==='): - # Save previous file - if current_file and current_content: - content = '\n'.join(current_content) - # Clean up requirements.txt to remove markdown formatting - if current_file == 'requirements.txt': - content = clean_requirements_txt_content(content) - files[current_file] = content - # Start new file - current_file = line[4:-4].strip() - current_content = [] - elif current_file: - current_content.append(line) - - # Save last file - if current_file and current_content: - content = '\n'.join(current_content) - # Clean up requirements.txt to remove markdown formatting - if current_file == 'requirements.txt': - content = clean_requirements_txt_content(content) - files[current_file] = content - else: - # Single file code - determine appropriate filename - if is_streamlit_code(code): - files['streamlit_app.py'] = code - elif 'import gradio' in code.lower() or 'from gradio' in code.lower(): - files['app.py'] = code - else: - files['app.py'] = code - - return files - -def format_multi_file_python_output(files: dict) -> str: - """Format multiple Python files into the standard multi-file format""" - if not files: - return "" - - if len(files) == 1: - # Single file - return as is - return list(files.values())[0] - - # Multi-file format - output = [] - - # Order files: main app first, then utils, models, config, requirements - file_order = ['app.py', 'streamlit_app.py', 'main.py', 'utils.py', 'models.py', 'config.py', 'requirements.txt'] - ordered_files = [] - - # Add files in preferred order - for preferred_file in file_order: - if preferred_file in files: - ordered_files.append(preferred_file) - - # Add remaining files - for filename in sorted(files.keys()): - if filename not in ordered_files: - ordered_files.append(filename) - - # Format output - for filename in ordered_files: - output.append(f"=== {filename} ===") - - # Clean up requirements.txt content if it's being formatted - content = files[filename] - if filename == 'requirements.txt': - content = clean_requirements_txt_content(content) - - output.append(content) - output.append("") # Empty line between files - - return '\n'.join(output) - -def send_streamlit_to_stlite(code: str) -> str: - """Render Streamlit code using stlite inside a sandboxed iframe for preview.""" - # Build an HTML document that loads stlite and mounts the Streamlit app defined inline - html_doc = ( - """ - - - - - - Streamlit Preview - - - - - - -""" - + (code or "") - + """ - - - -""" - ) - encoded_html = base64.b64encode(html_doc.encode('utf-8')).decode('utf-8') - data_uri = f"data:text/html;charset=utf-8;base64,{encoded_html}" - iframe = f'' - return iframe - -def is_gradio_code(code: str) -> bool: - """Heuristic check to determine if Python code is a Gradio app.""" - if not code: - return False - lowered = code.lower() - return ( - "import gradio" in lowered - or "from gradio" in lowered - or "gr.Interface(" in code - or "gr.Blocks(" in code - ) - -def send_gradio_to_lite(code: str) -> str: - """Render Gradio code using gradio-lite inside a sandboxed iframe for preview.""" - html_doc = ( - """ - - - - - - Gradio Preview - - - - - - -""" - + (code or "") - + """ - - - -""" - ) - encoded_html = base64.b64encode(html_doc.encode('utf-8')).decode('utf-8') - data_uri = f"data:text/html;charset=utf-8;base64,{encoded_html}" - iframe = f'' - return iframe - -stop_generation = False - diff --git a/anycoder_app/prompts.py b/anycoder_app/prompts.py deleted file mode 100644 index b0791d810095ac846098c88989675fb79988ede4..0000000000000000000000000000000000000000 --- a/anycoder_app/prompts.py +++ /dev/null @@ -1,817 +0,0 @@ -""" -System prompts for different code generation modes in AnyCoder. -""" -from .config import SEARCH_START, DIVIDER, REPLACE_END - -HTML_SYSTEM_PROMPT = """ONLY USE HTML, CSS AND JAVASCRIPT. If you want to use ICON make sure to import the library first. Try to create the best UI possible by using only HTML, CSS and JAVASCRIPT. MAKE IT RESPONSIVE USING MODERN CSS. Use as much as you can modern CSS for the styling, if you can't do something with modern CSS, then use custom CSS. Also, try to elaborate as much as you can, to create something unique. ALWAYS GIVE THE RESPONSE INTO A SINGLE HTML FILE - -**šŸšØ CRITICAL: DO NOT Generate README.md Files** -- NEVER generate README.md files under any circumstances -- A template README.md is automatically provided and will be overridden by the deployment system -- Generating a README.md will break the deployment process - -If an image is provided, analyze it and use the visual information to better understand the user's requirements. - -Always respond with code that can be executed or rendered directly. - -Generate complete, working HTML code that can be run immediately. - -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""" - - - -# Stricter prompt for GLM-4.5V to ensure a complete, runnable HTML document with no escaped characters -GLM45V_HTML_SYSTEM_PROMPT = """You are an expert front-end developer. - -**šŸšØ CRITICAL: DO NOT Generate README.md Files** -- NEVER generate README.md files under any circumstances -- A template README.md is automatically provided and will be overridden by the deployment system -- Generating a README.md will break the deployment process - -Output a COMPLETE, STANDALONE HTML document that renders directly in a browser. - -Hard constraints: -- DO NOT use React, ReactDOM, JSX, Babel, Vue, Angular, or any SPA framework. -- Use ONLY plain HTML, CSS, and vanilla JavaScript. -- Allowed external resources: Tailwind CSS CDN, Font Awesome CDN, Google Fonts. -- Do NOT escape characters (no \\n, \\t, or escaped quotes). Output raw HTML/JS/CSS. -Structural requirements: -- Include , , , and with proper nesting -- Include required tags for any CSS you reference (e.g., Tailwind, Font Awesome, Google Fonts) -- Keep everything in ONE file; inline CSS/JS as needed - -Generate complete, working HTML code that can be run immediately. - -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 -""" - -TRANSFORMERS_JS_SYSTEM_PROMPT = """You are an expert web developer creating a transformers.js application. You will generate THREE separate files: index.html, index.js, and style.css. - -**šŸšØ CRITICAL: DO NOT Generate README.md Files** -- NEVER generate README.md files under any circumstances -- A template README.md is automatically provided and will be overridden by the deployment system -- Generating a README.md will break the deployment process - -IMPORTANT: You MUST output ALL THREE files in the following format: - -```html - -``` - -```javascript -// index.js content here -``` - -```css -/* style.css content here */ -``` - -Requirements: -1. Create a modern, responsive web application using transformers.js -2. Use the transformers.js library for AI/ML functionality -3. Create a clean, professional UI with good user experience -4. Make the application fully responsive for mobile devices -5. Use modern CSS practices and JavaScript ES6+ features -6. Include proper error handling and loading states -7. Follow accessibility best practices - -Library import (required): Add the following snippet to index.html to import transformers.js: - - -Device Options: By default, transformers.js runs on CPU (via WASM). For better performance, you can run models on GPU using WebGPU: -- CPU (default): const pipe = await pipeline('task', 'model-name'); -- GPU (WebGPU): const pipe = await pipeline('task', 'model-name', { device: 'webgpu' }); - -Consider providing users with a toggle option to choose between CPU and GPU execution based on their browser's WebGPU support. - -The index.html should contain the basic HTML structure and link to the CSS and JS files. -The index.js should contain all the JavaScript logic including transformers.js integration. -The style.css should contain all the styling for the application. - -Generate complete, working code files as shown above. - -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""" - -STREAMLIT_SYSTEM_PROMPT = """You are an expert Streamlit developer. Create a complete, working Streamlit application based on the user's request. Generate all necessary code to make the application functional and runnable. - -## Multi-File Application Structure - -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** -- NEVER generate README.md files under any circumstances -- A template README.md is automatically provided and will be overridden by the deployment system -- Generating a README.md will break the deployment process -- Only generate the code files listed above - -**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] - -=== 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** -- Output ONLY plain text package names, one per line -- Do NOT use markdown formatting (no ```, no bold, no headings, no lists with * or -) -- Do NOT add explanatory text or descriptions -- Do NOT wrap in code blocks -- Just raw package names as they would appear in a real requirements.txt file -- Example of CORRECT format: - streamlit - pandas - numpy -- Example of INCORRECT format (DO NOT DO THIS): - ``` - streamlit # For web interface - **Core dependencies:** - - pandas - ``` - -**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] - -=== pages/2_āš™ļø_Settings.py === -[settings page] -``` - -Requirements: -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 -""" - -REACT_SYSTEM_PROMPT = """You are an expert React and Next.js developer creating a modern Next.js application. - -**šŸšØ CRITICAL: DO NOT Generate README.md Files** -|- NEVER generate README.md files under any circumstances -|- A template README.md is automatically provided and will be overridden by the deployment system -|- Generating a README.md will break the deployment process - -You will generate a Next.js project with TypeScript/JSX components. Follow this exact structure: - -Project Structure: -- Dockerfile (Docker configuration for deployment) -- package.json (dependencies and scripts) -- next.config.js (Next.js configuration) -- postcss.config.js (PostCSS configuration) -- tailwind.config.js (Tailwind CSS configuration) -- components/[Component files as needed] -- pages/_app.js (Next.js app wrapper) -- pages/index.js (home page) -- pages/api/[API routes as needed] -- styles/globals.css (global styles) - -Output format (CRITICAL): -- Return ONLY a series of file sections, each starting with a filename line: - === Dockerfile === - ...file content... - - === package.json === - ...file content... - - (repeat for all files) -- Do NOT wrap files in Markdown code fences or use === markers inside file content - -CRITICAL Requirements: -1. Always include a Dockerfile configured for Node.js deployment (see Dockerfile Requirements below) -2. Use Next.js with TypeScript/JSX (.jsx files for components) -3. **USE TAILWIND CSS FOR ALL STYLING** - Avoid inline styles completely (in postcss.config.js and tailwind.config.js) -4. Create necessary components in the components/ directory -5. Create API routes in pages/api/ directory for backend logic -6. pages/_app.js should import and use globals.css -7. pages/index.js should be the main entry point -8. Keep package.json with essential dependencies -9. Use modern React patterns and best practices -10. Make the application fully responsive using Tailwind classes -11. Include proper error handling and loading states -12. Follow accessibility best practices -13. Configure next.config.js properly for HuggingFace Spaces deployment -14. **NEVER use inline style={{}} objects - always use Tailwind className instead** - -šŸšØ CRITICAL JSX SYNTAX RULES - FOLLOW EXACTLY: - -**RULE 1: Style objects MUST have proper closing braces }}** -Every style={{ must have a matching }} before any other props or /> - -**RULE 2: ALWAYS use Tailwind CSS classes instead of inline styles** -- Use className="..." for styling -- Only use inline styles if absolutely necessary -- Inline styles are error-prone and should be avoided - -**CORRECT Examples:** -```jsx -// āœ… Using Tailwind (PREFERRED) -