--- a/COBRAxy/custom_data_generator.py	Thu Sep 04 13:20:46 2025 +0000
+++ b/COBRAxy/custom_data_generator.py	Thu Sep 04 22:09:42 2025 +0000
@@ -10,36 +10,41 @@
 import utils.reaction_parsing as reactionUtils
 
 ARGS : argparse.Namespace
-def process_args(args:List[str] = None) -> argparse.Namespace:
+def process_args(args: List[str] = None) -> argparse.Namespace:
+    """
+    Parse command-line arguments for CustomDataGenerator.
     """
-    Interfaces the script of a module with its frontend, making the user's choices for
-    various parameters available as values in code.
+
+    parser = argparse.ArgumentParser(
+        usage="%(prog)s [options]",
+        description="Generate custom data from a given model"
+    )
 
-    Args:
-        args : Always obtained (in file) from sys.argv
+    parser.add_argument("--out_log", type=str, required=True,
+                        help="Output log file")
+    parser.add_argument("--out_data", type=str, required=True,
+                        help="Single output dataset (CSV or Excel)")
 
-    Returns:
-        Namespace : An object containing the parsed arguments
-    """
-    parser = argparse.ArgumentParser(
-        usage = "%(prog)s [options]",
-        description = "generate custom data from a given model")
+    parser.add_argument("--model", type=str,
+                        help="Built-in model identifier (e.g., ENGRO2, Recon, HMRcore)")
+    parser.add_argument("--input", type=str,
+                        help="Custom model file (JSON or XML)")
+    parser.add_argument("--name", type=str, required=True,
+                        help="Model name (default or custom)")
     
-    parser.add_argument("-ol", "--out_log", type = str, required = True, help = "Output log")
-
-    parser.add_argument("-orules", "--out_rules", type = str, required = True, help = "Output rules")
-    parser.add_argument("-orxns", "--out_reactions", type = str, required = True, help = "Output reactions")
-    parser.add_argument("-omedium", "--out_medium", type = str, required = True, help = "Output medium")
-    parser.add_argument("-obnds", "--out_bounds", type = str, required = True, help = "Output bounds")
+    parser.add_argument("--medium_selector", type=str, required=True,
+                        help="Medium selection option (default/custom)")
+    parser.add_argument("--medium", type=str,
+                        help="Custom medium file if medium_selector=Custom")
+    
+    parser.add_argument("--output_format", type=str, choices=["tabular", "xlsx"], required=True,
+                        help="Output format: CSV (tabular) or Excel (xlsx)")
+    
+    parser.add_argument('-idop', '--output_path', type = str, default='result', 
+                        help = 'output path for the result files (default: result)')
+    
 
-    parser.add_argument("-id", "--input",   type = str, required = True, help = "Input model")
-    parser.add_argument("-mn", "--name",    type = str, required = True, help = "Input model name")
-    # ^ I need this because galaxy converts my files into .dat but I need to know what extension they were in
-    parser.add_argument('-idop', '--output_path', type = str, default='result', help = 'output path for maps')
-    argsNamespace = parser.parse_args(args)
-    # ^ can't get this one to work from xml, there doesn't seem to be a way to get the directory attribute from the collection
-
-    return argsNamespace
+    return parser.parse_args(args)
 
 ################################- INPUT DATA LOADING -################################
 def load_custom_model(file_path :utils.FilePath, ext :Optional[utils.FileFormat] = None) -> cobra.Model:
@@ -195,11 +200,30 @@
     ARGS = process_args(args)
 
     # this is the worst thing I've seen so far, congrats to the former MaREA devs for suggesting this!
-    if os.path.isdir(ARGS.output_path) == False: os.makedirs(ARGS.output_path)
+    if os.path.isdir(ARGS.output_path) == False: 
+        os.makedirs(ARGS.output_path)
+
+    if ARGS.input != "None":
+        # load custom model
+        model = load_custom_model(
+            utils.FilePath.fromStrPath(ARGS.input), utils.FilePath.fromStrPath(ARGS.name).ext)
+    else:
+        # load built-in model
 
-    # load custom model
-    model = load_custom_model(
-        utils.FilePath.fromStrPath(ARGS.input), utils.FilePath.fromStrPath(ARGS.name).ext)
+        try:
+            model_enum = utils.Model[ARGS.model]  # e.g., Model['ENGRO2']
+        except KeyError:
+            raise utils.ArgsErr("model", "one of Recon/ENGRO2/HMRcore/Custom_model", ARGS.model)
+
+        # Load built-in model (Model.getCOBRAmodel uses tool_dir to locate local models)
+        try:
+            model = model_enum.getCOBRAmodel(toolDir='../../COBRAxy')
+        except Exception as e:
+            # Wrap/normalize load errors as DataErr for consistency
+            raise utils.DataErr(ARGS.model, f"failed loading built-in model: {e}")
+
+    # Determine final model name: explicit --name overrides, otherwise use the model id
+    model_name = ARGS.name if ARGS.name else ARGS.model
 
     # generate data
     rules = generate_rules(model, asParsed = False)
@@ -207,11 +231,41 @@
     bounds = generate_bounds(model)
     medium = get_medium(model)
 
-    # save files out of collection: path coming from xml
-    save_as_csv(rules, ARGS.out_rules, ("ReactionID", "Rule"))
-    save_as_csv(reactions, ARGS.out_reactions, ("ReactionID", "Reaction"))
-    bounds.to_csv(ARGS.out_bounds, sep = '\t')
-    medium.to_csv(ARGS.out_medium, sep = '\t')
+    df_rules = pd.DataFrame(list(rules.items()), columns = ["ReactionID", "Rule"])
+    df_reactions = pd.DataFrame(list(reactions.items()), columns = ["ReactionID", "Reaction"])
+
+    df_bounds = bounds.reset_index().rename(columns = {"index": "ReactionID"})
+    df_medium = medium.rename(columns = {"reaction": "ReactionID"})
+    df_medium["InMedium"] = True # flag per indicare la presenza nel medium
+
+    merged = df_reactions.merge(df_rules, on = "ReactionID", how = "outer")
+    merged = merged.merge(df_bounds, on = "ReactionID", how = "outer")
+
+    merged = merged.merge(df_medium, on = "ReactionID", how = "left")
+
+    merged["InMedium"] = merged["InMedium"].fillna(False)
+
+    merged = merged.sort_values(by = "InMedium", ascending = False)
+
+    out_file = os.path.join(ARGS.output_path, f"{os.path.basename(ARGS.name).split('.')[0]}_custom_data")
+
+    #merged.to_csv(out_file, sep = '\t', index = False)
+
+
+    ####
+    out_data_path = out_file #ARGS.out_data
+
+    # If Galaxy provided a .dat name, ensure a correct extension according to output_format
+    if ARGS.output_format == "xlsx":
+        if not out_data_path.lower().endswith(".xlsx"):
+            out_data_path = out_data_path + ".xlsx"
+        merged.to_excel(out_data_path, index=False)
+    else:
+        # 'tabular' -> tab-separated, extension .csv is fine and common for Galaxy tabular
+        if not (out_data_path.lower().endswith(".csv") or out_data_path.lower().endswith(".tsv")):
+            out_data_path = out_data_path + ".csv"
+        merged.to_csv(out_data_path, sep="\t", index=False)
+
 
 if __name__ == '__main__':
     main()
\ No newline at end of file