gsMap 1.71.2__py3-none-any.whl → 1.73.0__py3-none-any.whl

gsMap/latent_to_gene.py

@@ -5,11 +5,10 @@ import numpy as np
 import pandas as pd
 import scanpy as sc
 import scipy
-from scipy.stats import gmean
-from scipy.stats import rankdata
+from scipy.stats import gmean, rankdata
 from sklearn.metrics.pairwise import cosine_similarity
 from sklearn.neighbors import NearestNeighbors
-from tqdm import tqdm
+from tqdm import tqdm, trange
 
 from gsMap.config import LatentToGeneConfig
 
@@ -26,7 +25,7 @@ def find_neighbors(coor, num_neighbour):
     cell1 = np.repeat(cell_indices, indices.shape[1])
     cell2 = indices.flatten()
     distance = distances.flatten()
-    spatial_net = pd.DataFrame({'Cell1': cell1, 'Cell2': cell2, 'Distance': distance})
+    spatial_net = pd.DataFrame({"Cell1": cell1, "Cell2": cell2, "Distance": distance})
     return spatial_net
 
 
@@ -34,11 +33,11 @@ def build_spatial_net(adata, annotation, num_neighbour):
     """
     Build spatial neighbourhood matrix for each spot (cell) based on the spatial coordinates.
     """
-    logger.info(f'------Building spatial graph based on spatial coordinates...')
+    logger.info("------Building spatial graph based on spatial coordinates...")
 
-    coor = adata.obsm['spatial']
+    coor = adata.obsm["spatial"]
     if annotation is not None:
-        logger.info(f'Cell annotations are provided...')
+        logger.info("Cell annotations are provided...")
         spatial_net_list = []
         # Cells with annotations
         for ct in adata.obs[annotation].dropna().unique():
@@ -46,24 +45,24 @@ def build_spatial_net(adata, annotation, num_neighbour):
             coor_temp = coor[idx, :]
             spatial_net_temp = find_neighbors(coor_temp, min(num_neighbour, coor_temp.shape[0]))
             # Map back to original indices
-            spatial_net_temp['Cell1'] = idx[spatial_net_temp['Cell1'].values]
-            spatial_net_temp['Cell2'] = idx[spatial_net_temp['Cell2'].values]
+            spatial_net_temp["Cell1"] = idx[spatial_net_temp["Cell1"].values]
+            spatial_net_temp["Cell2"] = idx[spatial_net_temp["Cell2"].values]
             spatial_net_list.append(spatial_net_temp)
-            logger.info(f'{ct}: {coor_temp.shape[0]} cells')
+            logger.info(f"{ct}: {coor_temp.shape[0]} cells")
 
         # Cells labeled as nan
         if pd.isnull(adata.obs[annotation]).any():
             idx_nan = np.where(pd.isnull(adata.obs[annotation]))[0]
-            logger.info(f'Nan: {len(idx_nan)} cells')
+            logger.info(f"Nan: {len(idx_nan)} cells")
             spatial_net_temp = find_neighbors(coor, num_neighbour)
-            spatial_net_temp = spatial_net_temp[spatial_net_temp['Cell1'].isin(idx_nan)]
+            spatial_net_temp = spatial_net_temp[spatial_net_temp["Cell1"].isin(idx_nan)]
             spatial_net_list.append(spatial_net_temp)
         spatial_net = pd.concat(spatial_net_list, axis=0)
     else:
-        logger.info(f'Cell annotations are not provided...')
+        logger.info("Cell annotations are not provided...")
         spatial_net = find_neighbors(coor, num_neighbour)
 
-    return spatial_net.groupby('Cell1')['Cell2'].apply(np.array).to_dict()
+    return spatial_net.groupby("Cell1")["Cell2"].apply(np.array).to_dict()
 
 
 def find_neighbors_regional(cell_pos, spatial_net_dict, coor_latent, config, cell_annotations):
