Update app.py

app.py

@@ -1,57 +1,172 @@
+import os
+import re
+from shutil import copy
 import gradio as gr
-from utils.steps import copyPasteTemplates  # Keeping the necessary parts
-from utils.options import inputPhases  # Importing inputPhases for phase dropdown
+from os import makedirs, listdir
+from os.path import isdir, isfile, join, realpath
+from tkinter import Tk
+from tkinter.filedialog import askdirectory
 
-# Global variables to store inputs
-testphase = None
-rootDir = None
-templatesDir = None
+# --- Constants ---
+phases = ["iFAT", "(i)SAT"]
+inputPhases = {**{i: k for i, k in enumerate(phases)}, **{len(phases): "All"}}
+exitinput = {"no", "n", "0"}
+regTemplate = r'template'
 
-# Function to validate directory existence
+# --- Helper Functions ---
+
+# Function to print available options
+def printOptions():
+    print("\nchoose one of the following options;\n")
+    for key in inputPhases:
+        print("[%d] %s" % (key, inputPhases[key]))
+    print()
+
+# Function to get phase input
+def validatedPhaseInput():
+    inputPhase = None
+    while inputPhase is None:
+        printOptions()
+        inputPhase = input()
+
+        if inputPhase.isnumeric():
+            inputPhase = int(inputPhase)
+            if inputPhase not in range(len(inputPhases)):
+                print("\n", inputPhase, "is not a valid option")
+                inputPhase = None
+            else:
+                return inputPhases[inputPhase]
+        else:
+            inputPhase = inputPhase.lower()
+            if inputPhase not in phases:
+                print("\n", inputPhase, "is not a valid option")
+                inputPhase = None
+            else:
+                return inputPhases[inputPhase]
+
+    print("Something went wrong, please consult the maintainer of the codebase.")
+    return inputPhase
+
+# Function to validate if a directory exists
 def validate_directory(directory_path):
-    if os.path.isdir(directory_path):
-        return True
-    else:
-        return False
-
-# Improved createFolders function with error handling and feedback
-def createFolders():
-    global rootDir, testphase, templatesDir
-    if not rootDir:
-        return "Error: Root directory not provided."
-    if not templatesDir:
-        return "Error: Templates directory not provided."
-    if not testphase:
-        return "Error: Phase not selected."
-
-    # Check if directories exist
-    if not validate_directory(rootDir):
-        return f"Error: Root directory '{rootDir}' does not exist."
-    if not validate_directory(templatesDir):
-        return f"Error: Templates directory '{templatesDir}' does not exist."
+    return os.path.isdir(directory_path)
+
+# Function to get list of files matching a pattern
+def getFilesWith(path: str, reg: str):
+    if not isdir(path):
+        print(f"{path} is not a valid path")
+        return None
+    content = listdir(path)
+    if len(content) == 0:
+        print(f"{path} has no content")
+        return None
+    files = [f for f in content if isfile(join(path, f)) and re.search(reg, f, re.IGNORECASE)]
+    if len(files) == 0:
+        print(f"{path} contains no {reg}")
+        return None
+    return files
+
+# Function to create new folders
+def createNewFolders(dirs: list):
+    for d in dirs:
+        if not isdir(d):
+            makedirs(d)
+        else:
+            print(f"Directory already exists: {d}")
+
+# Function to create new templates
+def createNewTemplates(objs, templatesDir, regTemplate, root):
+    templatefiles = getFilesWith(templatesDir, regTemplate)
+    for k in objs:
+        regPhase = r""
+        match k:
+            case "(i)SAT":
+                regPhase = r"sat"
+            case "iFAT":
+                regPhase = r"fat"
+
+        files = [f for f in templatefiles if re.search(regPhase, f, re.IGNORECASE)]
+        if len(files) == 0:
+            print(f"Phase {k} has no templates")
+            continue
+
+        for o in objs[k]:
+            targetLocation = join(root, o)
+            tlFiles = getFilesWith(targetLocation, regPhase)
+
+            if tlFiles:
+                print(f"{k} files already exist in: {targetLocation}")
+                continue
+
+            for f in files:
+                templatepath = join(templatesDir, f)
+                targetpath = targetLocation
+                if re.search(r"hut_\d{4}[a-zA-Z]{2}", f, re.IGNORECASE):
+                    targetpath = join(targetLocation, f[:4] + o + f[10:])
+                copy(templatepath, targetpath)
+
+# Function to get objects per phase
+def getObjectsPerPhase(phase: str = "All"):
+    with open("./objecten.txt", "r") as f:
+        t = f.read().split("\n\n")
+
+    objs = {p: [] for p in phases}
+    if phase in phases:
+        objs = {phase: []}
+
+    regObject = r"\d{4}[a-zA-Z]{2}"
+    for g in t:
+        ls = g.split("\n")
+        k = ls[0]
+        if k in objs:
+            objs[k] = ls[1::]
+        else:
+            print(f"Key [{k}] is not recognized")
+
+    objs = {k: objs[k] for k in objs if objs[k]}
+
+    for k in objs:
+        for i, o in enumerate(objs[k]):
+            m = re.search(regObject, o)
+            if not m:
+                continue
+            objs[k][i] = m.group(0)
+
+    return objs
+
+# Function to copy and paste templates
+def copyPasteTemplates(root: str, phase: str, templatesDir: str):
+    objs = getObjectsPerPhase(phase)
+    objectslist = list(set([o for p in [objs[k] for k in objs] for o in p]))
     
-    # Proceed with folder creation if all inputs are valid
-    copyPasteTemplates(rootDir, testphase, templatesDir)
-    return "Folders created successfully!"
+    createNewFolders([join(root, o) for o in objectslist])
+    print("Directories created")
+    
+    createNewTemplates(objs, templatesDir, regTemplate, root)
+    print("Templates ready")
+
+# --- Main Gradio App ---
 
 # Main function to run steps
 def run_steps(phase, root_dir, templates_dir):
-    global testphase, rootDir, templatesDir
     testphase = phase
     rootDir = root_dir
     templatesDir = templates_dir
 
     # Run folder creation process
-    result = createFolders()
-    return result
+    if not validate_directory(rootDir):
+        return f"Error: Root directory '{rootDir}' does not exist."
+    if not validate_directory(templatesDir):
+        return f"Error: Templates directory '{templatesDir}' does not exist."
+
+    copyPasteTemplates(rootDir, testphase, templatesDir)
+    return "Folders created successfully!"
 
 # Gradio interface
 def validate_and_run(phase, root_dir, templates_dir):
-    # Check for empty inputs
     if not root_dir or not templates_dir:
         return "Error: Please provide both the root and templates directory paths."
     
-    # Run the main function with inputs
     return run_steps(phase, root_dir, templates_dir)
 
 # Gradio app components