Update app.py

app.py

@@ -1,73 +1,84 @@
-import os
-import shutil
-import zipfile
-import tempfile
 import gradio as gr
+import zipfile
+import io
+import re
 
-def process(phase, template_zip, object_file):
+def process_files(phase, objecten_file, template_files):
     try:
-        if template_zip is None:
-            return "Error: Please upload the template directory as a ZIP file."
-        if object_file is None:
-            return "Error: Please upload the object names TXT file."
-        
-        # Create a temporary directory for processing
-        with tempfile.TemporaryDirectory() as tmpdir:
-            # Unzip the template directory
-            template_dir = os.path.join(tmpdir, 'template')
-            with zipfile.ZipFile(template_zip.name, 'r') as zip_ref:
-                zip_ref.extractall(template_dir)
-            
-            # Read object names from the txt file
-            object_names = object_file.read().decode('utf-8').splitlines()
-            
-            # Create a directory to store the results
-            result_dir = os.path.join(tmpdir, 'results')
-            os.makedirs(result_dir, exist_ok=True)
-            
-            for object_name in object_names:
-                if not object_name.strip():
-                    continue  # Skip empty lines
-                # Create a directory for the object under result_dir
-                object_dir = os.path.join(result_dir, f"{phase}_{object_name}")
-                os.makedirs(object_dir, exist_ok=True)
-                
-                # Copy files from template_dir to object_dir
-                for root, dirs, files in os.walk(template_dir):
-                    rel_path = os.path.relpath(root, template_dir)
-                    dest_dir = os.path.join(object_dir, rel_path)
-                    os.makedirs(dest_dir, exist_ok=True)
-                    for filename in files:
-                        template_file = os.path.join(root, filename)
-                        if os.path.isfile(template_file):
-                            # Get the file extension
-                            name, ext = os.path.splitext(filename)
-                            # Create new filename with object name appended
-                            new_filename = f"{name}_{object_name}{ext}"
-                            new_file = os.path.join(dest_dir, new_filename)
-                            shutil.copy(template_file, new_file)
-            
-            # Zip the result_dir
-            result_zip_path = os.path.join(tmpdir, 'result.zip')
-            shutil.make_archive(os.path.splitext(result_zip_path)[0], 'zip', result_dir)
-            
-            # Return the zip file for download
-            return result_zip_path
-    except Exception as e:
-        return f"Error: {str(e)}"
+        # Read and process the 'objecten.txt' file
+        content = objecten_file.read().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}
+
+        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
 
-phase_dropdown = gr.Dropdown(choices=['FAT', 'iFAT', 'iSAT'], label='Select Phase')
+        # 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_zip_input = gr.File(label='Template Directory (ZIP file)', file_types=['.zip'])
+        # 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'
+
+                # Filter template files for this phase
+                phase_templates = [f for f in template_files if re.search(regPhase, f.name, re.IGNORECASE)]
+                if not phase_templates:
+                    error_msg = f"Phase {k} has no templates."
+                    return None, error_msg
+
+                for o in objs[k]:
+                    folder_path = f"{o}/"
+                    for f in phase_templates:
+                        template_filename = f.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
+
+                        file_content = f.read()
+                        f.seek(0)  # Reset file pointer
+                        file_path = folder_path + adjusted_filename
+                        zf.writestr(file_path, file_content)
+        zip_buffer.seek(0)
+        return zip_buffer, None
+    except Exception as e:
+        return None, str(e)
 
-object_file_input = gr.File(label='Object Names File (TXT)', file_types=['.txt'])
+phase_options = ['iFAT', '(i)SAT', 'All']
 
-output_file = gr.File(label='Download Result ZIP')
+interface = gr.Interface(
+    fn=process_files,
+    inputs=[
+        gr.Dropdown(choices=phase_options, label="Select Phase"),
+        gr.File(label="Upload 'objecten.txt' File", type='file'),
+        gr.File(label="Upload Template Files", type='file', multiple=True)
+    ],
+    outputs=[
+        gr.File(label="Download ZIP File"),
+        gr.Textbox(label="Error Message", lines=2)
+    ],
+    title="Template Folder Generator",
+    description="Upload 'objecten.txt' and template files to generate folders and files."
+)
 
-gr.Interface(
-    fn=process,
-    inputs=[phase_dropdown, template_zip_input, object_file_input],
-    outputs=output_file,
-    title='Directory and File Creator',
-    description='Upload the template directory as a ZIP file and the object names TXT file. The processed files will be provided as a downloadable ZIP.'
-).launch()
+interface.launch()