PyamilySeq 1.3.1__py3-none-any.whl → 1.3.3__py3-none-any.whl

PyamilySeq/{Cluster_Compare.py → Group_Compare.py}

@@ -1,5 +1,12 @@
-import argparse
 from collections import defaultdict
+import logging
+import os
+
+# Use centralised logger factory from constants
+try:
+    from .constants import configure_logger, LoggingArgumentParser
+except Exception:
+    from constants import configure_logger, LoggingArgumentParser
 
 def read_cd_hit_output(clstr_file):
     """
@@ -23,10 +30,8 @@ def read_cd_hit_output(clstr_file):
     return seq_to_cluster
 
 def compare_cd_hit_clusters(file1, file2, output_file):
-    """
-    Compares two CD-HIT .clstr files to check if clusters are the same.
-    Writes the results to a TSV file.
-    """
+    logger = logging.getLogger("PyamilySeq.Group_Compare")
+    logger.info("Comparing clusters: %s vs %s", file1, file2)
     # Read both clustering files
     clusters1 = read_cd_hit_output(file1)
     clusters2 = read_cd_hit_output(file2)
@@ -80,12 +85,11 @@ def compare_cd_hit_clusters(file1, file2, output_file):
                     tsv_data.append([seq, cluster_id1, cluster_id2, "Cluster name change"])
 
     # Print metrics
-    print("🔢 Clustering Comparison Metrics:")
-    print(f"Cluster name changes: {cluster_name_changes}")
-    print(f"Sequence shifts (sequences assigned to different clusters): {sequence_shifts}")
-    print(f"Sequences only in the first file: {len(only_in_file1)}")
-    print(f"Sequences only in the second file: {len(only_in_file2)}")
-    print()
+    logger.info("Clustering Comparison Metrics:")
+    logger.info("Cluster name changes: %s", cluster_name_changes)
+    logger.info("Sequence shifts (sequences assigned to different clusters): %s", sequence_shifts)
+    logger.info("Sequences only in the first file: %s", len(only_in_file1))
+    logger.info("Sequences only in the second file: %s", len(only_in_file2))
 
     # Write the results to a TSV file
     with open(output_file, 'w') as out_file:
@@ -93,15 +97,25 @@ def compare_cd_hit_clusters(file1, file2, output_file):
         for row in tsv_data:
             out_file.write("\t".join(map(str, row)) + "\n")
 
-    print(f"✅ Results have been written to {output_file}")
+    logger.info("Results have been written to %s", output_file)
 
 def main():
-    parser = argparse.ArgumentParser(description="Compare two CD-HIT .clstr files to check for clustering consistency.")
+    # Early console-only logger so parser.description and argparse messages are emitted via logger
+    early_logger = configure_logger("PyamilySeq.Group_Compare", enable_file=False, log_dir=None, verbose=False)
+    parser = LoggingArgumentParser(logger_name="PyamilySeq.Group_Compare", description="Running Group-Compare - A tool to compare two CD-HIT .clstr files to check for clustering consistency.")
+
     parser.add_argument("-file1", required=True, help="First CD-HIT .clstr file")
     parser.add_argument("-file2", required=True, help="Second CD-HIT .clstr file")
     parser.add_argument("-output", required=True, help="Output file (TSV format)")
+    parser.add_argument("--log", action="store_true", dest="log", help="Create a timestamped logfile for this run.")
+    parser.add_argument("--log-dir", dest="log_dir", default=None, help="Directory for logfile (default: same dir as -output).")
     args = parser.parse_args()
 
+    # Setup logger
+    out_dir = os.path.abspath(os.path.dirname(args.output)) if args.output else os.getcwd()
+    log_dir = args.log_dir if args.log_dir else out_dir
+    logger = configure_logger("PyamilySeq.Group_Compare", enable_file=args.log, log_dir=log_dir, verbose=False)
+
     compare_cd_hit_clusters(args.file1, args.file2, args.output)
 
 if __name__ == "__main__":

PyamilySeq/Group_Extractor.py

@@ -1,6 +1,12 @@
-import argparse
 import os
 import csv
+import logging
+
+# Use centralissed logger factory from constants
+try:
+    from .constants import configure_logger, LoggingArgumentParser
+except Exception:
+    from constants import configure_logger, LoggingArgumentParser
 
 
 def parse_fasta(fasta_file):
@@ -43,9 +49,8 @@ def parse_csv(csv_file):
 
 
 def write_group_fastas(groups, sequences, output_dir):
-    """
-    Writes individual FASTA files for each group with the relevant sequences.
-    """
+
+    logger = logging.getLogger("PyamilySeq.Group_Extractor")
     if not os.path.exists(output_dir):
         os.makedirs(output_dir)
 
@@ -56,27 +61,39 @@ def write_group_fastas(groups, sequences, output_dir):
                 if gene_id in sequences:
                     f.write(f">{gene_id}\n{sequences[gene_id]}\n")
                 else:
-                    print(f"Warning: Gene ID {gene_id} not found in FASTA file.")
+                    logger.warning("Warning: Gene ID %s not found in FASTA file.", gene_id)
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Process FASTA and CSV files to create grouped FASTA outputs.")
+    # Early console-only logger so the parser description is logged before argparse outputs.
+    early_logger = configure_logger("PyamilySeq.Group_Extractor", enable_file=False, log_dir=None, verbose=False)
+    parser = LoggingArgumentParser(logger_name="PyamilySeq.Group_Extractor", description="Running Group-Extractor - A tool to process FASTA and CSV files to create grouped FASTA outputs.")
+
     parser.add_argument("-fasta", required=True, help="Input FASTA file containing gene sequences.")
     parser.add_argument("-csv", required=True, help="Input CSV file containing group and gene information.")
     parser.add_argument("-output_dir", required=True, help="Directory to save the grouped FASTA files.")
+    parser.add_argument("--log", action="store_true", dest="log", help="Create a timestamped logfile for this run.")
+    parser.add_argument("--log-dir", dest="log_dir", default=None, help="Directory for logfile (default: output_dir).")
 
     args = parser.parse_args()
 
-    # Parse the input files
-    print("Parsing FASTA file...")
+    # Setup logger writing to output_dir (optional file)
+    log_dir = os.path.abspath(args.output_dir) if args.output_dir else os.getcwd()
+    if hasattr(args, "log_dir") and args.log_dir:
+        log_dir = args.log_dir
+    # Only create a logfile when --log is provided; default is console (stdout) only.
+    logger = configure_logger("PyamilySeq.Group_Extractor", enable_file=getattr(args, "log", False), log_dir=log_dir, verbose=False)
+
+    logger.info("Parsing FASTA file: %s", args.fasta)
     sequences = parse_fasta(args.fasta)
-    print("Parsing CSV file...")
+    logger.info("Parsed %d sequences.", len(sequences))
+    logger.info("Parsing CSV file: %s", args.csv)
     groups = parse_csv(args.csv)
+    logger.info("Parsed %d groups.", len(groups))
 
-    # Write the grouped FASTA files
-    print("Writing grouped FASTA files...")
+    logger.info("Writing grouped FASTA files to %s", args.output_dir)
     write_group_fastas(groups, sequences, args.output_dir)
-    print("Process completed successfully.")
+    logger.info("Process completed successfully.")
 
 
 if __name__ == "__main__":

PyamilySeq/Group_Sizes.py

@@ -1,6 +1,14 @@
-import argparse
+
 import os
 import csv
+import logging
+
+
+# Use centralised logger factory from constants
+try:
+    from .constants import configure_logger, LoggingArgumentParser
+except Exception:
+    from constants import configure_logger, LoggingArgumentParser
 
 
 def parse_fasta_stats(fasta_file):
@@ -43,9 +51,7 @@ def parse_fasta_stats(fasta_file):
 
 
 def process_fasta_directory(input_dir, output_csv):
-    """
-    Processes a directory of FASTA files and writes statistics to a CSV file.
-    """
+    logger = logging.getLogger("PyamilySeq.Group_Sizes")
     results = []
     for filename in os.listdir(input_dir):
         if filename.endswith(".fasta"):
@@ -68,19 +74,27 @@ def process_fasta_directory(input_dir, output_csv):
         writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
         writer.writeheader()
         writer.writerows(results)
+    logger.info("Wrote statistics for %d FASTA files to %s", len(results), output_csv)
 
 
 def main():
-    parser = argparse.ArgumentParser(description="Summarize sequence statistics for a directory of FASTA files.")
+    # Early console-only logger so the parser.description is emitted via logger before argparse prints usage/help.
+    early_logger = configure_logger("PyamilySeq.Group_Sizes", enable_file=False, log_dir=None, verbose=False)
+    parser = LoggingArgumentParser(logger_name="PyamilySeq.Group_Sizes", description="Group-Sizes - A tool to summarise sequence statistics for a directory of FASTA files.")
     parser.add_argument("-input_dir", required=True, help="Directory containing FASTA files.")
     parser.add_argument("-output_csv", required=True, help="Output CSV file to save statistics.")
+    parser.add_argument("--log", action="store_true", dest="log", help="Create a timestamped logfile for this run.")
+    parser.add_argument("--log-dir", dest="log_dir", default=None, help="Directory for logfile (default: same dir as -output_csv).")
 
     args = parser.parse_args()
 
-    # Process the directory of FASTA files
-    print("Processing FASTA files...")
+    out_dir = os.path.abspath(os.path.dirname(args.output_csv)) if args.output_csv else os.getcwd()
+    log_dir = args.log_dir if args.log_dir else out_dir
+    logger = configure_logger("PyamilySeq.Group_Sizes", enable_file=args.log, log_dir=log_dir, verbose=False)
+
+    logger.info("Processing FASTA files in %s", args.input_dir)
     process_fasta_directory(args.input_dir, args.output_csv)
-    print(f"Statistics saved to {args.output_csv}")
+    logger.info("Statistics saved to %s", args.output_csv)
 
 
 if __name__ == "__main__":

PyamilySeq/Group_Splitter.py

@@ -1,6 +1,5 @@
-
-import argparse
 from collections import defaultdict, OrderedDict
+import sys
 
 
 try:
@@ -11,6 +10,7 @@ except (ModuleNotFoundError, ImportError, NameError, TypeError) as error:
     from utils import *
 
 def run_cd_hit(options, input_file, clustering_output, clustering_mode):
+    logger = logging.getLogger("PyamilySeq.Group_Splitter")
     cdhit_command = [
         clustering_mode,
         '-i', input_file,
@@ -24,12 +24,17 @@ def run_cd_hit(options, input_file, clustering_output, clustering_mode):
         '-sc', "1",
         '-sf', "1"
     ]
-    if options.verbose == True:
-        subprocess.run(cdhit_command)
-    else:
-        subprocess.run(cdhit_command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+    logger.debug("Group-Splitter CD-HIT command: %s", " ".join(cdhit_command))
+    try:
+        if options.verbose:
+            subprocess.run(cdhit_command)
+        else:
+            subprocess.run(cdhit_command, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+        logger.info("CD-HIT completed for %s", input_file)
+    except Exception:
+        logger.exception("Error running CD-HIT for %s", input_file)
+
 
-#'@profile
 def calculate_new_rep_seq(cluster_data, length_weight=1.0, identity_weight=1.0):
     total_length = sum(entry['length'] for entry in cluster_data)
     avg_length = total_length / len(cluster_data)
@@ -75,7 +80,27 @@ def read_fasta_groups(options, groups_to_use):
     else:
         affix = '_dna.fasta'
 
-    combined_groups_fasta = options.input_directory + '/Gene_Groups_Output/combined_group_sequences' + affix
+    # Ensure we look for the combined file that includes the requested group level (e.g. "99")
+    # groups_to_use[1] contains the numeric group level when using ('groups', <num>)
+    group_level = str(groups_to_use[1]) if groups_to_use and len(groups_to_use) > 1 else ''
+    combined_groups_fasta = os.path.join(options.input_directory, 'Gene_Groups_Output',
+                                         f"combined_group_sequences_{group_level}{affix}")
+
+    # Defensive check: combined_group_sequences_* file must exist (was created by PyamilySeq with -write_groups)
+    if not os.path.exists(combined_groups_fasta):
+        logger = logging.getLogger("PyamilySeq.Group_Splitter")
+        logger.error("Required combined group sequences file not found: %s", combined_groups_fasta)
+        logger.error("This usually means the upstream PyamilySeq run did not include the -write_groups and -write_individual_groups options.")
+        # Helpful debug info: list contents of Gene_Groups_Output if available
+        parent_dir = os.path.dirname(combined_groups_fasta)
+        if os.path.isdir(parent_dir):
+            try:
+                files = os.listdir(parent_dir)
+                logger.debug("Files in %s: %s", parent_dir, ", ".join(sorted(files)) if files else "(none)")
+            except Exception as e:
+                logger.debug("Could not list %s: %s", parent_dir, e)
+        # Stop further processing
+        sys.exit(1)
 
     if groups_to_use[0] == 'ids':
         selected_group_ids = [int(g.strip()) for g in groups_to_use[1].split(',')]
@@ -334,13 +359,16 @@ def separate_groups(options, clustering_mode, groups_to_use):
 
 
 def main():
-    parser = argparse.ArgumentParser(description='PyamilySeq ' + PyamilySeq_Version + ': Group-Splitter - A tool to split multi-copy gene groups identified by PyamilySeq.')
+    # Early console-only logger so parser.description is emitted via logger before argparse prints usage/help.
+    early_logger = configure_logger("PyamilySeq.Group_Splitter", enable_file=False, log_dir=None, verbose=False)
+    # Use LoggingArgumentParser so usage/errors are emitted via the configured logger
+    parser = LoggingArgumentParser(logger_name="PyamilySeq.Group_Splitter", description='Group-Splitter - A tool to split multi-copy gene groups identified by PyamilySeq.')
     ### Required Arguments
     required = parser.add_argument_group('Required Parameters')
-    required.add_argument('-input_directory', action='store', dest='input_directory',
+    required.add_argument('-input_dir', action='store', dest='input_directory',
                           help='Provide the directory of a PyamilySeq run.',
                           required=True)
-    required.add_argument('-sequence_type', action='store', dest='sequence_type', default='AA',choices=['AA', 'DNA'],
+    required.add_argument('-seq_type', action='store', dest='sequence_type', default='AA',choices=['AA', 'DNA'],
                           help='Default - AA: Are groups "DNA" or "AA" sequences?',
                           required=True)
     required.add_argument('-genome_num', action='store', dest='genome_num', type=int,
@@ -350,7 +378,7 @@ def main():
 
     ### Regrouping Arguments
     regrouping_params = parser.add_argument_group('Regrouping Parameters')
-    regrouping_params.add_argument('-groups', action="store", dest='groups', type=int, default=None,
+    regrouping_params.add_argument('-groups', action="store", dest='groups', type=int, default=99,
                           help='Default - 99: groups to be split by pangenome grouping (see -group_threshold). '
                                'Provide "-groups 99" to split specific groups.',
                           required=False)
@@ -403,10 +431,14 @@ def main():
                       help="Print out version number and exit")
 
 
+    # Optional file logging flags (must be added before parsing)
+    parser.add_argument("--log", action="store_true", dest="log", help="Create a timestamped logfile for this run.")
+    parser.add_argument("--log-dir", dest="log_dir", default=None, help="Directory for logfile (default: input_directory).")
     options = parser.parse_args()
-    print("Running PyamilySeq: Group-Splitter " + PyamilySeq_Version)
-
-
+    # Compute logfile directory (default to input_directory) and only enable file logging when --log is provided.
+    log_dir = options.log_dir if getattr(options, "log_dir", None) else os.path.abspath(options.input_directory)
+    logger = configure_logger("PyamilySeq.Group_Splitter", enable_file=getattr(options, "log", False), log_dir=log_dir, verbose=options.verbose)
+    logger.info("Running Group-Splitter %s", PyamilySeq_Version)
 
     ###External tool checks:
     ##MAFFT
@@ -416,11 +448,10 @@ def main():
                 print("mafft is installed. Proceeding with alignment.")
         else:
             exit("mafft is not installed. Please install mafft to proceed.")
-    ##CD-HIT
 
+    ##CD-HIT
     if is_tool_installed('cd-hit'):
-        if options.verbose == True:
-            print("cd-hit is installed. Proceeding with clustering.")
+        logger.info("cd-hit is installed. Proceeding with clustering.")
         if options.sequence_type == 'DNA':
             clustering_mode = 'cd-hit-est'
         else:
@@ -434,6 +465,7 @@ def main():
             if options.verbose == True:
                 print("Running CD-HIT in slow mode.")
     else:
+        logger.error("cd-hit is not installed. Please install cd-hit to proceed.")
         exit("cd-hit is not installed. Please install cd-hit to proceed.")
 
     ##Alignment
@@ -451,6 +483,9 @@ def main():
     if not os.path.exists(sub_groups_output):
         os.makedirs(sub_groups_output)
 
+    logger.info("Gene groups output: %s", gene_groups_output)
+    logger.info("Sub groups output: %s", sub_groups_output)
+
     ## Get Summary Stats
     summary_file = os.path.join(options.input_directory, 'summary_statistics.txt')
 
@@ -459,10 +494,9 @@ def main():
     with open(params_out, "w") as outfile:
         for arg, value in vars(options).items():
             outfile.write(f"{arg}: {value}\n")
+    logger.info("Saved parameters to %s", params_out)
 
-
-
-    ## Group Selction - FIX THIS - currently fails if either are not provided
+    ## Group Selection - FIX THIS - currently fails if either are not provided
     if options.groups != None and options.group_ids != None:
         sys.exit('Must provide "-group_ids" or "-groups", not both.')
     elif options.group_ids != None:
@@ -475,12 +509,9 @@ def main():
 
 
     paralog_groups = separate_groups(options, clustering_mode, groups_to_use)
-    ###
-    # Print metrics about paralog groups
-    print(f"Identified {len(paralog_groups)} paralog groups:")
+    logger.info("Identified %d paralog groups", len(paralog_groups))
     for group_id, data in paralog_groups.items():
-        print(f"Group ID: {group_id}, Number of new groups: {data['count']}, Sizes: {data['sizes']}")
-    ###
+        logger.debug("Group %s -> new groups: %s sizes: %s", group_id, data['count'], data['sizes'])
 
 
     # Read summary statistics
@@ -509,8 +540,37 @@ def main():
     # Recalculate each *_core_* value
     for group_id, data in paralog_groups.items():
         group_id = group_id.replace('>Group_', '')
-        original_group = next((f for f in os.listdir(gene_groups_output) if f.endswith(f'_{group_id}.fasta')), None)
-        original_group = int(original_group.split('_')[2])
+        # Find the original group filename in gene_groups_output that:
+        #  - contains the requested group level (options.groups, e.g. '99')
+        #  - corresponds to this subgroup id (group_id)
+        original_group = None
+        for fname in os.listdir(gene_groups_output):
+            if not fname.endswith('.fasta'):
+                continue
+            # Require the filename to include the group level token (e.g., '_99_') to avoid false matches
+            if f"_{options.groups}_" not in fname:
+                continue
+            # Accept filenames that end with _<group_id>.fasta or _<group_id>_dna.fasta/_aa.fasta
+            if fname.endswith(f"_{group_id}.fasta") or fname.endswith(f"_{group_id}_dna.fasta") or fname.endswith(f"_{group_id}_aa.fasta"):
+                original_group = fname
+                break
+        if original_group is None:
+            # fallback: attempt a looser match (preserve previous behavior)
+            for fname in os.listdir(gene_groups_output):
+                if fname.endswith(f"_{group_id}.fasta") or fname.endswith(f"_{group_id}_dna.fasta") or fname.endswith(f"_{group_id}_aa.fasta"):
+                    original_group = fname
+                    break
+        if original_group is None:
+            # If still not found, skip recalculation for this paralog group
+            logger.warning("Could not find original group file for subgroup id %s in %s", group_id, gene_groups_output)
+            continue
+        # Extract the core-group number from the filename (expected at index 2: First_core_99_3_dna.fasta)
+        try:
+            original_group_num = int(original_group.split('_')[2])
+        except Exception:
+            logger.warning("Unexpected filename format for %s; skipping", original_group)
+            continue
+        original_group = original_group_num
         if original_group == 99:
             new_core_99 -= 1
         elif original_group == 95:
@@ -554,7 +614,7 @@ def main():
 
     # Alignment
     if options.align_core != None:
-        print("\n\nProcessing gene group alignment")
+        logger.info("Processing gene group alignment")
         group_directory = options.gene_groups_output
         sub_group_directory = options.sub_groups_output
         genome_list = read_genomes_from_fasta(options.gene_groups_output + '/combined_group_sequences_dna.fasta')

PyamilySeq/{Cluster_Summary.py → Group_Summary.py}

@@ -1,4 +1,3 @@
-import argparse
 from collections import OrderedDict, defaultdict
 
 try:
@@ -10,7 +9,6 @@ except (ModuleNotFoundError, ImportError, NameError, TypeError):
 
 
 def categorise_percentage(percent):
-    """Categorise the percentage of genomes with multicopy genes."""
     categories = {
         (20, 40): "20-40%",
         (40, 60): "40-60%",
@@ -26,12 +24,9 @@ def categorise_percentage(percent):
 
 
 def read_cd_hit_output(clustering_output):
-    """Parse CD-HIT .cluster file and extract clustering information."""
     clusters = OrderedDict()
-
     with open(clustering_output, 'r') as f:
         current_cluster_id = None
-
         for line in f:
             line = line.strip()
             if line.startswith(">Cluster"):
@@ -43,14 +38,12 @@ def read_cd_hit_output(clustering_output):
                     clustered_info = parts[1]
                     length = int(''.join(c for c in clustered_info.split(',')[0] if c.isdigit()))
                     clustered_header = '>' + clustered_info.split('>')[1].split('...')[0]
-
                     if 'at ' in clustered_info and '%' in clustered_info.split('at ')[-1]:
                         percent_identity = extract_identity(clustered_info)
                     elif line.endswith('*'):
                         percent_identity = 100.0
                     else:
                         raise ValueError("Percent identity not found in the string.")
-
                     clusters[current_cluster_id].append({
                         'header': clustered_header,
                         'length': length,
@@ -61,22 +54,17 @@ def read_cd_hit_output(clustering_output):
 
 
 def summarise_clusters(options, clusters, output):
-    """Generate a detailed cluster summary report."""
+    logger = logging.getLogger("PyamilySeq.Group_Summary")
     multicopy_groups = defaultdict(int)  # Counter for clusters with multicopy genes
-
     with open(output, 'w') as out_f:
         out_f.write(
-            "Cluster_ID\tNum_Sequences\tNum_Genomes\tAvg_Length\tLength_Range\tAvg_Identity\tIdentity_Range\tGenomes_With_Multiple_Genes\tMulticopy_Percentage\n"
-        )
-
+            "Cluster_ID\tNum_Sequences\tNum_Genomes\tAvg_Length\tLength_Range\tAvg_Identity\tIdentity_Range\tGenomes_With_Multiple_Genes\tMulticopy_Percentage\n")
         for cluster_id, seqs in clusters.items():
             num_seqs = len(seqs)
             lengths = [seq['length'] for seq in seqs]
             identities = [seq['percent_identity'] for seq in seqs]
-
             avg_length = sum(lengths) / num_seqs if num_seqs > 0 else 0
             length_range = f"{min(lengths)}-{max(lengths)}" if num_seqs > 0 else "N/A"
-
             avg_identity = sum(identities) / num_seqs if num_seqs > 0 else 0
             identity_range = f"{min(identities):.2f}-{max(identities):.2f}" if num_seqs > 0 else "N/A"
 
@@ -90,7 +78,6 @@ def summarise_clusters(options, clusters, output):
             num_genomes_with_multiple_genes = sum(1 for count in genome_to_gene_count.values() if count > 1)
             multicopy_percentage = (num_genomes_with_multiple_genes / options.genome_num) * 100 if options.genome_num > 0 else 0
 
-            # Categorize multicopy percentage
             category = categorise_percentage(multicopy_percentage)
             if category:
                 multicopy_groups[category] += 1
@@ -104,13 +91,14 @@ def summarise_clusters(options, clusters, output):
         # Define order for multicopy statistics output
         category_order = ["20-40%", "40-60%", "60-80%", "80-95%", "95-99%", "99-100%"]
         for category in category_order:
-            print(f"Clusters with multicopy genes in {category} range: {multicopy_groups[category]}")
+            logger.info("Clusters with multicopy genes in %s range: %s", category, multicopy_groups[category])
 
 
 def main():
-    """Main function to parse arguments and process clustering files."""
-    parser = argparse.ArgumentParser(
-        description='PyamilySeq ' + PyamilySeq_Version + ': Cluster-Summary - A tool to summarise CD-HIT clustering files.')
+    # Initial logger setup before parsing arguments (use same logger name as summarise_clusters)
+    early_logger = configure_logger("PyamilySeq.Group_Summary", enable_file=False, log_dir=None, verbose=False)
+    # Use the LoggingArgumentParser so usage/help/error messages are emitted via the same logger
+    parser = LoggingArgumentParser(logger_name="PyamilySeq.Group_Summary", description="Running Group-Summary - A tool to summarise CD-HIT clustering files.")
 
     # Required Arguments
     required = parser.add_argument_group('Required Parameters')
@@ -132,9 +120,18 @@ def main():
     misc.add_argument("-v", "--version", action="version",
                       version=f"PyamilySeq: Group-Summary version {PyamilySeq_Version} - Exiting",
                       help="Print out version number and exit")
+    # Add optional logging flags
+    parser.add_argument("--log", action="store_true", dest="log", help="Create a timestamped logfile for this run.")
+    parser.add_argument("--log-dir", dest="log_dir", default=None, help="Directory for logfile (default: output_dir or input file dir).")
 
     options = parser.parse_args()
-    print("Running PyamilySeq " + PyamilySeq_Version + ": Group-Summary ")
+
+    # Setup logger once we know output paths/options
+    # after we resolve output_path / options.output_dir:
+    resolved_log_dir = options.log_dir if getattr(options, "log_dir", None) else (os.path.abspath(options.output_dir) if getattr(options, "output_dir", None) else os.getcwd())
+    logger = configure_logger("PyamilySeq.Group_Summary", enable_file=getattr(options, "log", False), log_dir=resolved_log_dir, verbose=options.verbose)
+    if options.verbose:
+        logger.debug("Options: %s", vars(options))
 
     # File handling
     options.input_cluster = fix_path(options.input_cluster)
@@ -152,6 +149,7 @@ def main():
     # Process clusters and generate summary
     clusters = read_cd_hit_output(options.input_cluster)
     summarise_clusters(options, clusters, output_file_path)
+    logger.info("Summary written to %s", output_file_path)
 
 
 if __name__ == "__main__":