Update app.py

app.py

@@ -247,6 +247,152 @@ model = AutoModelForCausalLM.from_pretrained(
     trust_remote_code=True
 )
 
+# @spaces.GPU
+# def process_validator_request(model_name, model_structure, template_instructions):
+#     if not model_name or not model_structure:
+#         return "Error: Model Name and Model Structure are required."
+
+#     try:
+#         generated_prompt = generate_validator_prompt(model_name, model_structure, template_instructions)
+
+#         messages = [{"role": "user", "content": generated_prompt}]
+
+#         input_ids = tokenizer.apply_chat_template(
+#             messages,
+#             tokenize=True,
+#             return_tensors="pt",
+#             add_generation_prompt=True,
+#         ).to(model.device)
+
+#         with torch.no_grad():
+#              outputs = model.generate(
+#                 input_ids,
+#                 max_new_tokens=4096,
+#                 pad_token_id=tokenizer.eos_token_id,
+#                 eos_token_id=tokenizer.eos_token_id,
+#                 do_sample=True,
+#                 temperature=0.7,
+#                 top_p=0.95,
+#             )
+
+#         response = tokenizer.decode(outputs[0][input_ids.shape[-1]:], skip_special_tokens=True)
+
+#         response = response.strip()
+#         if response.startswith("```csharp"):
+#              response = response[len("```csharp"):].strip()
+#         if response.endswith("```"):
+#              response = response[:-len("```")].strip()
+
+#         return response
+
+#     except Exception as e:
+#         print(f"An error occurred: {e}")
+#         return f"An error occurred during generation: {e}"
+
+# # with gr.Blocks(title="C# Validator Generator") as demo:
+# #     gr.Markdown("""
+# #     # C# Validator Code Generator
+# #     Use this tool to generate a C# validator class based on your model structure and template instructions,
+# #     following a specific architectural pattern.
+# #     """)
+
+# #     with gr.Row():
+# #         with gr.Column():
+# #             model_name_input = gr.Textbox(label="Model Name (e.g., Role)", placeholder="Enter the model name (must be a valid C# identifier)...", interactive=True)
+# #             model_structure_input = gr.Textbox(label="Model Structure (C# Class Definition)", placeholder="Paste your C# class definition here (including public properties)...", lines=15, interactive=True)
+# #             template_instructions_input = gr.Textbox(label="Specific Template Instructions (Optional)", placeholder="Add any specific validation rules (e.g., 'Validate Id as GUID', 'Check if list is not null and not empty')...", lines=5, interactive=True)
+# #             generate_button = gr.Button("Generate Validator Code")
+
+# #         with gr.Column():
+# #             code_output = gr.Code(label="Generated C# Validator Code",lines=25, interactive=False)
+
+# #     generate_button.click(
+# #         fn=process_validator_request,
+# #         inputs=[model_name_input, model_structure_input, template_instructions_input],
+# #         outputs=[code_output]
+# #     )
+
+
+# # demo.launch()
+
+# import gradio as gr
+
+# @spaces.GPU
+# def process_multiple_validators(model_names_str, model_structure, template_instructions):
+#     model_names = [name.strip() for name in model_names_str.split(",") if name.strip()]
+#     files_output = {}
+
+#     for model_name in model_names:
+#         result = process_validator_request(model_name, model_structure, template_instructions)
+#         files_output[model_name] = result
+
+#     return files_output
+
+# @spaces.GPU
+
+# def render_outputs(model_names_str, model_structure, template_instructions):
+#     files = process_multiple_validators(model_names_str, model_structure, template_instructions)
+#     components = []
+
+#     for name, code in files.items():
+#         components.append(
+#             gr.Accordion(f"{name}.Validator.cs", open=False).render()(
+#                 gr.Code(value=code, lines=20, label=name)
+#             )
+#         )
+
+#     return components
+
+
+# with gr.Blocks(title="C# Validator Generator") as demo:
+#     gr.Markdown("## 🧠 C# Validator Code Generator")
+
+#     with gr.Tabs():
+#         # ✅ Tab 1: Single
+#         with gr.Tab("Single Validator"):
+#             with gr.Row():
+#                 with gr.Column():
+#                     model_name_input = gr.Textbox(label="Model Name")
+#                     model_structure_input = gr.Textbox(label="Model Structure", lines=15)
+#                     template_input = gr.Textbox(label="Template Instructions (Optional)", lines=4)
+#                     generate_btn = gr.Button("Generate Validator")
+
+#                 with gr.Column():
+#                     single_code_output = gr.Code(label="Generated Code", lines=25)
+
+#             generate_btn.click(
+#                 fn=process_validator_request,
+#                 inputs=[model_name_input, model_structure_input, template_input],
+#                 outputs=[single_code_output],
+#             )
+
+#         # ✅ Tab 2: Batch
+#         with gr.Tab("Batch Validators"):
+#             with gr.Row():
+#                 with gr.Column():
+#                     model_names_input = gr.Textbox(
+#                         label="Model Names (comma-separated)",
+#                         placeholder="e.g., User, Role, Customer"
+#                     )
+#                     shared_model_structure_input = gr.Textbox(label="Shared Model Structure", lines=10)
+#                     shared_template_input = gr.Textbox(label="Shared Template Instructions (Optional)", lines=3)
+#                     batch_generate_btn = gr.Button("Generate All")
+
+#                 with gr.Column():
+#                     dynamic_outputs = gr.Column()
+
+#             batch_generate_btn.click(
+#                 fn=render_outputs,
+#                 inputs=[model_names_input, shared_model_structure_input, shared_template_input],
+#                 outputs=[dynamic_outputs],
+#             )
+
+# demo.launch()
+
+import gradio as gr
+import torch
+
+# افتراضياً لديك هذه الدالة كما كتبتها
 @spaces.GPU
 def process_validator_request(model_name, model_structure, template_instructions):
     if not model_name or not model_structure:
@@ -265,7 +411,7 @@ def process_validator_request(model_name, model_structure, template_instructions
         ).to(model.device)
 
         with torch.no_grad():
-             outputs = model.generate(
+            outputs = model.generate(
                 input_ids,
                 max_new_tokens=4096,
                 pad_token_id=tokenizer.eos_token_id,
@@ -279,9 +425,9 @@ def process_validator_request(model_name, model_structure, template_instructions
 
         response = response.strip()
         if response.startswith("```csharp"):
-             response = response[len("```csharp"):].strip()
+            response = response[len("```csharp"):].strip()
         if response.endswith("```"):
-             response = response[:-len("```")].strip()
+            response = response[:-len("```")].strip()
 
         return response
 
@@ -289,34 +435,6 @@ def process_validator_request(model_name, model_structure, template_instructions
         print(f"An error occurred: {e}")
         return f"An error occurred during generation: {e}"
 
-# with gr.Blocks(title="C# Validator Generator") as demo:
-#     gr.Markdown("""
-#     # C# Validator Code Generator
-#     Use this tool to generate a C# validator class based on your model structure and template instructions,
-#     following a specific architectural pattern.
-#     """)
-
-#     with gr.Row():
-#         with gr.Column():
-#             model_name_input = gr.Textbox(label="Model Name (e.g., Role)", placeholder="Enter the model name (must be a valid C# identifier)...", interactive=True)
-#             model_structure_input = gr.Textbox(label="Model Structure (C# Class Definition)", placeholder="Paste your C# class definition here (including public properties)...", lines=15, interactive=True)
-#             template_instructions_input = gr.Textbox(label="Specific Template Instructions (Optional)", placeholder="Add any specific validation rules (e.g., 'Validate Id as GUID', 'Check if list is not null and not empty')...", lines=5, interactive=True)
-#             generate_button = gr.Button("Generate Validator Code")
-
-#         with gr.Column():
-#             code_output = gr.Code(label="Generated C# Validator Code",lines=25, interactive=False)
-
-#     generate_button.click(
-#         fn=process_validator_request,
-#         inputs=[model_name_input, model_structure_input, template_instructions_input],
-#         outputs=[code_output]
-#     )
-
-
-# demo.launch()
-
-import gradio as gr
-
 @spaces.GPU
 def process_multiple_validators(model_names_str, model_structure, template_instructions):
     model_names = [name.strip() for name in model_names_str.split(",") if name.strip()]
@@ -328,27 +446,23 @@ def process_multiple_validators(model_names_str, model_structure, template_instr
 
     return files_output
 
-@spaces.GPU
-
 def render_outputs(model_names_str, model_structure, template_instructions):
     files = process_multiple_validators(model_names_str, model_structure, template_instructions)
     components = []
 
     for name, code in files.items():
-        components.append(
-            gr.Accordion(f"{name}.Validator.cs", open=False).render()(
-                gr.Code(value=code, lines=20, label=name)
-            )
-        )
+        # إنشاء أكورديون لكل نتيجة
+        accordion = gr.Accordion(f"{name}.Validator.cs", open=False)
+        code_component = gr.Code(value=code, lines=20, label=name)
+        components.append(accordion(code_component))
 
     return components
 
-
-with gr.Blocks(title="C# Validator Generator") as demo:
-    gr.Markdown("## 🧠 C# Validator Code Generator")
+with gr.Blocks(title="C# Validator Generator with 8 Tabs") as demo:
+    gr.Markdown("# C# Validator & Entity Generator")
 
     with gr.Tabs():
-        # ✅ Tab 1: Single
+        # Tab 1: Single Validator
         with gr.Tab("Single Validator"):
             with gr.Row():
                 with gr.Column():
@@ -358,7 +472,7 @@ with gr.Blocks(title="C# Validator Generator") as demo:
                     generate_btn = gr.Button("Generate Validator")
 
                 with gr.Column():
-                    single_code_output = gr.Code(label="Generated Code", lines=25)
+                    single_code_output = gr.Code(label="Generated Validator Code", lines=25)
 
             generate_btn.click(
                 fn=process_validator_request,
@@ -366,7 +480,7 @@ with gr.Blocks(title="C# Validator Generator") as demo:
                 outputs=[single_code_output],
             )
 
-        # ✅ Tab 2: Batch
+        # Tab 2: Batch Validators
         with gr.Tab("Batch Validators"):
             with gr.Row():
                 with gr.Column():
@@ -387,7 +501,11 @@ with gr.Blocks(title="C# Validator Generator") as demo:
                 outputs=[dynamic_outputs],
             )
 
-demo.launch()
+        # Tab 3 to Tab 8 placeholders for future features
+        for i in range(3, 9):
+            with gr.Tab(f"Tab {i} - Placeholder"):
+                gr.Markdown(f"Content for Tab {i} goes here...")
 
+demo.launch()