Spaces:

MINEOGO
/

pro-zephyr-coder

Sleeping

App Files Files Community

MINEOGO commited on Apr 28

Commit

e8a0246

verified ·

1 Parent(s): e3eee09

Update app.py

Browse files

Files changed (1) hide show

app.py +132 -31

app.py CHANGED Viewed

@@ -39,32 +39,66 @@ def generate_code(prompt: str, backend_choice: str, max_tokens: int, temperature
             token = message.choices[0].delta.content
             if isinstance(token, str):
                 full_response += token
         cleaned_response = full_response.strip()
         cleaned_response = re.sub(r"^\s*```[a-z]*\s*\n?", "", cleaned_response)
         cleaned_response = re.sub(r"\n?\s*```\s*$", "", cleaned_response)
-        cleaned_response = re.sub(r"<\s*\|?\s*(user|assistant)\s*\|?\s*>", "", cleaned_response, flags=re.IGNORECASE)
         common_phrases = [
             "Here is the code:", "Okay, here is the code:", "Here's the code:",
-            "Sure, here is the code you requested:", "Let me know if you need anything else."
         ]
         for phrase in common_phrases:
-            if cleaned_response.lower().startswith(phrase.lower()):
                 cleaned_response = cleaned_response[len(phrase):].lstrip()
         return cleaned_response
     except Exception as e:
         return f"## Error\n\nFailed to generate code.\n**Reason:** {e}"
 def split_files(full_code_text):
     file_blocks = []
-    splits = re.split(r'TAB\.NAME=\{(.+?)\}', full_code_text)
-    if not splits[0].strip():
-        splits = splits[1:]
-    for i in range(0, len(splits), 2):
-        if i+1 >= len(splits):
-            continue
-        filename = splits[i].strip()
-        content = splits[i+1].strip()
-        file_blocks.append((filename, content))
     return file_blocks
 with gr.Blocks(css=".gradio-container { max-width: 90% !important; }") as demo:
@@ -72,38 +106,39 @@ with gr.Blocks(css=".gradio-container { max-width: 90% !important; }") as demo:
     gr.Markdown(
         "Describe the website you want. The AI will generate website code.\n\n"
         "**Rules:**\n"
-        "- Backend hint (Static / Flask / Node.js).\n"
-        "- Always fully SFW and minimal errors.\n"
-        "- Only websites. No other codes.\n"
-        "- Multiple files use TAB.NAME={filename}."
     )
     with gr.Row():
         with gr.Column(scale=2):
             prompt_input = gr.Textbox(
                 label="Website Description",
-                placeholder="e.g., A simple landing page with a hero section and contact form.",
                 lines=6,
             )
             backend_radio = gr.Radio(
                 ["Static", "Flask", "Node.js"],
-                label="Backend Context",
                 value="Static",
             )
             generate_button = gr.Button("✨ Generate Website Code", variant="primary")
         with gr.Column(scale=3):
-            main_output = gr.Code(
-                label="Full Generated Code",
                 language="html",
-                lines=25,
                 interactive=False,
             )
-            extra_outputs = gr.Column()
     with gr.Accordion("Advanced Settings", open=False):
         max_tokens_slider = gr.Slider(
             minimum=512,
-            maximum=4096,
-            value=3072,
             step=256,
             label="Max New Tokens"
         )
@@ -122,20 +157,86 @@ with gr.Blocks(css=".gradio-container { max-width: 90% !important; }") as demo:
             label="Top-P"
         )
     def generate_and_display(prompt, backend, max_tokens, temperature, top_p):
         full_code = generate_code(prompt, backend, max_tokens, temperature, top_p)
         files = split_files(full_code)
-        file_outputs = []
-        for filename, content in files:
-            file_outputs.append(gr.Markdown.update(value=f"### {filename}"))
-            file_outputs.append(gr.Code.update(value=content, language="html" if filename.endswith(".html") else "python" if filename.endswith(".py") else "javascript" if filename.endswith(".js") else "text"))
-        return full_code, file_outputs
     generate_button.click(
         fn=generate_and_display,
         inputs=[prompt_input, backend_radio, max_tokens_slider, temperature_slider, top_p_slider],
-        outputs=[main_output, extra_outputs]
     )
 if __name__ == "__main__":
