Upload 9 files

Huggface/.env

@@ -0,0 +1 @@
+GROQ_API_KEY=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

Huggface/HuggfaceAgent.ipynb

@@ -0,0 +1,342 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 🐝 Hugging Face Space Creator Agent\n",
+    "\n",
+    "Run this notebook to launch the Agent Creator. This tool allows you to convert code to Gradio apps and deploy them to Hugging Face Spaces."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 1. Install Dependencies\n",
+    "!pip install -q gradio langchain-groq huggingface_hub python-dotenv nbconvert beautifulsoup4"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 2. Configuration\n",
+    "import os\n",
+    "from google.colab import userdata\n",
+    "\n",
+    "# Try to get from Colab Secrets, otherwise verify env\n",
+    "try:\n",
+    "    os.environ[\"GROQ_API_KEY\"] = userdata.get('GROQ_API_KEY')\n",
+    "except (ImportError, AttributeError, Exception):\n",
+    "    pass\n",
+    "\n",
+    "if not os.environ.get(\"GROQ_API_KEY\"):\n",
+    "    print(\"⚠️ GROQ_API_KEY not found in secrets. Please set it manually below or rely on the UI input if we implemented that (code currently expects env var).\")\n",
+    "    key = input(\"Enter your GROQ_API_KEY: \")\n",
+    "    os.environ[\"GROQ_API_KEY\"] = key"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 3. Define Backend Logic\n",
+    "\n",
+    "import os\n",
+    "from langchain_groq import ChatGroq\n",
+    "from langchain_core.prompts import ChatPromptTemplate\n",
+    "from langchain_core.output_parsers import JsonOutputParser\n",
+    "from typing import Dict, Any, Optional\n",
+    "import json\n",
+    "from huggingface_hub import HfApi, create_repo\n",
+    "import zipfile\n",
+    "import io\n",
+    "\n",
+    "# --- Converter Logic ---\n",
+    "def convert_code(input_code: str, model_name: str = \"llama-3.3-70b-versatile\") -> Dict[str, str]:\n",
+    "    \"\"\"\n",
+    "    Converts input Python/IPYNB code into a Gradio app structure.\n",
+    "    Returns a dictionary containing app.py, requirements.txt, and README.md content.\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # Check for API Key\n",
+    "    if not os.environ.get(\"GROQ_API_KEY\"):\n",
+    "         raise ValueError(\"GROQ_API_KEY environment variable is not set.\")\n",
+    "\n",
+    "    chat = ChatGroq(temperature=0, model_name=model_name)\n",
+    "\n",
+    "    system_prompt = \"\"\"You are an expert Python developer specializing in Gradio and Hugging Face Spaces. \n",
+    "    Your task is to convert the provided Python code (which might be a script or a notebook content) into a deployable Gradio web application.\n",
+    "    \n",
+    "    You must output a JSON object with exactly three keys:\n",
+    "    1. \"app_py\": The complete code for app.py. It must use Gradio to create a UI for the functionality in the source code. Ensure all imports are correct.\n",
+    "    2. \"requirements_txt\": A list of dependencies required to run the app. Include 'gradio'.\n",
+    "    3. \"readme_md\": A README.md file customized for a Hugging Face Space.\n",
+    "    \n",
+    "    Rules for app.py:\n",
+    "    - Encapsulate logic in functions.\n",
+    "    - Create a professional Gradio interface `demo = gr.Interface(...)` or `with gr.Blocks() as demo: ...`.\n",
+    "    - Ensure `demo.launch()` is called at the end if it's main, but standard HF spaces just look for `demo` object or run the script.\n",
+    "    - Handle potential errors gracefully.\n",
+    "    \n",
+    "    Do not include markdown triple backticks in the JSON values. The values should be raw string content.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    human_template = \"Convert this code into a Gradio app:\\n\\n{code}\"\n",
+    "    \n",
+    "    prompt = ChatPromptTemplate.from_messages([\n",
+    "        (\"system\", system_prompt),\n",
+    "        (\"human\", human_template)\n",
+    "    ])\n",
+    "\n",
+    "    chain = prompt | chat | JsonOutputParser()\n",
+    "\n",
+    "    try:\n",
+    "        result = chain.invoke({\"code\": input_code})\n",
+    "        return result\n",
+    "    except Exception as e:\n",
+    "        # Fallback or error handling\n",
+    "        raise RuntimeError(f\"Failed to generate code: {str(e)}\")\n",
+    "\n",
+    "def parse_notebook(notebook_content: dict) -> str:\n",
+    "    \"\"\"Extracts code cells from a notebook dictionary.\"\"\"\n",
+    "    code = []\n",
+    "    for cell in notebook_content.get('cells', []):\n",
+    "        if cell.get('cell_type') == 'code':\n",
+    "            code.append(\"\".join(cell.get('source', [])))\n",
+    "    return \"\\n\\n\".join(code)\n",
+    "\n",
+    "# --- Deployer Logic ---\n",
+    "def deploy_to_space(\n",
+    "    token: str, \n",
+    "    space_name: str, \n",
+    "    files: Dict[str, str], \n",
+    "    username: Optional[str] = None\n",
+    ") -> str:\n",
+    "    \"\"\"\n",
+    "    Deploys the given files to a Hugging Face Space.\n",
+    "    Returns the URL of the deployed space.\n",
+    "    \"\"\"\n",
+    "    if not token:\n",
+    "        raise ValueError(\"Hugging Face Token is required.\")\n",
+    "\n",
+    "    api = HfApi(token=token)\n",
+    "    \n",
+    "    # Authenticate and get user\n",
+    "    try:\n",
+    "        user_info = api.whoami()\n",
+    "        if not username:\n",
+    "            username = user_info['name']\n",
+    "    except Exception as e:\n",
+    "        raise ValueError(f\"Invalid Token: {str(e)}\")\n",
+    "\n",
+    "    repo_id = f\"{username}/{space_name}\"\n",
+    "\n",
+    "    # Create Repo if not exists\n",
+    "    try:\n",
+    "        api.create_repo(\n",
+    "            repo_id=repo_id,\n",
+    "            repo_type=\"space\",\n",
+    "            space_sdk=\"gradio\",\n",
+    "            exist_ok=True,\n",
+    "            private=False # Default to public, can be changed\n",
+    "        )\n",
+    "    except Exception as e:\n",
+    "        print(f\"Repo creation/check status: {e}\")\n",
+    "\n",
+    "    try:\n",
+    "        for filename, content in files.items():\n",
+    "            content_bytes = content.encode('utf-8')\n",
+    "            api.upload_file(\n",
+    "                path_or_fileobj=content_bytes,\n",
+    "                path_in_repo=filename,\n",
+    "                repo_id=repo_id,\n",
+    "                repo_type=\"space\",\n",
+    "                commit_message=f\"Update {filename} via Agent\"\n",
+    "            )\n",
+    "            \n",
+    "        return f\"https://huggingface.co/spaces/{repo_id}\"\n",
+    "        \n",
+    "    except Exception as e:\n",
+    "        raise RuntimeError(f\"Deployment Failed: {str(e)}\")\n",
+    "\n",
+    "# --- Utils ---\n",
+    "def create_zip_archive(files: dict) -> bytes:\n",
+    "    \"\"\"Creates a zip archive in memory from a dictionary of filename: content.\"\"\"\n",
+    "    zip_buffer = io.BytesIO()\n",
+    "    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:\n",
+    "        for filename, content in files.items():\n",
+    "            zip_file.writestr(filename, content)\n",
+    "    zip_buffer.seek(0)\n",
+    "    return zip_buffer.getvalue()\n",
+    "\n",
+    "def extract_code_from_ipynb(ipynb_content: str) -> str:\n",
+    "    \"\"\"Extracts code cells from ipynb json string.\"\"\"\n",
+    "    try:\n",
+    "        data = json.loads(ipynb_content)\n",
+    "        code_cells = []\n",
+    "        for cell in data.get('cells', []):\n",
+    "            if cell.get('cell_type') == 'code':\n",
+    "                source = cell.get('source', [])\n",
+    "                if isinstance(source, list):\n",
+    "                    code_cells.append(''.join(source))\n",
+    "                elif isinstance(source, str):\n",
+    "                    code_cells.append(source)\n",
+    "        return '\\n\\n'.join(code_cells)\n",
+    "    except json.JSONDecodeError:\n",
+    "        return ipynb_content"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# @title 4. Launch Application\n",
+    "import gradio as gr\n",
+    "import tempfile\n",
+    "\n",
+    "# Custom CSS\n",
+    "custom_css = \"\"\"\n",
+    ":root {\n",
+    "    --primary-color: #FFD700; /* Gold/Yellow */\n",
+    "    --secondary-color: #1a1a1a; /* Dark Gray/Black */\n",
+    "    --text-color: #333333;\n",
+    "    --bg-color: #f4f4f4;\n",
+    "}\n",
+    "body { background-color: var(--bg-color); font-family: 'Roboto', sans-serif; }\n",
+    "gradio-app { background-color: var(--bg-color) !important; }\n",
+    ".gradio-container { max-width: 1200px !important; }\n",
+    "button.primary { \n",
+    "    background-color: var(--primary-color) !important; \n",
+    "    color: var(--secondary-color) !important; \n",
+    "    font-weight: bold !important; \n",
+    "    border: none !important; \n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "def process_and_deploy(input_text, input_file, hf_token, space_name, deploy_mode):\n",
+    "    try:\n",
+    "        # 1. Get Source Code\n",
+    "        code_content = \"\"\n",
+    "        if input_file is not None:\n",
+    "            if input_file.name.endswith('.ipynb'):\n",
+    "                with open(input_file.name, 'r', encoding='utf-8') as f:\n",
+    "                    content = f.read()\n",
+    "                code_content = extract_code_from_ipynb(content)\n",
+    "            else:\n",
+    "                with open(input_file.name, 'r', encoding='utf-8') as f:\n",
+    "                    code_content = f.read()\n",
+    "        elif input_text.strip():\n",
+    "            code_content = input_text\n",
+    "        else:\n",
+    "            return None, \"Please provide either a file or paste code.\"\n",
+    "\n",
+    "        if not code_content.strip():\n",
+    "            return None, \"No code found to convert.\"\n",
+    "\n",
+    "        # 2. Convert\n",
+    "        try:\n",
+    "             conversion_result = convert_code(code_content)\n",
+    "        except Exception as e:\n",
+    "            return None, f\"AI Conversion Failed: {str(e)}\"\n",
+    "\n",
+    "        files_dict = {\n",
+    "            \"app.py\": conversion_result[\"app_py\"],\n",
+    "            \"requirements.txt\": conversion_result[\"requirements_txt\"],\n",
+    "            \"README.md\": conversion_result[\"readme_md\"]\n",
+    "        }\n",
+    "\n",
+    "        # 3. Zip\n",
+    "        zip_bytes = create_zip_archive(files_dict)\n",
+    "        temp_dir = tempfile.mkdtemp()\n",
+    "        zip_path = os.path.join(temp_dir, \"huggingface_space_files.zip\")\n",
+    "        with open(zip_path, \"wb\") as f:\n",
+    "            f.write(zip_bytes)\n",
+    "            \n",
+    "        status_msg = \"Conversion Successful! Download the zip below.\"\n",
+    "        \n",
+    "        # 4. Deploy\n",
+    "        if deploy_mode == \"Convert & Deploy to HF Space\":\n",
+    "            if not hf_token or not space_name:\n",
+    "                status_msg += \"\\n\\nDeployment Skipped: Missing HF Token or Space Name.\"\n",
+    "            else:\n",
+    "                try:\n",
+    "                    deploy_url = deploy_to_space(hf_token, space_name, files_dict)\n",
+    "                    status_msg += f\"\\n\\nSuccessfully Deployed to: {deploy_url}\"\n",
+    "                except Exception as e:\n",
+    "                    status_msg += f\"\\n\\nDeployment Failed: {str(e)}\"\n",
+    "\n",
+    "        return zip_path, status_msg\n",
+    "\n",
+    "    except Exception as e:\n",
+    "        return None, f\"An unexpected error occurred: {str(e)}\"\n",
+    "\n",
+    "with gr.Blocks(css=custom_css, title=\"HF Agent Creator\") as demo:\n",
+    "    with gr.Row():\n",
+    "        gr.Markdown(\"# 🐝 Hugging Face Space Creator Agent\")\n",
+    "    \n",
+    "    gr.Markdown(\"Transform your local Python scripts or Jupyter Notebooks into ready-to-deploy Hugging Face Spaces instantly.\")\n",
+    "    \n",
+    "    with gr.Row():\n",
+    "        with gr.Column(scale=1):\n",
+    "            gr.Markdown(\"### 1. Source Code\")\n",
+    "            with gr.Tabs():\n",
+    "                with gr.TabItem(\"Upload File\"):\n",
+    "                    file_input = gr.File(label=\"Upload .py or .ipynb file\", file_types=[\".py\", \".ipynb\"])\n",
+    "                with gr.TabItem(\"Paste Code\"):\n",
+    "                    text_input = gr.Code(label=\"Paste your Python code\", language=\"python\")\n",
+    "        \n",
+    "        with gr.Column(scale=1):\n",
+    "             gr.Markdown(\"### 2. Deployment Details\")\n",
+    "             hf_token = gr.Textbox(label=\"Hugging Face Access Token (Write)\", type=\"password\", placeholder=\"hf_...\")\n",
+    "             space_name = gr.Textbox(label=\"New Space Name\", placeholder=\"my-awesome-agent\")\n",
+    "             action_radio = gr.Radio([\"Convert Only\", \"Convert & Deploy to HF Space\"], label=\"Action\", value=\"Convert Only\")\n",
+    "             submit_btn = gr.Button(\"Generate Agent\", variant=\"primary\", size=\"lg\")\n",
+    "\n",
+    "    with gr.Row():\n",
+    "        with gr.Group():\n",
+    "            gr.Markdown(\"### 3. Results\")\n",
+    "            status_output = gr.Markdown(label=\"Status Console\")\n",
+    "            zip_output = gr.File(label=\"Download Generated Files\")\n",
+    "\n",
+    "    submit_btn.click(\n",
+    "        fn=process_and_deploy,\n",
+    "        inputs=[text_input, file_input, hf_token, space_name, action_radio],\n",
+    "        outputs=[zip_output, status_output]\n",
+    "    )\n",
+    "\n",
+    "demo.launch(debug=True, share=True)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

