comparison COBRAxy/custom_data_generator.py @ 343:4165326259cc draft

Uploaded

342:057909a104d9

import utils.rule_parsing  as rulesUtils
from typing import Optional, Tuple, Union, List, Dict
import utils.reaction_parsing as reactionUtils

ARGS : argparse.Namespace
def process_args(args:List[str] = None) -> argparse.Namespace:
    """
    Interfaces the script of a module with its frontend, making the user's choices for
    various parameters available as values in code.

    Args:
        args : Always obtained (in file) from sys.argv

    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("-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("-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

################################- INPUT DATA LOADING -################################
def load_custom_model(file_path :utils.FilePath, ext :Optional[utils.FileFormat] = None) -> cobra.Model:
    """
    Loads a custom model from a file, either in JSON or XML format.

    # get args from frontend (related xml)
    global ARGS
    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)

    # load custom model
    model = load_custom_model(
        utils.FilePath.fromStrPath(ARGS.input), utils.FilePath.fromStrPath(ARGS.name).ext)

    # generate data
    rules = generate_rules(model, asParsed = False)
    reactions = generate_reactions(model, asParsed = False)
    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')

if __name__ == '__main__':
    main()

343:4165326259cc

import utils.rule_parsing  as rulesUtils
from typing import Optional, Tuple, Union, List, Dict
import utils.reaction_parsing as reactionUtils

ARGS : argparse.Namespace
def process_args(args: List[str] = None) -> argparse.Namespace:
    """
    Parse command-line arguments for CustomDataGenerator.
    """

    parser = argparse.ArgumentParser(
        usage="%(prog)s [options]",
        description="Generate custom data from a given model"
    )

    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)")

    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("--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)')
    

    return parser.parse_args(args)

################################- INPUT DATA LOADING -################################
def load_custom_model(file_path :utils.FilePath, ext :Optional[utils.FileFormat] = None) -> cobra.Model:
    """
    Loads a custom model from a file, either in JSON or XML format.

    # get args from frontend (related xml)
    global ARGS
    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 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

        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)
    reactions = generate_reactions(model, asParsed = False)
    bounds = generate_bounds(model)
    medium = get_medium(model)

    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()