-    demo.queue(max_size=10).launch()

             token = message.choices[0].delta.content
             if isinstance(token, str):
                 full_response += token
         cleaned_response = full_response.strip()
         cleaned_response = re.sub(r"^\s*```[a-z]*\s*\n?", "", cleaned_response)
         cleaned_response = re.sub(r"\n?\s*```\s*$", "", cleaned_response)
+        cleaned_response = re.sub(r"<\s*\|?\s*(user|assistant|system|endoftext)\s*\|?\s*>", "", cleaned_response, flags=re.IGNORECASE)
+        cleaned_response = cleaned_response.replace("<|im_end|>", "").replace("<|im_start|>", "").strip()
         common_phrases = [
             "Here is the code:", "Okay, here is the code:", "Here's the code:",
+            "Sure, here is the code you requested:", "Let me know if you need anything else.",
+            "Here is the website code you requested:", "Here are the files for your website:",
+            "Okay, here are the files:"
         ]
+        lower_response = cleaned_response.lower()
         for phrase in common_phrases:
+            if lower_response.startswith(phrase.lower()):
                 cleaned_response = cleaned_response[len(phrase):].lstrip()
+                lower_response = cleaned_response.lower()
+        if not cleaned_response:
+             return "Error: Empty response from model after cleaning."
         return cleaned_response
     except Exception as e:
         return f"## Error\n\nFailed to generate code.\n**Reason:** {e}"
 def split_files(full_code_text):
     file_blocks = []
+    splits = re.split(r'(TAB\.NAME=\{.+?\})', full_code_text)
+    initial_content = splits[0].strip()
+    if len(splits) == 1:
+        if initial_content:
+            default_name = "index.html"
+            if "def " in initial_content or "import " in initial_content: default_name = "app.py"
+            elif "function " in initial_content or "const " in initial_content or "let " in initial_content: default_name = "script.js"
+            elif "<!DOCTYPE html>" in initial_content or "<html" in initial_content: default_name = "index.html"
+            elif "@app.route" in initial_content: default_name = "app.py"
+            elif "require(" in initial_content or "module.exports" in initial_content: default_name = "server.js"
+            elif "<?php" in initial_content: default_name = "index.php"
+            elif "package main" in initial_content: default_name = "main.go"
+            file_blocks.append((default_name, initial_content))
+    else:
+        for i in range(1, len(splits), 2):
+            marker = splits[i]
+            content = splits[i+1].strip() if (i+1) < len(splits) else ""
+            filename_match = re.search(r'TAB\.NAME=\{(.+?)\}', marker)
+            if filename_match:
+                filename = filename_match.group(1).strip()
+                if content:
+                    file_blocks.append((filename, content))
+            elif i == 1 and initial_content: # Handle content before the first explicit marker
+                 file_blocks.append(("file_0.txt", initial_content))
+                 if content: # Add the content after the first marker if it exists
+                     filename_match_fallback = re.search(r'TAB\.NAME=\{(.+?)\}', marker)
+                     if filename_match_fallback:
+                         filename = filename_match_fallback.group(1).strip()
+                         file_blocks.append((filename, content))
     return file_blocks
 with gr.Blocks(css=".gradio-container { max-width: 90% !important; }") as demo:
     gr.Markdown(
         "Describe the website you want. The AI will generate website code.\n\n"
         "**Rules:**\n"
+        "- Provide a backend hint (Static / Flask / Node.js).\n"
+        "- Generated code should be functional and SFW.\n"
+        "- Only generates website-related code.\n"
+        "- If multiple files are generated, they will be separated below using the format `TAB.NAME={filename}`."
     )
     with gr.Row():
         with gr.Column(scale=2):
             prompt_input = gr.Textbox(
                 label="Website Description",
+                placeholder="e.g., A simple Flask app with one route that displays 'Hello World'.",
                 lines=6,
             )
             backend_radio = gr.Radio(
                 ["Static", "Flask", "Node.js"],
+                label="Backend Context / Hint",
                 value="Static",
             )
             generate_button = gr.Button("✨ Generate Website Code", variant="primary")
         with gr.Column(scale=3):
