Update app.py

app.py

@@ -1,73 +1,91 @@
-import re
 import gradio as gr
+import zipfile
+import io
+import re
+import traceback
 
-# Simulating an in-memory virtual filesystem for directories and files
-virtual_filesystem = {}
+def process_files(phase, objecten_file_dict, template_files_data):
+    try:
+        # Read and process the 'objecten.txt' file
+        content = objecten_file_dict['data'].decode('utf-8')
+        t = content.strip().split('\n\n')
+        phases = ["iFAT", "(i)SAT"]
+        objs = {p: [] for p in phases}
+        if phase in phases:
+            objs = {phase: []}
+        else:
+            objs = {p: [] for p in phases}
 
-def create_virtual_directory(path):
-    if path not in virtual_filesystem:
-        virtual_filesystem[path] = {}
-        return f"Directory '{path}' created."
-    return f"Directory '{path}' already exists."
+        regObject = r"\d{4}[a-zA-Z]{2}"
+        for g in t:
+            ls = g.strip().split('\n')
+            k = ls[0]
+            if k in objs:
+                objs[k] = ls[1:]
+            else:
+                error_msg = f"Key [{k}] is not recognized."
+                return None, error_msg
 
-def create_new_templates(objs, templatesDir, regTemplate, root):
-    result = []
-    if templatesDir not in virtual_filesystem:
-        return f"Error: Template directory '{templatesDir}' not found."
+        # Extract object codes
+        for k in objs:
+            objs[k] = [re.search(regObject, o).group(0) for o in objs[k] if re.search(regObject, o)]
 
-    template_files = [f for f in virtual_filesystem[templatesDir] if re.search(regTemplate, f, re.IGNORECASE)]
-    if not template_files:
-        return f"No templates matching '{regTemplate}' found in {templatesDir}."
-    
-    for phase in objs:
-        phase_files = [f for f in template_files if re.search(phase.lower(), f, re.IGNORECASE)]
-        if not phase_files:
-            result.append(f"No templates for phase '{phase}' found.")
-            continue
+        # Create an in-memory ZIP file
+        zip_buffer = io.BytesIO()
+        with zipfile.ZipFile(zip_buffer, 'w') as zf:
+            for k in objs:
+                regPhase = ''
+                if k == '(i)SAT':
+                    regPhase = r'sat'
+                elif k == 'iFAT':
+                    regPhase = r'fat'
 
-        for obj in objs[phase]:
-            target_dir = f"{root}/{obj}"
-            create_virtual_directory(target_dir)
-            result.append(f"Copied templates for {obj}.")
-    
-    return "\n".join(result)
+                # Filter template files for this phase
+                phase_templates = []
+                for file_dict in template_files_data:
+                    filename = file_dict['name']
+                    if re.search(regPhase, filename, re.IGNORECASE):
+                        phase_templates.append(file_dict)
 
-# Simulated phase selection
-def get_objects_per_phase(phase="All"):
-    objects = {
-        "iFAT": ["001ABC", "002DEF"],
-        "(i)SAT": ["003GHI", "004JKL"],
-    }
-    return objects if phase == "All" else {phase: objects.get(phase, [])}
+                if not phase_templates:
+                    error_msg = f"Phase {k} has no templates."
+                    return None, error_msg
 
-def process_folders_and_templates(root_dir, phase, templates_dir):
-    try:
-        # Create directories based on phase objects
-        objects = get_objects_per_phase(phase)
-        for obj_list in objects.values():
-            for obj in obj_list:
-                create_virtual_directory(f"{root_dir}/{obj}")
-        
-        # Copy template files
-        return create_new_templates(objects, templates_dir, r'template', root_dir)
-    except Exception as e:
-        return f"Error occurred: {str(e)}"
-
-# Gradio Interface
-def gradio_interface(root_dir, phase, templates_dir):
-    return process_folders_and_templates(root_dir, phase, templates_dir)
+                for o in objs[k]:
+                    folder_path = f"{o}/"
+                    for file_dict in phase_templates:
+                        template_filename = file_dict['name']
+                        # Adjust filename if needed
+                        if re.search(r"hut_\d{4}[a-zA-Z]{2}", template_filename, re.IGNORECASE):
+                            adjusted_filename = template_filename[:4] + o + template_filename[10:]
+                        else:
+                            adjusted_filename = template_filename
 
-# Gradio App
-with gr.Blocks() as app:
-    gr.Markdown("# Folder and Template Processor")
-    
-    root_dir = gr.Textbox(label="Root Directory")
-    phase = gr.Dropdown(choices=["iFAT", "(i)SAT", "All"], label="Phase Selection")
-    templates_dir = gr.Textbox(label="Templates Directory")
+                        file_content = file_dict['data']
+                        file_path = folder_path + adjusted_filename
+                        zf.writestr(file_path, file_content)
+        zip_buffer.seek(0)
+        return zip_buffer, None
+    except Exception as e:
+        # Capture the full traceback
+        error_msg = traceback.format_exc()
+        return None, error_msg
 
-    output = gr.Textbox(label="Output")
+phase_options = ['iFAT', '(i)SAT', 'All']
 
-    submit_button = gr.Button("Create Folders and Copy Templates")
-    submit_button.click(gradio_interface, inputs=[root_dir, phase, templates_dir], outputs=output)
+interface = gr.Interface(
+    fn=process_files,
+    inputs=[
+        gr.Dropdown(choices=phase_options, label="Select Phase"),
+        gr.File(label="Upload 'objecten.txt' File", type='binary'),
+        gr.File(label="Upload Template Files", type='binary', multiple=True)
+    ],
+    outputs=[
+        gr.File(label="Download ZIP File"),
+        gr.Textbox(label="Error Log", lines=15)
+    ],
+    title="Template Folder Generator",
+    description="Upload 'objecten.txt' and template files to generate folders and files."
+)
 
-app.launch()
+interface.launch()