Merge branch 'main' into develop

Jenkinsfile

@@ -38,10 +38,9 @@ pipeline {
             parallel {
                 stage ("git.reslate.systems") {
                     when {
-                        not {
-                            tag '*.*.*'
-                        }
+                        branch '**/main'
                     }
+
                     environment {
                         CREDS = credentials('username-password-rs-git')
                     }

README.md

@@ -9,7 +9,7 @@ This program is simply a command-line interface for [autoBIGS.engine](https://py
 This CLI is capable of exactly what [autoBIGS.engine](https://pypi.org/project/autoBIGS.engine) is capable of:
 - Import multiple whole genome FASTA files
 - Fetch the available BIGSdb databases that is currently live and available
-- Fetch the available BIGSdb database schemas for a given MLST database
+- Fetch the available BIGSdb database schemes for a given MLST database
 - Retrieve exact/non-exact MLST allele variant IDs based off a sequence
 - Retrieve MLST sequence type IDs based off a sequence
 - Inexact matches are annotated with an asterisk (\*)
@@ -17,7 +17,7 @@ This CLI is capable of exactly what [autoBIGS.engine](https://pypi.org/project/a
 
 ## Planned Features for CLI
 - Specifications of multi-threading capacity
-- Session authentication for updated database schemas (as required by both PubMLST and Institut Pasteur)
+- Session authentication for updated database schemes (as required by both PubMLST and Institut Pasteur)
 
 Please refer to [autoBIGS.engine](https://pypi.org/project/autoBIGS.engine) for more planned features.
 
@@ -33,11 +33,11 @@ This CLI can be installed with `pip`. Please ensure [pip is installed](https://p
 
 ### Example
 
-Let's say you have a fasta called `seq.fasta` which contains several sequences. You know all sequences in `seq.fasta` are Bordetella pertussis sequences, and you know you have the sequences for the necessary targets of your schema in each of them. You want to retrieve MLST profiles for all of them. This can be done by:
+Let's say you have a fasta called `seq.fasta` which contains several sequences. You know all sequences in `seq.fasta` are Bordetella pertussis sequences, and you know you have the sequences for the necessary targets of your scheme in each of them. You want to retrieve MLST profiles for all of them. This can be done by:
 
 1. Running `autobigs info -l` to list all available `seqdef` databases and find the database associated with Bordetella (you should see one called `pubmlst_bordetella_seqdef`).
 
-2. Then, run `autobigs info -lschema pubmlst_bordetella_seqdef` to get the available typing schemas and their associated IDs. In this example, let's assume we want a normal MLST scheme. In this case, we would pay attention to the number next to `MLST` (it should be `3`).
+2. Then, run `autobigs info -lscheme pubmlst_bordetella_seqdef` to get the available typing schemes and their associated IDs. In this example, let's assume we want a normal MLST scheme. In this case, we would pay attention to the number next to `MLST` (it should be `3`).
 
 3. Then, run `autobigs st -h` and familiarize yourself with the parameters needed for sequence typing.
 

pyproject.toml

@@ -8,7 +8,7 @@ dynamic = ["version"]
 readme = "README.md"
 license = {text = "GPL-3.0-or-later"}
 dependencies = [
-    "autoBIGS-engine==0.12.*"
+    "autoBIGS-engine==0.13.*"
 ]
 requires-python = ">=3.12"
 description = "A CLI tool to rapidly fetch fetch MLST profiles given sequences for various diseases."

src/autobigs/cli/info.py

@@ -6,7 +6,9 @@ from autobigs.engine.analysis.bigsdb import BIGSdbIndex
 
 def setup_parser(parser: ArgumentParser):
     parser.description = "Fetches the latest BIGSdb MLST database definitions."
-    parser.add_argument(
+    
+    retrieve_group = parser.add_mutually_exclusive_group(required=True)
+    retrieve_group.add_argument(
         "--retrieve-bigsdbs", "-l",
         action="store_true",
         dest="list_dbs",
@@ -15,15 +17,15 @@ def setup_parser(parser: ArgumentParser):
         help="Lists all known BIGSdb MLST databases (fetched from known APIs and cached)."
     )
 
-    parser.add_argument(
-        "--retrieve-bigsdb-schemas", "-lschemas",
+    retrieve_group.add_argument(
+        "--retrieve-bigsdb-schemes", "-lschemes",
         nargs="+",
         action="extend",
-        dest="list_bigsdb_schemas",
+        dest="list_bigsdb_schemes",
         required=False,
         default=[],
         type=str,
-        help="Lists the known schema IDs for a given BIGSdb sequence definition database name. The name, and then the ID of the schema is given."
+        help="Lists the known scheme IDs for a given BIGSdb sequence definition database name. The name, and then the ID of the scheme is given."
     )
 
     parser.add_argument(
@@ -39,10 +41,6 @@ def setup_parser(parser: ArgumentParser):
 
 async def run(args: Namespace):
     async with BIGSdbIndex() as bigsdb_index:
-        if args.list_dbs and len(args.list_bigsdb_schemas) > 0:
-            print("Cannot specify both database listing and schema listing, please choose one!")
-            exit(1)
-
         if args.list_dbs:
             known_seqdef_dbs = await bigsdb_index.get_known_seqdef_dbs(force=False)
             sorted_seqdef_dbs = [(name, source) for name, source in sorted(known_seqdef_dbs.items())]
@@ -55,21 +53,18 @@ async def run(args: Namespace):
                     writer.writerows(sorted_seqdef_dbs)
                     print("\nDatabase output written to {0}".format(args.csv_output))
 
-        for bigsdb_schema_name in args.list_bigsdb_schemas:
-            schemas = await bigsdb_index.get_schemas_for_seqdefdb(bigsdb_schema_name)
-            sorted_schemas = [(name, id) for name, id in sorted(schemas.items())]
-            print("The following are the known schemas for \"{0}\", and their associated IDs:".format(bigsdb_schema_name))
-            print("\n".join(["{0}: {1}".format(name, id) for name, id in sorted_schemas]))
-            if args.csv_output:
-                with open(args.csv_output, "w") as csv_out_handle:
-                    writer = csv.writer(csv_out_handle)
-                    writer.writerow(("Name", "ID"))
-                    writer.writerows(sorted_schemas)
-                    print("\nSchema list output written to {0}".format(args.csv_output))
-
-        if not (args.list_dbs or len(args.list_bigsdb_schemas) > 0):
-            print("Nothing to do. Try specifying \"-l\" for a list of known databases, or \"-h\" for more information.")
-            exit(1)
+        csv_scheme_rows = []
+        for bigsdb_scheme_name in args.list_bigsdb_schemes:
+            schemes = await bigsdb_index.get_schemes_for_seqdefdb(bigsdb_scheme_name)
+            csv_scheme_rows.extend([(name, id, bigsdb_scheme_name) for name, id in sorted(schemes.items())])
+            print("The following are the known schemes for \"{0}\", and their associated IDs:".format(bigsdb_scheme_name))
+            print("\n".join(["{0}: {1}".format(name, id) for name, id, database in csv_scheme_rows]))
+        if args.csv_output:
+            with open(args.csv_output, "w") as csv_out_handle:
+                writer = csv.writer(csv_out_handle)
+                writer.writerow(("Name", "ID", "Database Name"))
+                writer.writerows(csv_scheme_rows)
+            print("\nscheme list output written to {0}".format(args.csv_output))
 
 def run_asynchronously(args: Namespace):
     asyncio.run(run(args))

src/autobigs/cli/program.py

@@ -7,7 +7,7 @@ from autobigs.cli import info, st
 from autobigs.cli.meta import get_module_base_name
 import importlib
 
-root_parser = argparse.ArgumentParser(epilog='Use "%(prog)s info -h" to learn how to get available MLST databases, and their available schemas.'
+root_parser = argparse.ArgumentParser(epilog='Use "%(prog)s info -h" to learn how to get available MLST databases, and their available schemes.'
                                       + ' Once that is done, use "%(prog)s st -h" to learn how to retrieve MLST profiles.'
                                       )
 subparsers = root_parser.add_subparsers(required=False)
@@ -20,17 +20,17 @@ root_parser.add_argument(
     action="store_true",
     default=False,
     required=False,
-    help="Displays the autoBIGS.CLI version, and the autoBIGS.Engine version."
+    help="Displays the autoBIGS.cli version, and the autoBIGS.Engine version."
 )
 
 
 def run():
     args = root_parser.parse_args()
     if args.version:
-        print(f'autoBIGS.CLI is running version {
-              metadata.version("autoBIGS-cli")}.')
-        print(f'autoBIGS.Engine is running version {
-              metadata.version("autoBIGS-engine")}.')
+        print(f'autoBIGS.cli is running version {
+              metadata.version("autobigs-cli")}.')
+        print(f'autoBIGS.engine is running version {
+              metadata.version("autobigs-engine")}.')
     if hasattr(args, "run"):
         args.run(args)
     elif not args.version:

src/autobigs/cli/st.py

@@ -4,8 +4,7 @@ import asyncio
 import datetime
 from autobigs.engine.writing import write_mlst_profiles_as_csv
 from autobigs.engine.reading import read_multiple_fastas
-from autobigs.engine.analysis.bigsdb import BIGSdbIndex
-
+from autobigs.engine.analysis.bigsdb import BIGSdbIndex, BIGSdbMLSTProfiler
 
 def setup_parser(parser: ArgumentParser):
     parser.description = "Returns MLST exact profile matches."
@@ -23,10 +22,18 @@ def setup_parser(parser: ArgumentParser):
         help="The BIGSdb seqdef database to use for typing."
     )
 
-    parser.add_argument(
-        "schema",
+    scheme_group = parser.add_mutually_exclusive_group()
+
+    scheme_group.add_argument(
+        "--scheme-id", "-sid",
         type=int,
-        help="The BIGSdb seqdef database schema ID (integer) to use for typing."
+        help="The BIGSdb seqdef database scheme ID (integer) to use for typing."
+    )
+
+    scheme_group.add_argument(
+        "--scheme-name", "-sn",
+        type=str,
+        help="The BIGSdb seqdef database scheme name (string) to use for typing. If neither this argument, nor the ID equivalent is defined, a scheme ID with name \"MLST\" will be used."
     )
 
     parser.add_argument(
@@ -49,12 +56,18 @@ def setup_parser(parser: ArgumentParser):
 async def run(args: Namespace):
     async with BIGSdbIndex() as bigsdb_index:
         gen_strings = read_multiple_fastas(args.fastas)
-        async with await bigsdb_index.build_profiler_from_seqdefdb(False, args.seqdefdb, args.schema) as mlst_profiler:
+        scheme_id_lookup = await bigsdb_index.get_schemes_for_seqdefdb(args.seqdefdb)
+        scheme_id = args.scheme_id or args.scheme_name or (scheme_id_lookup)["MLST"]
+        scheme_name_lookup = {value: key for key, value in scheme_id_lookup.items()}
+
+        async with await bigsdb_index.build_profiler_from_seqdefdb(False, args.seqdefdb, scheme_id) as mlst_profiler:
+            if not isinstance(mlst_profiler, BIGSdbMLSTProfiler):
+                raise TypeError("MLST profiler type invalid")
             mlst_profiles = mlst_profiler.profile_multiple_strings(gen_strings, args.stop_on_fail)
             failed = await write_mlst_profiles_as_csv(mlst_profiles, args.out)
             if len(failed) > 0:
                 print(f"A total of {len(failed)} IDs failed (no profile found):\n{"\n".join(failed)}")
-            print(f"Completed fetching MLSTs for {len(args.fastas)} sequences.")
+            print(f"Completed fetching from {args.seqdefdb} for {scheme_name_lookup[scheme_id]}s for {len(args.fastas)} sequences.")
 
 def run_asynchronously(args):
     asyncio.run(run(args))