+            main_output_label = gr.Markdown("### Full Generated Code / Main File")
+            main_output_code = gr.Code(
+                label="Generated Code", # Label is less prominent now
                 language="html",
+                lines=15,
                 interactive=False,
             )
+            extra_outputs_column = gr.Column(visible=False) # Initially hidden
     with gr.Accordion("Advanced Settings", open=False):
         max_tokens_slider = gr.Slider(
             minimum=512,
+            maximum=8192,
+            value=4096,
             step=256,
             label="Max New Tokens"
         )
             label="Top-P"
         )
+    def get_language(filename):
+        if filename.endswith(".html") or filename.endswith(".htm"): return "html"
+        if filename.endswith(".css"): return "css"
+        if filename.endswith(".js"): return "javascript"
+        if filename.endswith(".py"): return "python"
+        if filename.endswith(".json"): return "json"
+        if filename.endswith(".sql"): return "sql"
+        if filename.endswith(".php"): return "php"
+        if filename.endswith(".go"): return "go"
+        if filename.endswith(".java"): return "java"
+        if filename.endswith(".rb"): return "ruby"
+        if filename.endswith(".sh"): return "shell"
+        if filename.endswith(".yml") or filename.endswith(".yaml"): return "yaml"
+        if filename.endswith(".md"): return "markdown"
+        return "text"
     def generate_and_display(prompt, backend, max_tokens, temperature, top_p):
         full_code = generate_code(prompt, backend, max_tokens, temperature, top_p)
+        if full_code.startswith("## Error"):
+            return {
+                main_output_label: gr.Markdown.update(value="### Error Occurred"),
+                main_output_code: gr.Code.update(value=full_code, language="markdown"),
+                extra_outputs_column: gr.Column.update(visible=False, children=[])
+            }
+        if full_code.startswith("Error: Empty response"):
+             return {
+                main_output_label: gr.Markdown.update(value="### Error Occurred"),
+                main_output_code: gr.Code.update(value=full_code, language="text"),
+                extra_outputs_column: gr.Column.update(visible=False, children=[])
+             }
         files = split_files(full_code)
+        dynamic_components = []
+        main_file_content = full_code
+        main_file_lang = "text"
+        main_file_label = "### Full Generated Code"
+        if not files:
+             main_file_content = full_code # Show full code if split failed but we got output
+             main_file_lang = get_language("output.txt") # Basic guess
+             main_file_label = "### Full Generated Output (No Files Detected)"
+             return {
+                 main_output_label: gr.Markdown.update(value=main_file_label),
+                 main_output_code: gr.Code.update(value=main_file_content, language=main_file_lang),
+                 extra_outputs_column: gr.Column.update(visible=False, children=[])
+             }
+        if len(files) == 1:
+             main_file_content = files[0][1]
+             main_file_lang = get_language(files[0][0])
+             main_file_label = f"### File: {files[0][0]}"
+             return {
+                 main_output_label: gr.Markdown.update(value=main_file_label),
+                 main_output_code: gr.Code.update(value=main_file_content, language=main_file_lang),
+                 extra_outputs_column: gr.Column.update(visible=False, children=[])
+             }
+        else:
+            main_file_content = files[0][1]
+            main_file_lang = get_language(files[0][0])
+            main_file_label = f"### File: {files[0][0]}"
+            for i, (filename, content) in enumerate(files[1:], start=1): # Start from the second file for extras
+                lang = get_language(filename)
+                dynamic_components.append(gr.Markdown(f"### File: {filename}"))
+                dynamic_components.append(gr.Code(value=content, language=lang, label=filename, interactive=False))
+            return {
+                main_output_label: gr.Markdown.update(value=main_file_label),
+                main_output_code: gr.Code.update(value=main_file_content, language=main_file_lang),
+                extra_outputs_column: gr.Column.update(visible=True, children=dynamic_components)
+            }
     generate_button.click(
         fn=generate_and_display,
         inputs=[prompt_input, backend_radio, max_tokens_slider, temperature_slider, top_p_slider],
+        outputs=[main_output_label, main_output_code, extra_outputs_column]
     )
 if __name__ == "__main__":
+    demo.queue().launch()