@@ -96,8 +95,16 @@ def find_neighbors_regional(cell_pos, spatial_net_dict, coor_latent, config, cel
     return cell_select_pos
 
 
-def compute_regional_mkscore(cell_pos, spatial_net_dict, coor_latent, config, cell_annotations,
-                             ranks, frac_whole, adata_X_bool):
+def compute_regional_mkscore(
+    cell_pos,
+    spatial_net_dict,
+    coor_latent,
+    config,
+    cell_annotations,
+    ranks,
+    frac_whole,
+    adata_X_bool,
+):
     """
     Compute gmean ranks of a region.
     """
@@ -122,79 +129,113 @@ def compute_regional_mkscore(cell_pos, spatial_net_dict, coor_latent, config, ce
         # Simultaneously consider the ratio of expression fractions and ranks
         gene_ranks_region = gene_ranks_region * frac_region
 
-    mkscore = np.exp(gene_ranks_region ** 1.5) - 1
+    mkscore = np.exp(gene_ranks_region**1.5) - 1
     return mkscore.astype(np.float16, copy=False)
 
 
 def run_latent_to_gene(config: LatentToGeneConfig):
-    logger.info('------Loading the spatial data...')
+    logger.info("------Loading the spatial data...")
     adata = sc.read_h5ad(config.hdf5_with_latent_path)
-    logger.info(f'Loaded spatial data with {adata.n_obs} cells and {adata.n_vars} genes.')
+    logger.info(f"Loaded spatial data with {adata.n_obs} cells and {adata.n_vars} genes.")
 
     if config.annotation is not None:
-        logger.info(f'------Cell annotations are provided as {config.annotation}...')
+        logger.info(f"------Cell annotations are provided as {config.annotation}...")
         initial_cell_count = adata.n_obs
         adata = adata[~pd.isnull(adata.obs[config.annotation]), :]
-        logger.info(f'Removed null annotations. Cells retained: {adata.n_obs} (initial: {initial_cell_count}).')
+        logger.info(
+            f"Removed null annotations. Cells retained: {adata.n_obs} (initial: {initial_cell_count})."
+        )
 
     # Homologs transformation
-    if config.homolog_file is not None:
-        logger.info(f'------Transforming the {config.species} to HUMAN_GENE_SYM...')
-        homologs = pd.read_csv(config.homolog_file, sep='\t')
-        if homologs.shape[1] != 2:
-            raise ValueError("Homologs file must have two columns: one for the species and one for the human gene symbol.")
-
-        homologs.columns = [config.species, 'HUMAN_GENE_SYM']
-        homologs.set_index(config.species, inplace=True)
-        adata = adata[:, adata.var_names.isin(homologs.index)]
-        logger.info(f"{adata.shape[1]} genes retained after homolog transformation.")
-        if adata.shape[1] < 100:
-            raise ValueError("Too few genes retained in ST data (<100).")
-        adata.var_names = homologs.loc[adata.var_names, 'HUMAN_GENE_SYM'].values
-        adata = adata[:, ~adata.var_names.duplicated()]
+    if config.homolog_file is not None and config.species is not None:
+        species_col_name = f"{config.species}_homolog"
+
+        # Check if homolog conversion has already been performed
+        if species_col_name in adata.var.columns:
+            logger.warning(
+                f"Column '{species_col_name}' already exists in adata.var. "
+                f"It appears gene names have already been converted to human gene symbols. "
+                f"Skipping homolog transformation."
+            )
+        else:
+            logger.info(f"------Transforming the {config.species} to HUMAN_GENE_SYM...")
+            homologs = pd.read_csv(config.homolog_file, sep="\t")
+            if homologs.shape[1] != 2:
+                raise ValueError(
+                    "Homologs file must have two columns: one for the species and one for the human gene symbol."
+                )
+
+            homologs.columns = [config.species, "HUMAN_GENE_SYM"]
+            homologs.set_index(config.species, inplace=True)
 
-    # Create mappings
-    n_cells = adata.n_obs
-    n_genes = adata.n_vars
+            # original_gene_names = adata.var_names.copy()
+
+            # Filter genes present in homolog file
+            adata = adata[:, adata.var_names.isin(homologs.index)]
+            logger.info(f"{adata.shape[1]} genes retained after homolog transformation.")
+            if adata.shape[1] < 100:
+                raise ValueError("Too few genes retained in ST data (<100).")
+
+            # Create mapping table of original to human gene names
+            gene_mapping = pd.Series(
+                homologs.loc[adata.var_names, "HUMAN_GENE_SYM"].values, index=adata.var_names
+            )
+
+            # Store original species gene names in var dataframe with the suffixed column name
+            adata.var[species_col_name] = adata.var_names.values
+
+            # Convert var_names to human gene symbols
+            adata.var_names = gene_mapping.values
+            adata.var.index.name = "HUMAN_GENE_SYM"
+
+            # Remove duplicated genes after conversion
+            adata = adata[:, ~adata.var_names.duplicated()]
+            logger.info(f"{adata.shape[1]} genes retained after removing duplicates.")
 
     if config.annotation is not None:
         cell_annotations = adata.obs[config.annotation].values
-        logger.info(f'Using cell annotations for {len(cell_annotations)} cells.')
+        logger.info(f"Using cell annotations for {len(cell_annotations)} cells.")
     else:
         cell_annotations = None
 
     # Build the spatial graph
-    logger.info('------Building the spatial graph...')
+    logger.info("------Building the spatial graph...")
     spatial_net_dict = build_spatial_net(adata, config.annotation, config.num_neighbour_spatial)
-    logger.info('Spatial graph built successfully.')
+    logger.info("Spatial graph built successfully.")
 
     # Extract the latent representation
-    logger.info('------Extracting the latent representation...')
+    logger.info("------Extracting the latent representation...")
     coor_latent = adata.obsm[config.latent_representation]
     coor_latent = coor_latent.astype(np.float32)
-    logger.info('Latent representation extracted.')
+    logger.info("Latent representation extracted.")
 
     # Geometric mean across slices
     gM = None
+    frac_whole = None
     if config.gM_slices is not None:
-        logger.info('Geometrical mean across multiple slices is provided.')
+        logger.info("Geometrical mean across multiple slices is provided.")
         gM_df = pd.read_parquet(config.gM_slices)
         if config.species is not None:
-            homologs = pd.read_csv(config.homolog_file, sep='\t')
+            homologs = pd.read_csv(config.homolog_file, sep="\t")
             if homologs.shape[1] < 2:
-                raise ValueError("Homologs file must have at least two columns: one for the species and one for the human gene symbol.")
-            homologs.columns = [config.species, 'HUMAN_GENE_SYM']
+                raise ValueError(
+                    "Homologs file must have at least two columns: one for the species and one for the human gene symbol."
+                )
+            homologs.columns = [config.species, "HUMAN_GENE_SYM"]
             homologs.set_index(config.species, inplace=True)
             gM_df = gM_df.loc[gM_df.index.isin(homologs.index)]
-            gM_df.index = homologs.loc[gM_df.index, 'HUMAN_GENE_SYM'].values
+            gM_df.index = homologs.loc[gM_df.index, "HUMAN_GENE_SYM"].values
         common_genes = np.intersect1d(adata.var_names, gM_df.index)
         gM_df = gM_df.loc[common_genes]
-        gM = gM_df['G_Mean'].values
+        gM = gM_df["G_Mean"].values
+        frac_whole = gM_df["frac"].values
         adata = adata[:, common_genes]
-        logger.info(f'{len(common_genes)} common genes retained after loading the cross slice geometric mean.')
+        logger.info(
+            f"{len(common_genes)} common genes retained after loading the cross slice geometric mean."
+        )
 
     # Compute ranks after taking common genes with gM_slices
-    logger.info('------Ranking the spatial data...')
+    logger.info("------Ranking the spatial data...")
     if not scipy.sparse.issparse(adata.X):
         adata_X = scipy.sparse.csr_matrix(adata.X)
     elif isinstance(adata.X, scipy.sparse.csr_matrix):
@@ -202,51 +243,70 @@ def run_latent_to_gene(config: LatentToGeneConfig):
     else:
         adata_X = adata.X.tocsr()
 
-    ranks = np.zeros((n_cells, adata.n_vars), dtype=np.float32)
+    # Create mappings
+    n_cells = adata.n_obs
+    n_genes = adata.n_vars
 
+    ranks = np.zeros((n_cells, adata.n_vars), dtype=np.float16)
     for i in tqdm(range(n_cells), desc="Computing ranks per cell"):
         data = adata_X[i, :].toarray().flatten()
-        ranks[i, :] = rankdata(data, method='average')
+        ranks[i, :] = rankdata(data, method="average")
 
     if gM is None:
         gM = gmean(ranks, axis=0)
+        gM = gM.astype(np.float16)
 
-    # Compute the fraction of each gene across cells
     adata_X_bool = adata_X.astype(bool)
-    frac_whole = np.asarray(adata_X_bool.sum(axis=0)).flatten() / n_cells
-    logger.info('Gene expression proportion of each gene across cells computed.')
+    if frac_whole is None:
+        # Compute the fraction of each gene across cells
+        frac_whole = np.asarray(adata_X_bool.sum(axis=0)).flatten() / n_cells
+        logger.info("Gene expression proportion of each gene across cells computed.")
+    else:
+        logger.info(
+            "Gene expression proportion of each gene across cells in all sections has been provided."
+        )
 
+    frac_whole += 1e-12  # Avoid division by zero
     # Normalize the ranks
     ranks /= gM
 
-    # Compute marker scores in parallel
-    logger.info('------Computing marker scores...')
     def compute_mk_score_wrapper(cell_pos):
         return compute_regional_mkscore(
-            cell_pos, spatial_net_dict, coor_latent, config, cell_annotations, ranks, frac_whole, adata_X_bool
+            cell_pos,
+            spatial_net_dict,
+            coor_latent,
+            config,
+            cell_annotations,
+            ranks,
+            frac_whole,
+            adata_X_bool,
         )
 
-    mk_scores = [compute_mk_score_wrapper(cell_pos) for cell_pos in tqdm(range(n_cells), desc="Calculating marker scores")]
-    mk_score = np.vstack(mk_scores).T
-    logger.info('Marker scores computed.')
+    logger.info("------Computing marker scores...")
+    mk_score = np.zeros((n_cells, n_genes), dtype=np.float16)
+    for cell_pos in trange(n_cells, desc="Calculating marker scores"):
+        mk_score[cell_pos, :] = compute_mk_score_wrapper(cell_pos)
+
+    mk_score = mk_score.T
+    logger.info("Marker scores computed.")
 
     # Remove mitochondrial genes
     gene_names = adata.var_names.values.astype(str)
-    mt_gene_mask = ~(np.char.startswith(gene_names, 'MT-') | np.char.startswith(gene_names, 'mt-'))
+    mt_gene_mask = ~(np.char.startswith(gene_names, "MT-") | np.char.startswith(gene_names, "mt-"))
     mk_score = mk_score[mt_gene_mask, :]
     gene_names = gene_names[mt_gene_mask]
-    logger.info(f'Removed mitochondrial genes. Remaining genes: {len(gene_names)}.')
+    logger.info(f"Removed mitochondrial genes. Remaining genes: {len(gene_names)}.")
 
     # Save the marker scores
-    logger.info(f'------Saving marker scores ...')
+    logger.info("------Saving marker scores ...")
     output_file_path = Path(config.mkscore_feather_path)
     output_file_path.parent.mkdir(parents=True, exist_ok=True, mode=0o755)
     mk_score_df = pd.DataFrame(mk_score, index=gene_names, columns=adata.obs_names)
     mk_score_df.reset_index(inplace=True)
-    mk_score_df.rename(columns={'index': 'HUMAN_GENE_SYM'}, inplace=True)
+    mk_score_df.rename(columns={"index": "HUMAN_GENE_SYM"}, inplace=True)
     mk_score_df.to_feather(output_file_path)
-    logger.info(f'Marker scores saved to {output_file_path}.')
+    logger.info(f"Marker scores saved to {output_file_path}.")
 
     # Save the modified adata object to disk
     adata.write(config.hdf5_with_latent_path)
-    logger.info(f'Modified adata object saved to {config.hdf5_with_latent_path}.')
+    logger.info(f"Modified adata object saved to {config.hdf5_with_latent_path}.")

gsMap/main.py

@@ -1,5 +1,8 @@
-from gsMap import (__version__)
-from gsMap.config import *
+import argparse
+
+from gsMap import __version__
+from gsMap.config import cli_function_registry
+
 
 def main():
     parser = create_parser()
@@ -7,21 +10,27 @@ def main():
     if args.subcommand is None:
         parser.print_help()
         exit(1)
-    args.func(
-        args
-    )
+    args.func(args)
+
 
 def create_parser():
-    parser = argparse.ArgumentParser(description=" gsMap: genetically informed spatial mapping of cells for complex traits",
-                                     formatter_class=argparse.RawTextHelpFormatter,
-                                     prog='gsMap'
-                                     )
-    parser.add_argument('--version', '-v', action='version', version=f'gsMap version {__version__}')
-    subparsers = parser.add_subparsers(dest="subcommand", help="Subcommands", title="Available subcommands")
+    parser = argparse.ArgumentParser(
+        description=" gsMap: genetically informed spatial mapping of cells for complex traits",
+        formatter_class=argparse.RawTextHelpFormatter,
+        prog="gsMap",
+    )
+    parser.add_argument(
+        "--version", "-v", action="version", version=f"gsMap version {__version__}"
+    )
+    subparsers = parser.add_subparsers(
+        dest="subcommand", help="Subcommands", title="Available subcommands"
+    )
     for subcommand in cli_function_registry.values():
-        subcommand_parser = subparsers.add_parser(subcommand.name, help=subcommand.description,
-                                                  formatter_class=argparse.ArgumentDefaultsHelpFormatter
-                                                  )
+        subcommand_parser = subparsers.add_parser(
+            subcommand.name,
+            help=subcommand.description,
+            formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        )
         subcommand.add_args_function(subcommand_parser)
         subcommand_parser.set_defaults(func=subcommand.func)
     return parser

gsMap/report.py

@@ -16,16 +16,17 @@ logger = logging.getLogger(__name__)
 try:
     from importlib.resources import files
 
-    template_dir = files('gsMap').joinpath('templates')
+    template_dir = files("gsMap").joinpath("templates")
 except (ImportError, FileNotFoundError):
     # Fallback to a relative path if running in development mode
-    template_dir = os.path.join(os.path.dirname(__file__), 'templates')
+    template_dir = os.path.join(os.path.dirname(__file__), "templates")
 
 # Set up Jinja2 environment
 env = Environment(loader=FileSystemLoader(template_dir))
 
 # Load the template
-template = env.get_template('report_template.html')
+template = env.get_template("report_template.html")
+
 
 def copy_files_to_report_dir(result_dir, report_dir, files_to_copy):
     """Copy specified files (HTML or PNG) to the report directory."""
@@ -36,28 +37,30 @@ def copy_files_to_report_dir(result_dir, report_dir, files_to_copy):
 
 def load_cauchy_table(csv_file):
     """Load the Cauchy combination table from a compressed CSV file using Pandas."""
-    df = pd.read_csv(csv_file, compression='gzip')
-    table_data = df[['annotation', 'p_cauchy', 'p_median']].to_dict(orient='records')
+    df = pd.read_csv(csv_file, compression="gzip")
+    table_data = df[["annotation", "p_cauchy", "p_median"]].to_dict(orient="records")
     return table_data
 
 
 def load_gene_diagnostic_info(csv_file):
     """Load the Gene Diagnostic Info CSV file and return the top 50 rows."""
     df = pd.read_csv(csv_file)
-    top_50 = df.head(50).to_dict(orient='records')
+    top_50 = df.head(50).to_dict(orient="records")
     return top_50
 
 
 def embed_html_content(file_path):
     """Read the content of an HTML file and return it as a string."""
-    with open(file_path, 'r') as f:
+    with open(file_path) as f:
         return f.read()
 
+
 def check_and_run_cauchy_combination(config):
     cauchy_result_file = config.get_cauchy_result_file(config.trait_name)
     if cauchy_result_file.exists():
         logger.info(
-            f"Cauchy combination already done for trait {config.trait_name}. Results saved at {cauchy_result_file}. Skipping...")
+            f"Cauchy combination already done for trait {config.trait_name}. Results saved at {cauchy_result_file}. Skipping..."
+        )
     else:
         logger.info(f"Running Cauchy combination for trait {config.trait_name}...")
         cauchy_config = CauchyCombinationConfig(
@@ -68,16 +71,16 @@ def check_and_run_cauchy_combination(config):
         )
         run_Cauchy_combination(cauchy_config)
 
-    df = pd.read_csv(cauchy_result_file, compression='gzip')
-    table_data = df[['annotation', 'p_cauchy', 'p_median']].to_dict(orient='records')
+    df = pd.read_csv(cauchy_result_file, compression="gzip")
+    table_data = df[["annotation", "p_cauchy", "p_median"]].to_dict(orient="records")
 
     return table_data
 
-def run_report(config: ReportConfig, run_parameters=None):
 
-    logger.info('Running gsMap Diagnosis Module')
+def run_report(config: ReportConfig, run_parameters=None):
+    logger.info("Running gsMap Diagnosis Module")
     run_Diagnosis(config)
-    logger.info('gsMap Diagnosis running successfully')
+    logger.info("gsMap Diagnosis running successfully")
 
     report_dir = config.get_report_dir(config.trait_name)
     gene_diagnostic_info_file = config.get_gene_diagnostic_info_save_path(config.trait_name)
@@ -90,19 +93,27 @@ def run_report(config: ReportConfig, run_parameters=None):
     gss_distribution_dir = config.get_GSS_plot_dir(config.trait_name)
 
     gene_plots = []
-    plot_select_gene_list = config.get_GSS_plot_select_gene_file(config.trait_name).read_text().splitlines()
+    plot_select_gene_list = (
+        config.get_GSS_plot_select_gene_file(config.trait_name).read_text().splitlines()
+    )
     for gene_name in plot_select_gene_list:
-        expression_png = gss_distribution_dir / f"{config.sample_name}_{gene_name}_Expression_Distribution.png"
+        expression_png = (
+            gss_distribution_dir / f"{config.sample_name}_{gene_name}_Expression_Distribution.png"
+        )
         gss_png = gss_distribution_dir / f"{config.sample_name}_{gene_name}_GSS_Distribution.png"
         # check if expression and GSS plots exist
         if not os.path.exists(expression_png) or not os.path.exists(gss_png):
             print(f"Skipping gene {gene_name} as expression or GSS plot is missing.")
             continue
-        gene_plots.append({
-            'name': gene_name,
-            'expression_plot': expression_png.relative_to(report_dir),  # Path for gene expression plot
-            'gss_plot': gss_png.relative_to(report_dir)  # Path for GSS distribution plot
-        })
+        gene_plots.append(
+            {
+                "name": gene_name,
+                "expression_plot": expression_png.relative_to(
+                    report_dir
+                ),  # Path for gene expression plot
+                "gss_plot": gss_png.relative_to(report_dir),  # Path for GSS distribution plot
+            }
+        )
 
     # # Copy PNG files to the report directory
     # copy_files_to_report_dir(result_dir, report_dir, [gene['expression_plot'] for gene in gene_plots] + [gene['gss_plot'] for gene in gene_plots])
@@ -115,7 +126,9 @@ def run_report(config: ReportConfig, run_parameters=None):
     # Sample data for other report components
     title = f"{config.sample_name} Genetic Spatial Mapping Report"
 
-    genetic_mapping_plot = embed_html_content(config.get_gsMap_html_plot_save_path(config.trait_name))
+    genetic_mapping_plot = embed_html_content(
+        config.get_gsMap_html_plot_save_path(config.trait_name)
+    )
     manhattan_plot = embed_html_content(config.get_manhattan_html_plot_path(config.trait_name))
 
     gsmap_version = gsMap.__version__
@@ -133,13 +146,12 @@ def run_report(config: ReportConfig, run_parameters=None):
         "Report Directory": config.get_report_dir(trait_name),
         "gsMap Report File": config.get_gsMap_report_file(trait_name),
         "Gene Diagnostic Info File": config.get_gene_diagnostic_info_save_path(trait_name),
-        "Report Generation Date": pd.Timestamp.now().strftime('%Y-%m-%d %H:%M:%S'),
+        "Report Generation Date": pd.Timestamp.now().strftime("%Y-%m-%d %H:%M:%S"),
     }
 
     if run_parameters is not None:
         default_run_parameters.update(run_parameters)
 
-
     output_html = template.render(
         title=title,
         genetic_mapping_plot=genetic_mapping_plot,  # Inlined genetic mapping plot
@@ -148,7 +160,7 @@ def run_report(config: ReportConfig, run_parameters=None):
         gene_plots=gene_plots,  # List of PNG paths for gene plots
         gsmap_version=gsmap_version,
         parameters=default_run_parameters,  # Pass the run parameters to the template
-        gene_diagnostic_info=gene_diagnostic_info  # Include top 50 gene diagnostic info rows
+        gene_diagnostic_info=gene_diagnostic_info,  # Include top 50 gene diagnostic info rows
     )
 
     # Save the generated HTML report in the 'report' directory
@@ -157,4 +169,6 @@ def run_report(config: ReportConfig, run_parameters=None):
         f.write(output_html)
 
     logger.info(f"Report generated successfully! Saved at {report_file}.")
-    logger.info(f"Copy the report directory to your local PC and open the HTML report file in a web browser to view the report.")
+    logger.info(
+        "Copy the report directory to your local PC and open the HTML report file in a web browser to view the report."
+    )