Huggface/app.py

@@ -0,0 +1,144 @@
+import gradio as gr
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+import tempfile
+from backend.converter import convert_code
+from backend.deployer import deploy_to_space
+from backend.utils import create_zip_archive, extract_code_from_ipynb
+import json
+
+# Load CSS
+with open("assets/style.css", "r") as f:
+    custom_css = f.read()
+
+def process_and_deploy(
+    input_text, 
+    input_file, 
+    hf_token, 
+    space_name, 
+    deploy_mode
+):
+    try:
+        # 1. Get Source Code
+        code_content = ""
+        if input_file is not None:
+            # Determine file type
+            if input_file.name.endswith('.ipynb'):
+                with open(input_file.name, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                code_content = extract_code_from_ipynb(content)
+            else:
+                with open(input_file.name, 'r', encoding='utf-8') as f:
+                    code_content = f.read()
+        elif input_text.strip():
+            code_content = input_text
+        else:
+            return None, "Please provide either a file or paste code."
+
+        if not code_content.strip():
+            return None, "No code found to convert."
+
+        # 2. Convert Code using AI Agent
+        # Note: We expect GROQ_API_KEY to be set in the environment.
+        # If not, we could ask user, but requirements said "place to enter HF tokens", didn't specify Groq key user input.
+        # Assuming env var is present or handled globally.
+        try:
+             conversion_result = convert_code(code_content)
+        except Exception as e:
+            return None, f"AI Conversion Failed: {str(e)}"
+
+        files_dict = {
+            "app.py": conversion_result["app_py"],
+            "requirements.txt": conversion_result["requirements_txt"],
+            "README.md": conversion_result["readme_md"]
+        }
+
+        # 3. Create Zip
+        zip_bytes = create_zip_archive(files_dict)
+        
+        # Create a temp file for the zip output
+        # Gradio File component needs a real path
+        temp_dir = tempfile.mkdtemp()
+        zip_path = os.path.join(temp_dir, "huggingface_space_files.zip")
+        with open(zip_path, "wb") as f:
+            f.write(zip_bytes)
+            
+        status_msg = "Conversion Successful! Download the zip below."
+        
+        # 4. Deploy if requested
+        deploy_url = ""
+        if deploy_mode == "Convert & Deploy to HF Space":
+            if not hf_token or not space_name:
+                status_msg += "\n\nDeployment Skipped: Missing HF Token or Space Name."
+            else:
+                try:
+                    deploy_url = deploy_to_space(hf_token, space_name, files_dict)
+                    status_msg += f"\n\nSuccessfully Deployed to: {deploy_url}"
+                except Exception as e:
+                    status_msg += f"\n\nDeployment Failed: {str(e)}"
+
+        return zip_path, status_msg
+
+    except Exception as e:
+        return None, f"An unexpected error occurred: {str(e)}"
+
+
+with gr.Blocks(css=custom_css, title="HF Agent Creator") as demo:
+    
+    with gr.Row(elem_id="header-title"):
+        gr.Markdown("# 🐝 Hugging Face Space Creator Agent")
+    
+    gr.Markdown("Transform your local Python scripts or Jupyter Notebooks into ready-to-deploy Hugging Face Spaces instantly.")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            with gr.Group(elem_classes="panel-container"):
+                gr.Markdown("### 1. Source Code")
+                input_tab = gr.Tabs()
+                with input_tab:
+                    with gr.TabItem("Upload File"):
+                        file_input = gr.File(
+                            label="Upload .py or .ipynb file", 
+                            file_types=[".py", ".ipynb"]
+                        )
+                    with gr.TabItem("Paste Code"):
+                        text_input = gr.Code(
+                            label="Paste your Python code", 
+                            language="python"
+                        )
+        
+        with gr.Column(scale=1):
+             with gr.Group(elem_classes="panel-container"):
+                gr.Markdown("### 2. Deployment Details")
+                hf_token = gr.Textbox(
+                    label="Hugging Face Access Token (Write)", 
+                    type="password",
+                    placeholder="hf_..."
+                )
+                space_name = gr.Textbox(
+                    label="New Space Name", 
+                    placeholder="my-awesome-agent"
+                )
+                action_radio = gr.Radio(
+                    ["Convert Only", "Convert & Deploy to HF Space"], 
+                    label="Action", 
+                    value="Convert Only"
+                )
+                submit_btn = gr.Button("Generate Agent", variant="primary", size="lg")
+
+    with gr.Row():
+        with gr.Group(elem_classes="panel-container"):
+            gr.Markdown("### 3. Results")
+            status_output = gr.Markdown(label="Status Console")
+            zip_output = gr.File(label="Download Generated Files")
+
+    submit_btn.click(
+        fn=process_and_deploy,
+        inputs=[text_input, file_input, hf_token, space_name, action_radio],
+        outputs=[zip_output, status_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

Huggface/assets/style.css

@@ -0,0 +1,56 @@
+:root {
+    --primary-color: #FFD700; /* Gold/Yellow */
+    --secondary-color: #1a1a1a; /* Dark Gray/Black */
+    --text-color: #333333;
+    --bg-color: #f4f4f4;
+}
+
+body {
+    background-color: var(--bg-color);
+    font-family: 'Roboto', sans-serif;
+}
+
+gradio-app {
+    background-color: var(--bg-color) !important;
+}
+
+.gradio-container {
+    max-width: 1200px !important;
+}
+
+/* Customizing Buttons */
+button.primary {
+    background-color: var(--primary-color) !important;
+    color: var(--secondary-color) !important;
+    font-weight: bold !important;
+    border: none !important;
+    transition: transform 0.1s;
+}
+
+button.primary:hover {
+    transform: scale(1.02);
+    box-shadow: 0 4px 6px rgba(0,0,0,0.1);
+}
+
+/* Header Styling */
+#header-title {
+    text-align: center;
+    color: var(--secondary-color);
+    margin-bottom: 20px;
+}
+
+#header-title h1 {
+    font-size: 2.5rem;
+    border-bottom: 4px solid var(--primary-color);
+    display: inline-block;
+    padding-bottom: 5px;
+}
+
+/* Panel Styling */
+.panel-container {
+    background: white;
+    border-radius: 12px;
+    padding: 20px;
+    box-shadow: 0 4px 12px rgba(0,0,0,0.08);
+    border-top: 5px solid var(--primary-color);
+}

Huggface/backend/converter.py

@@ -0,0 +1,59 @@
+import os
+from langchain_groq import ChatGroq
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.output_parsers import JsonOutputParser
+from typing import Dict, Any
+import json
+
+def convert_code(input_code: str, model_name: str = "llama-3.3-70b-versatile") -> Dict[str, str]:
+    """
+    Converts input Python/IPYNB code into a Gradio app structure.
+    Returns a dictionary containing app.py, requirements.txt, and README.md content.
+    """
+    
+    # Check for API Key
+    if not os.environ.get("GROQ_API_KEY"):
+         raise ValueError("GROQ_API_KEY environment variable is not set.")
+
+    chat = ChatGroq(temperature=0, model_name=model_name)
+
+    system_prompt = """You are an expert Python developer specializing in Gradio and Hugging Face Spaces. 
+    Your task is to convert the provided Python code (which might be a script or a notebook content) into a deployable Gradio web application.
+    
+    You must output a JSON object with exactly three keys:
+    1. "app_py": The complete code for app.py. It must use Gradio to create a UI for the functionality in the source code. Ensure all imports are correct.
+    2. "requirements_txt": A list of dependencies required to run the app. Include 'gradio'.
+    3. "readme_md": A README.md file customized for a Hugging Face Space.
+    
+    Rules for app.py:
+    - Encapsulate logic in functions.
+    - Create a professional Gradio interface `demo = gr.Interface(...)` or `with gr.Blocks() as demo: ...`.
+    - Ensure `demo.launch()` is called at the end if it's main, but standard HF spaces just look for `demo` object or run the script.
+    - Handle potential errors gracefully.
+    
+    Do not include markdown triple backticks in the JSON values. The values should be raw string content.
+    """
+
+    human_template = "Convert this code into a Gradio app:\n\n{code}"
+    
+    prompt = ChatPromptTemplate.from_messages([
+        ("system", system_prompt),
+        ("human", human_template)
+    ])
+
+    chain = prompt | chat | JsonOutputParser()
+
+    try:
+        result = chain.invoke({"code": input_code})
+        return result
+    except Exception as e:
+        # Fallback or error handling
+        raise RuntimeError(f"Failed to generate code: {str(e)}")
+
+def parse_notebook(notebook_content: dict) -> str:
+    """Extracts code cells from a notebook dictionary."""
+    code = []
+    for cell in notebook_content.get('cells', []):
+        if cell.get('cell_type') == 'code':
+            code.append("".join(cell.get('source', [])))
+    return "\n\n".join(code)

Huggface/backend/deployer.py

@@ -0,0 +1,69 @@
+from huggingface_hub import HfApi, create_repo
+from typing import Dict, Optional
+import tempfile
+import os
+
+def deploy_to_space(
+    token: str, 
+    space_name: str, 
+    files: Dict[str, str], 
+    username: Optional[str] = None
+) -> str:
+    """
+    Deploys the given files to a Hugging Face Space.
+    Returns the URL of the deployed space.
+    """
+    if not token:
+        raise ValueError("Hugging Face Token is required.")
+
+    api = HfApi(token=token)
+    
+    # Authenticate and get user
+    try:
+        user_info = api.whoami()
+        if not username:
+            username = user_info['name']
+    except Exception as e:
+        raise ValueError(f"Invalid Token: {str(e)}")
+
+    repo_id = f"{username}/{space_name}"
+
+    # Create Repo if not exists
+    try:
+        api.create_repo(
+            repo_id=repo_id,
+            repo_type="space",
+            space_sdk="gradio",
+            exist_ok=True,
+            private=False # Default to public, can be changed
+        )
+    except Exception as e:
+        print(f"Repo creation/check status: {e}")
+
+    # Prepare files for upload
+    operations = []
+    
+    # Create a temporary directory to write files to upload
+    # Note: api.upload_file or upload_folder can be used.
+    # We will use upload_file loop for simplicity with in-memory strings
+    
+    # Ideally we use commit_operations for atomicity but simple upload loop is fine for MVP
+    # Let's use upload_file content directly
+    
+    try:
+        for filename, content in files.items():
+            # Convert string content to bytes
+            content_bytes = content.encode('utf-8')
+            
+            api.upload_file(
+                path_or_fileobj=content_bytes,
+                path_in_repo=filename,
+                repo_id=repo_id,
+                repo_type="space",
+                commit_message=f"Update {filename} via Agent"
+            )
+            
+        return f"https://huggingface.co/spaces/{repo_id}"
+        
+    except Exception as e:
+        raise RuntimeError(f"Deployment Failed: {str(e)}")

Huggface/backend/utils.py

@@ -0,0 +1,43 @@
+import zipfile
+import io
+import json
+
+def create_zip_archive(files: dict) -> bytes:
+    """Creates a zip archive in memory from a dictionary of filename: content."""
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, 'w', zipfile.ZIP_DEFLATED) as zip_file:
+        for filename, content in files.items():
+            zip_file.writestr(filename, content)
+    zip_buffer.seek(0)
+    return zip_buffer.getvalue()
+
+def read_file_content(file_obj) -> str:
+    """Reads content from a file object (GradIO file wrapper) or path."""
+    if hasattr(file_obj, 'name'):
+        path = file_obj.name
+    else:
+        path = file_obj
+        
+    try:
+        with open(path, 'r', encoding='utf-8') as f:
+            return f.read()
+    except UnicodeDecodeError:
+        # Fallback for some notebook formats if needed
+        with open(path, 'r', encoding='latin-1') as f:
+            return f.read()
+
+def extract_code_from_ipynb(ipynb_content: str) -> str:
+    """Extracts code cells from ipynb json string."""
+    try:
+        data = json.loads(ipynb_content)
+        code_cells = []
+        for cell in data.get('cells', []):
+            if cell.get('cell_type') == 'code':
+                source = cell.get('source', [])
+                if isinstance(source, list):
+                    code_cells.append(''.join(source))
+                elif isinstance(source, str):
+                    code_cells.append(source)
+        return '\n\n'.join(code_cells)
+    except json.JSONDecodeError:
+        return ipynb_content # Validation failed or not json, treat as raw text?

Huggface/requirements.txt

@@ -0,0 +1,6 @@
+gradio
+langchain-groq
+huggingface_hub
+python-dotenv
+nbconvert
+beautifulsoup4