# HG changeset patch
# User dcouvin
# Date 1638927967 0
# Node ID a16d245332d6e5b8e6dd1acc9a6e3ad665485c91
Uploaded
diff -r 000000000000 -r a16d245332d6 ResFinder.xml
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ResFinder.xml Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,76 @@
+
+ identifies acquired antimicrobial resistance genes in total or partial sequenced isolates of bacteria.
+
+
+ tabulate
+ biopython
+ cgecore
+ gitpython
+ python-dateutil
+ git
+ gcg
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+10.1093/jac/dkaa345
+
+
+
diff -r 000000000000 -r a16d245332d6 resfinder/.gitignore
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/.gitignore Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,10 @@
+.DS_Store
+blast-2.2.26
+*.gz
+*.pyc
+__pycache__
+running_test
+cge/kma
+db_pointfinder
+db_resfinder
+._*
diff -r 000000000000 -r a16d245332d6 resfinder/.gitmodules
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/.gitmodules Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,3 @@
+[submodule "cge/blaster"]
+ path = cge/blaster
+ url = https://RolfKaas@bitbucket.org/genomicepidemiology/blaster.git
diff -r 000000000000 -r a16d245332d6 resfinder/README.md
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/README.md Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,364 @@
+ResFinder documentation
+=============
+
+ResFinder identifies acquired antimicrobial resistance genes in total or partial
+sequenced isolates of bacteria.
+
+## Content of the repository
+1. run_resfinder.py - Use this script to run ResFinder
+2. tests/data - Contains fasta and fastq data for testing. More information in the "Test data" section
+3. scripts/ - All scripts in this directory is unsupported but has been uploaded as they may be useful
+4. cge/ - ResFinder code
+5. dockerfile - Used to build ResFinder docker image (See Docker section near the end)
+
+## Installation
+The installation described here will first install the actual ResFinder software,
+then the dependencies, and finally the databases. A more detailed breakdown of the
+installation is provided below:
+
+1. Install ResFinder tool
+2. Install python modules
+3. Install BLAST (optional)
+4. install KMA (optional)
+5. Download ResFinder database
+6. Download PointFinder database
+7. Index databases with KMA (if installed)
+8. Test installation
+
+A small script has been written to automate this process. It is available from the
+scripts directory and is named install_resfinder.sh. It is very simple and might
+not work in all environments. It is only meant as a supplement and no support will
+be provided for any scripts in this directory. However, specific suggestions (with code)
+for improvement is very welcome.
+
+### ResFinder tool
+Setting up ResFinder script and database
+```bash
+# Go to wanted location for resfinder
+cd /path/to/some/dir
+
+# Clone the latest version and enter the resfinder directory
+git clone https://git@bitbucket.org/genomicepidemiology/resfinder.git
+cd resfinder
+
+```
+
+### Dependencies:
+Depending on how you plan to run ResFinder BLAST and KMA can be optional.
+BLAST is used to analyse assemblies (ie. FASTA files).
+KMA is used to analyse read data (ie. FASTQ files).
+
+#### Python modules: Tabulate, BioPython, CGECore and Python-Git
+To install the needed python modules you can use pip
+```bash
+pip3 install tabulate biopython cgecore gitpython python-dateutil
+```
+For more information visit the respective website
+```url
+https://bitbucket.org/astanin/python-tabulate
+https://biopython.org
+https://bitbucket.org/genomicepidemiology/cge_core_module
+https://gitpython.readthedocs.io/en/stable/index.html
+```
+
+#### BLAST (optional)
+If you don't want to specify the path of blastn every time you run
+ResFinder, make sure that blastn is in you PATH.
+
+Blastn can be obtained from:
+```url
+ftp://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/LATEST/
+```
+
+#### KMA (optional)
+The instructions here will install KMA in the default location ResFinder uses. KMA
+can be installed in another location but the path to KMA will then need to be
+specified every time you run ResFinder unless you add the kma program to your PATH.
+```bash
+# Go to the directoy in which you installed the ResFinder tool
+cd /path/to/some/dir/resfinder
+cd cge
+git clone https://bitbucket.org/genomicepidemiology/kma.git
+cd kma && make
+```
+
+### Databases
+This section describes how to install the databases at the ResFinder default locations.
+The database locations can be changed, but must then be specified to ResFinder at run time.
+
+#### ResFinder database
+```bash
+# Go to the directoy in which you installed the ResFinder tool
+cd /path/to/some/dir/resfinder
+git clone https://git@bitbucket.org/genomicepidemiology/resfinder_db.git db_resfinder
+```
+
+#### PointFinder database
+```bash
+# Go to the directoy in which you installed the ResFinder tool
+cd /path/to/some/dir/resfinder
+git clone https://git@bitbucket.org/genomicepidemiology/pointfinder_db.git db_pointfinder
+```
+
+#### Indexing databases with KMA
+If you have KMA installed you either need to have the kma_index in your PATH or
+you need to provide the path to kma_index to INSTALL.py
+
+**NOTE**: The documentation given here describes the procedure for the ResFinder database, but the procedure is identical for the PointFinder database.
+**PointFinder database documentation**: [https://bitbucket.org/genomicepidemiology/pointfinder_db]
+
+##### a) Run INSTALL.py in interactive mode
+```bash
+# Go to the database directory
+cd path/to/db_resfinder
+python3 INSTALL.py
+```
+If kma_index was found in your path a lot of indexing information will be
+printed to your terminal, and will end with the word "done".
+
+If kma_index wasn't found you will recieve the following output:
+```bash
+KMA index program, kma_index, does not exist or is not executable
+Please input path to executable kma_index program or choose one of the options below:
+ 1. Install KMA using make, index db, then remove KMA.
+ 2. Exit
+```
+You can now write the path to kma_index and finish with or you can
+enter "1" or "2" and finish with .
+
+If "1" is chosen, the script will attempt to install kma in your systems
+default temporary location. If the installation is successful it will proceed
+to index your database, when finished it will delete the kma installation again.
+
+##### b) Run INSTALL.py in non_interactive mode
+```bash
+# Go to the database directory
+cd path/to/resfinder_db
+python3 INSTALL.py /path/to/kma_index non_interactive
+```
+The path to kma_index can be omitted if it exists in PATH or if the script
+should attempt to do an automatic temporary installation of KMA.
+
+##### c) Index database manually (not recommended)
+It is possible to index the databases manually, but is generally not recommended
+as it is more prone to error. If you choose to do so, be aware of the naming of
+the indexed files.
+
+This is an example of how to index the ResFinder database files:
+```bash
+# Go to the resfinder database directory
+cd path/to/resfinder_db
+# create indexing directory
+mkdir kma_indexing
+# Index files using kma_index
+kma_index -i db_resfinder/fusidicacid.fsa -o db_resfinder/kma_indexing/fusidicacid
+kma_index -i db_resfinder/phenicol.fsa -o db_resfinder/kma_indexing/phenicol
+kma_index -i db_resfinder/glycopeptide.fsa -o db_resfinder/kma_indexing/glycopeptide
+kma_index -i db_resfinder/trimethoprim.fsa -o db_resfinder/kma_indexing/trimethoprim
+kma_index -i db_resfinder/oxazolidinone.fsa -o db_resfinder/kma_indexing/oxazolidinone
+kma_index -i db_resfinder/tetracycline.fsa -o db_resfinder/kma_indexing/tetracycline
+kma_index -i db_resfinder/quinolone.fsa -o db_resfinder/kma_indexing/quinolone
+kma_index -i db_resfinder/nitroimidazole.fsa -o db_resfinder/kma_indexing/nitroimidazole
+kma_index -i db_resfinder/fosfomycin.fsa -o db_resfinder/kma_indexing/fosfomycin
+kma_index -i db_resfinder/aminoglycoside.fsa -o db_resfinder/kma_indexing/aminoglycoside
+kma_index -i db_resfinder/macrolide.fsa -o db_resfinder/kma_indexing/macrolide
+kma_index -i db_resfinder/sulphonamide.fsa -o db_resfinder/kma_indexing/sulphonamide
+kma_index -i db_resfinder/rifampicin.fsa -o db_resfinder/kma_indexing/rifampicin
+kma_index -i db_resfinder/colistin.fsa -o db_resfinder/kma_indexing/colistin
+kma_index -i db_resfinder/beta-lactam.fsa -o db_resfinder/kma_indexing/beta-lactam
+# Go to the pointfinder database directory
+cd path/to/pointfinder_db
+# Index files using kma_index
+kma_index -i db_pointfinder/campylobacter/*.fsa -o db_pointfinder/campylobacter/campylobacter
+kma_index -i db_pointfinder/escherichia_coli/*.fsa -o db_pointfinder/escherichia_coli/escherichia_coli
+kma_index -i db_pointfinder/enterococcus_faecalis/*.fsa -o db_pointfinder/enterococcus_faecalis/enterococcus_faecalis
+kma_index -i db_pointfinder/enterococcus_faecium/*.fsa -o db_pointfinder/enterococcus_faecium/enterococcus_faecium
+kma_index -i db_pointfinder/neisseria_gonorrhoeae/*.fsa -o db_pointfinder/neisseria_gonorrhoeae/neisseria_gonorrhoeae
+kma_index -i db_pointfinder/salmonella/*.fsa -o db_pointfinder/salmonella/salmonella
+kma_index -i db_pointfinder/mycobacterium_tuberculosis/*.fsa -o db_pointfinder/mycobacterium_tuberculosis/mycobacterium_tuberculosis
+```
+
+### Test ResFinder intallation
+(This will not function with the docker installation.)
+If you did not install BLAST, test 1 and 3 will fail. If you did not install KMA, test 2
+and 4 will fail.
+The 4 tests will in total take approximately take 5-60 seconds, depending on your system.
+```bash
+# Go to the directoy in which you installed the ResFinder tool
+cd /path/to/some/dir/resfinder
+
+# For seeing the unittest options for running the tests
+python3 tests/functional_tests.py -h
+
+# In case you need to point blastn or kma, or the resfinder or the pointfinder databases as they are not in the places indicated above, see the optional arguments for the test by:
+python3 tests/functional_tests.py -res_help
+
+#Which outputs:
+usage: functional_tests.py [-res_help] [-db_res DB_PATH_RES] [-b BLAST_PATH]
+ [-k KMA_PATH] [-db_point DB_PATH_POINT]
+
+Options:
+ -res_help, --resfinder_help
+ -db_res DB_PATH_RES, --db_path_res DB_PATH_RES
+ Path to the databases for ResFinder
+ -b BLAST_PATH, --blastPath BLAST_PATH
+ Path to blastn
+ -k KMA_PATH, --kmaPath KMA_PATH
+ Path to KMA
+ -db_point DB_PATH_POINT, --db_path_point DB_PATH_POINT
+ Path to the databases for PointFinder
+
+# Run tests
+python3 tests/functional_tests.py
+
+# Output from successful tests
+....
+----------------------------------------------------------------------
+Ran 4 tests in 8.263s
+
+OK
+```
+
+### Test data
+Test data can be found in the sub-dierectory /tests/data
+
+## Usage
+
+You can run resfinder command line using python3.
+
+**NOTE**: Species should be entered with their full scientific names (e.g. "escherichia coli"), using quotation marks, not case sensitive.
+ An attempt has been made to capture some deviations like "ecoli" and "e.coli", but it is far from all deviations that will be captured.
+
+
+```bash
+
+# Example of running resfinder
+python3 run_resfinder.py -o path/to/outdir -s "Escherichia coli" -l 0.6 -t 0.8 --acquired --point -ifq test_isolate_01_*
+
+# The program can be invoked with the -h option
+usage: run_resfinder.py [-h] [-ifa INPUTFASTA]
+ [-ifq INPUTFASTQ [INPUTFASTQ ...]] [-scripts SCRIPTS]
+ [-o OUT_PATH] [-b BLAST_PATH] [-k KMA_PATH]
+ [-s SPECIES] [-l MIN_COV] [-t THRESHOLD]
+ [-db_res DB_PATH_RES] [-db_res_kma DB_PATH_RES_KMA]
+ [-d DATABASES] [-acq] [-c] [-db_point DB_PATH_POINT]
+ [-g SPECIFIC_GENE [SPECIFIC_GENE ...]] [-u]
+
+optional arguments:
+ -h, --help show this help message and exit
+ -ifa INPUTFASTA, --inputfasta INPUTFASTA
+ Input fasta file.
+ -ifq INPUTFASTQ [INPUTFASTQ ...], --inputfastq INPUTFASTQ [INPUTFASTQ ...]
+ Input fastq file(s). Assumed to be single-end fastq if
+ only one file is provided, and assumed to be paired-
+ end data if two files are provided.
+ -o OUT_PATH, --outputPath OUT_PATH
+ All output will be stored in this directory.
+ -b BLAST_PATH, --blastPath BLAST_PATH
+ Path to blastn
+ -k KMA_PATH, --kmaPath KMA_PATH
+ Path to kma
+ -s SPECIES, --species SPECIES
+ Species in the sample
+ Available species: Campylobacter, Campylobacter jejuni, Campylobacter coli,
+ Enterococcus faecalis, Enterococcus faecium, Escherichia coli, Helicobacter pylori,
+ Klebsiella, Mycobacterium tuberculosis, Neisseria gonorrhoeae,
+ Plasmodium falciparum, Salmonella, Salmonella enterica, Staphylococcus aureus
+ -s "Other" can be used for metagenomic samples or samples with unknown species.
+ -db_res DB_PATH_RES, --db_path_res DB_PATH_RES
+ Path to the databases for ResFinder
+ -db_res_kma DB_PATH_RES_KMA, --db_path_res_kma DB_PATH_RES_KMA
+ Path to the ResFinder databases indexed with KMA.
+ Defaults to the 'kma_indexing' directory inside the
+ given database directory.
+ -d DATABASES, --databases DATABASES
+ Databases chosen to search in - if none is specified
+ all is used
+ -acq, --acquired Run resfinder for acquired resistance genes
+ -l MIN_COV, --min_cov MIN_COV
+ Minimum (breadth-of) coverage of ResFinder
+ Valid interval: 0.00-1.00
+ -t THRESHOLD, --threshold THRESHOLD
+ Threshold for identity of ResFinder
+ Valid interval: 0.00-1.00
+ -c, --point Run pointfinder for chromosomal mutations
+ -db_point DB_PATH_POINT, --db_path_point DB_PATH_POINT
+ Path to the databases for PointFinder
+ -g SPECIFIC_GENE [SPECIFIC_GENE ...]
+ Specify genes existing in the database to search for -
+ if none is specified all genes are included in the
+ search.
+ -u, --unknown_mut Show all mutations found even if in unknown to the
+ resistance database
+ -l_p MIN_COV_POINT, --min_cov_point MIN_COV_POINT
+ Minimum (breadth-of) coverage of Pointfinder. If None
+ is selected, the minimum coverage of ResFinder will be
+ used.
+ -t_p THRESHOLD_POINT, --threshold_point THRESHOLD_POINT
+ Threshold for identity of Pointfinder. If None is
+ selected, the minimum coverage of ResFinder will be
+ used.
+
+```
+
+### Web-server
+
+A webserver implementing the methods is available at the [CGE
+website](http://www.genomicepidemiology.org/) and can be found here:
+https://cge.cbs.dtu.dk/services/ResFinder/
+
+### Install ResFinder with Docker
+If you would like to build a docker image with ResFinder, make sure you have cloned the ResFinder directory as well as installed and indexed the databases: `db_pointfinder` and `db_resfinder`. Then run the following commands:
+```bash
+# Go to ResFinder directory
+cd path/to/resfinder
+# Build docker image with name resfinder
+docker build -t resfinder .
+```
+When running the docker make sure to mount the `db_resfinder` and the `db_pointfinder` with the flag -v, as shown in the examples below.
+
+You can test the installation by running the docker with the test files:
+```bash
+cd path/to/resfinder/
+mkdir results
+
+# Run with raw data (this command mounts the results to the local directory "results")
+docker run --rm -it -v $(pwd)/db_resfinder/:/usr/src/db_resfinder -v $(pwd)/results/:/usr/src/results resfinder -ifq /usr/src/tests/data/test_isolate_01_1.fq /usr/src/tests/data/test_isolate_01_2.fq -acq -db_res /usr/src/db_resfinder -o /usr/src/results
+
+# Run with assembled data (this command mounts the results to the local directory "results")
+docker run --rm -it -v $(pwd)/db_resfinder/:/usr/src/db_resfinder -v $(pwd)/results/:/usr/src/results resfinder -ifa /usr/src/tests/data/test_isolate_01.fa -acq -db_res /usr/src/db_resfinder -o /usr/src/results
+```
+
+Citation
+=======
+
+When using the method please cite:
+
+ResFinder 4.0 for predictions of phenotypes from genotypes.
+Bortolaia V, Kaas RF, Ruppe E, Roberts MC, Schwarz S, Cattoir V, Philippon A, Allesoe RL, Rebelo AR, Florensa AR, Fagelhauer L,
+Chakraborty T, Neumann B, Werner G, Bender JK, Stingl K, Nguyen M, Coppens J, Xavier BB, Malhotra-Kumar S, Westh H, Pinholt M,
+Anjum MF, Duggett NA, Kempf I, Nyk�senoja S, Olkkola S, Wieczorek K, Amaro A, Clemente L, Mossong J, Losch S, Ragimbeau C, Lund O, Aarestrup FM.
+Journal of Antimicrobial Chemotherapy. 2020 Aug 11.
+PMID: 32780112 doi: 10.1093/jac/dkaa345
+[Epub ahead of print]
+
+References
+=======
+
+1. Camacho C, Coulouris G, Avagyan V, Ma N, Papadopoulos J, Bealer K, Madden TL. BLAST+: architecture and applications. BMC Bioinformatics 2009; 10:421.
+2. Clausen PTLC, Aarestrup FM, Lund O. Rapid and precise alignment of raw reads against redundant databases with KMA. BMC Bioinformatics 2018; 19:307.
+
+License
+=======
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
\ No newline at end of file
diff -r 000000000000 -r a16d245332d6 resfinder/amr_abbreviations.md
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/amr_abbreviations.md Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,131 @@
+# Antimicrobial Abbreviations
+
+In ResFinder results where antimicrobial abbreviations are used, it will use the [EUCAST System for Antimicrobial Abbreviations](https://www.eucast.org/fileadmin/src/media/PDFs/EUCAST_files/Disk_test_documents/Disk_abbreviations/EUCAST_system_for_antimicrobial_abbreviations.pdf).
+
+## Abbreviations
+
+| Antimicrobial | Abbreviation |
+|-------------------------------|--------------|
+| Amikacin | AMI |
+| Amoxicillin | AMO |
+| Amoxicillin-clavulanate | AMC |
+| Ampicillin | AMP |
+| Ampicillin-sulbactam | AMS |
+| Avibactam | AVI |
+| Azithromycin | AZI |
+| Aztreonam | AZT |
+| Benzylpenicillin | BEN |
+| Cefaclor | CCL |
+| Cefadroxil | CDR |
+| Cefalexin | CLE |
+| Cefazolin | CZO |
+| Cefepime | CEP |
+| Cefixime | CIX |
+| Cefotaxime | CTA |
+| Cefoxitin | CXI |
+| Cefpodoxime | CPO |
+| Ceftaroline | CTL |
+| Ceftazidime | CTZ |
+| Ceftazidime-avibactam | CTV |
+| Ceftibuten | CTI |
+| Ceftiofur | CTF |
+| Ceftobiprole | CTO |
+| Ceftolozane-tazobactam | CTT |
+| Ceftriaxone | CTR |
+| Cefuroxime | CUR |
+| Chloramphenicol | CHL |
+| Ciprofloxacin | CIP |
+| Clarithromycin | CLA |
+| Clavulanic acid | CLV |
+| Clindamycin | CLI |
+| Cloxacillin | CLO |
+| Colistin | COL |
+| Dalbavancin | DAL |
+| Daptomycin | DAP |
+| Dicloxacillin | DIC |
+| Difloxacin | DIF |
+| Doripenem | DOR |
+| Doxycyline | DOX |
+| Enrofloxacin | ENR |
+| Ertapenem | ERT |
+| Erythromycin | ERY |
+| Florfenicol | FLO |
+| Flucloxacillin | FLU |
+| Fosfomycin | FOS |
+| Fusidic acid | FUS |
+| Gamithromycin | GAM |
+| Gentamicin | GEN |
+| Gepotidacin | GEP |
+| Imipenem | IMI |
+| Kanamycin | KAN |
+| Levofloxacin | LEV |
+| Linezolid | LIN |
+| Marbofloxacin | MAR |
+| Mecillinam | MEC |
+| Meropenem | MER |
+| Methicillin | MEH |
+| Metronidazole | MET |
+| Minocycline | MIN |
+| Moxifloxacin | MOX |
+| Mupirocin | MUP |
+| Nalidixic acid | NAL |
+| Netilmicin | NET |
+| Nitrofurantoin | NIT |
+| Norfloxacin | NOR |
+| Novobiocin | NOV |
+| Ofloxacin | OFL |
+| Orbifloxacin | ORB |
+| Oritavancin | ORI |
+| Oxacillin | OXA |
+| Oxytetracycline | OXY |
+| Pefloxacin | PEF |
+| Phenethicillin | PHN |
+| Phenoxymethypenicillin | PHE |
+| Pipemidic acid | PIE |
+| Piperacillin | PIP |
+| Piperacillin-tazobactam | PIT |
+| Pirlimycin | PIR |
+| Pradofloxacin | PRA |
+| Quinupristin-dalfopristin | QUD |
+| Relabactam | REL |
+| Retapamulin | RET |
+| Rifampicin | RIF |
+| Roxithromycin | ROX |
+| Spectinomycin | SPE |
+| Spectinomycin | SPE |
+| Streptomycin | STR |
+| Streptomycin | STR |
+| Sulbactam | SUL |
+| Sulbactam | SUL |
+| Sulfamethoxazole | SME |
+| Sulfamethoxazole | SME |
+| Sulfathiazole | STH |
+| Sulfathiazole | STH |
+| Sulfisoxazole | SIS |
+| Sulfisoxazole | SIS |
+| Tazobactam | TAZ |
+| Tazobactam | TAZ |
+| Tedizolid | TED |
+| Tedizolid | TED |
+| Teicoplanin | TEI |
+| Teicoplanin | TEI |
+| Telavancin | TEL |
+| Telavancin | TEL |
+| Telithromycin | TEH |
+| Telithromycin | TEH |
+| Tetracycline | TET |
+| Tetracycline | TET |
+| Tiamulin | TIA |
+| Tiamulin | TIA |
+| Ticarcillin | TIC |
+| Ticarcillin-clavulanate | TIL |
+| Tigecycline | TIG |
+| Tildipirosin | TID |
+| Tilmicosin | TIM |
+| Tobramycin | TOB |
+| Trimethoprim | TRI |
+| Trimethoprim-sulfamethoxazole | TRS |
+| Tulathromycin | TUL |
+| Vaborbactam | VAB |
+| Valnemulin | VAL |
+| Vancomycin | VAN |
diff -r 000000000000 -r a16d245332d6 resfinder/cge/__init__.py
diff -r 000000000000 -r a16d245332d6 resfinder/cge/__pycache__/__init__.cpython-36.pyc
Binary file resfinder/cge/__pycache__/__init__.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/__pycache__/__init__.cpython-38.pyc
Binary file resfinder/cge/__pycache__/__init__.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/__pycache__/pointfinder.cpython-36.pyc
Binary file resfinder/cge/__pycache__/pointfinder.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/__pycache__/pointfinder.cpython-38.pyc
Binary file resfinder/cge/__pycache__/pointfinder.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/__pycache__/resfinder.cpython-36.pyc
Binary file resfinder/cge/__pycache__/resfinder.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/__pycache__/resfinder.cpython-38.pyc
Binary file resfinder/cge/__pycache__/resfinder.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/__pycache__/standardize_results.cpython-38.pyc
Binary file resfinder/cge/__pycache__/standardize_results.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/__pycache__/exceptions.cpython-38.pyc
Binary file resfinder/cge/out/__pycache__/exceptions.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/__pycache__/parserdict.cpython-38.pyc
Binary file resfinder/cge/out/__pycache__/parserdict.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/__pycache__/result.cpython-38.pyc
Binary file resfinder/cge/out/__pycache__/result.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/__pycache__/valueparsers.cpython-38.pyc
Binary file resfinder/cge/out/__pycache__/valueparsers.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/beone.json
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/beone.json Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,95 @@
+{
+"software_result": {
+ "type": "software_result",
+ "key": "string*",
+ "software_name": "string*",
+ "software_version": "string*",
+ "software_branch": "string",
+ "software_commit": "string",
+ "software_log": "string",
+ "run_id": "string",
+ "run_date": "date",
+ "databases": "dict database:class",
+ "genes": "dict gene:class",
+ "seq_variations": "dict seq_variation:class",
+ "phenotypes": "dict phenotype:class"
+ },
+"database": {
+ "type": "database",
+ "key": "string*",
+ "database_name": "string*",
+ "database_version": "string",
+ "database_branch": "string",
+ "database_commit": "string",
+ "checksum_sha256": "char64"
+ },
+"gene": {
+ "type": "gene",
+ "key": "string*",
+ "name": "string*",
+ "identity": "percentage",
+ "alignment_length": "integer",
+ "ref_gene_lenght": "integer",
+ "coverage": "percentage",
+ "depth": "float",
+ "ref_id": "string*",
+ "ref_acc": "string",
+ "ref_start_pos": "integer",
+ "ref_end_pos": "integer",
+ "query_id": "string",
+ "query_start_pos": "integer",
+ "query_end_pos": "integer",
+ "phenotypes": "array phenotype.key",
+ "ref_database": "database.key"
+ },
+"seq_region": {
+ "type": "seq_region",
+ "key": "string*",
+ "name": "string*",
+ "gene": "bool_or_unknown",
+ "identity": "percentage",
+ "alignment_length": "integer",
+ "ref_gene_lenght": "integer",
+ "coverage": "percentage",
+ "depth": "float",
+ "ref_id": "string*",
+ "ref_acc": "string",
+ "ref_start_pos": "integer",
+ "ref_end_pos": "integer",
+ "query_id": "string",
+ "query_start_pos": "integer",
+ "query_end_pos": "integer",
+ "phenotypes": "array phenotype.key",
+ "ref_database": "database.key"
+ },
+"seq_variation": {
+ "type": "seq_variation",
+ "key": "string*",
+ "ref_id": "string*",
+ "seq_var": "seq_var_string",
+ "codon_change": "codon_change_string",
+ "ref_codon": "nucleotides",
+ "var_codon": "nucleotides",
+ "ref_aa": "aminoacid_1_char",
+ "var_aa": "aminoacid_1_char",
+ "ref_start_pos": "integer",
+ "ref_end_pos": "integer",
+ "substitution": "bool",
+ "insertion": "bool",
+ "deletion": "bool",
+ "ref_database": "database.key",
+ "genes": "array gene.key",
+ "phenotypes": "array phenotype.key"
+ },
+"phenotype": {
+ "type": "phenotype",
+ "key": "string*",
+ "category": "vocabulary*",
+ "amr_classes": "array vocabulary",
+ "amr_resistance": "vocabulary",
+ "amr_resistant": "bool_or_unknown",
+ "genes": "array gene.key",
+ "seq_variations": "array seq_variation.key",
+ "ref_database": "database.key"
+ }
+}
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/exceptions.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/exceptions.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+
+
+class CGECoreOut(Exception):
+ """ Root for all submodule out exceptions in the cgecore module.
+ Only used to enable "except" of all exceptions from submodule.
+ Never raised.
+ """
+ pass
+
+
+class CGECoreOutTypeError(CGECoreOut):
+ """ Raised when the 'type' specified is not defined in the json
+ definition, if it is missing.
+ """
+ def __init__(self, message, *args):
+ self.message = message
+ # allow users initialize misc. arguments as any other builtin Error
+ super(CGECoreOutTypeError, self).__init__(message, *args)
+
+
+class CGECoreOutInputError(CGECoreOut):
+ """ Raised when some of the data stored in a Result object did not pass
+ validation based on the JSON definition.
+ """
+ def __init__(self, message, errors, *args):
+ self.message = message
+ self.errors = errors
+ # allow users initialize misc. arguments as any other builtin Error
+ super(CGECoreOutInputError, self).__init__(message, errors, *args)
+
+
+class CGECoreOutTranslateError(CGECoreOut):
+ """ Raised when keys for the given type of Translate object does not match"
+ a key in the JSON definition
+ """
+ def __init__(self, message, *args):
+ self.message = message
+ # allow users initialize misc. arguments as any other builtin Error
+ super(CGECoreOutTranslateError, self).__init__(message, *args)
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/parserdict.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/parserdict.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,30 @@
+#!/usr/bin/env python3
+
+from .valueparsers import ValueParsers
+
+
+class ParserDict(dict):
+
+ def __init__(self, input_parser=None):
+
+ if(input_parser is None):
+ parser_class = ValueParsers
+ else:
+ parser_class = input_parser.__class__
+
+ val_parser_list = self.get_method_names(parser_class)
+
+ for parser in val_parser_list:
+ if(parser.startswith("parse_")):
+ parse_key = parser[6:]
+ self[parse_key] = getattr(parser_class, parser)
+ else:
+ raise SyntaxError(("A function in the {} class did "
+ "not start with 'parse_'. Function is "
+ "named: {}"
+ .format(parser_class.__name__, parser)))
+
+ @staticmethod
+ def get_method_names(cls):
+ return [func for func in dir(cls) if(callable(getattr(cls, func))
+ and not func.startswith("__"))]
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/result.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/result.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+
+import json
+import os.path
+
+from .parserdict import ParserDict
+from .exceptions import CGECoreOutTypeError, CGECoreOutInputError
+
+
+class Result(dict):
+
+ BEONE_JSON_FILE = "beone.json"
+ beone_json_path = os.path.join(os.path.dirname(__file__), BEONE_JSON_FILE)
+
+ def __init__(self, result_type=None, fmt_file=beone_json_path,
+ parsers=None, **kwargs):
+
+ self.defs = {}
+ with open(fmt_file, "r") as fh:
+ self.defs = json.load(fh)
+
+ if(parsers is None):
+ self.val_parsers = ParserDict()
+ else:
+ self.val_parsers = ParserDict(parsers)
+
+ type = self._get_type(result_type, **kwargs)
+ self._set_type(type)
+ self._parser = ResultParser(result_def=self.defs[type])
+ for d in self._parser.arrays:
+ self[d] = []
+ for d in self._parser.dicts:
+ self[d] = {}
+
+ self.add(**kwargs)
+
+ def _set_type(self, type):
+ if(type in self.defs):
+ self["type"] = type
+ else:
+ raise CGECoreOutTypeError(
+ "Unknown result type given. Type given: {}. Type must be one "
+ "of:\n{}".format(type, list(self.defs.keys())))
+
+ def _get_type(self, result_type=None, **kwargs):
+ type = None
+ if(result_type is not None):
+ type = result_type
+ if(kwargs):
+ kw_type = kwargs.get("type", None)
+ if(type is not None and kw_type is not None and type != kw_type):
+ raise CGECoreOutTypeError(
+ "Type was given as argument to method call and as an "
+ "attribute in the given dictionary, but they did not "
+ "match. {} (method) != {} (dict)".format(type, kw_type))
+ elif(kw_type is not None):
+ type = kw_type
+ if(type is None):
+ raise CGECoreOutTypeError(
+ "The class format requires a 'type' attribute. The given "
+ "dictionary contained the following attributes: {}"
+ .format(kwargs.keys()))
+ return type
+
+ def add(self, **kwargs):
+ for key, val in kwargs.items():
+ if(val is None):
+ continue
+ self[key] = val
+
+ def add_class(self, cl, result_type=None, **kwargs):
+ type = self._get_type(result_type, **kwargs)
+ res = Result(result_type=type, **kwargs)
+ if(cl in self._parser.arrays):
+ self[cl].append(res)
+ elif(cl in self._parser.dicts):
+ self[cl][res["key"]] = res
+ else:
+ self[cl] = res
+
+ def modify_class(self, cl, result_type=None, **kwargs):
+ type = self._get_type(result_type, **kwargs)
+ res = Result(result_type=type, **kwargs)
+ res_id = res["ref_id"].replace("_", ";;")
+ for key, value in res.items():
+ if key not in self[cl][res_id]:
+ self[cl][res_id][key] = value
+ elif self[cl][res_id][key] != value:
+ self[cl][res_id][key] = \
+ self[cl][res_id][key] \
+ + ", " + value
+ else:
+ pass
+
+ def check_results(self, errors=None):
+ self.errors = {}
+
+ for key, val in self.items():
+ if(key == "type"):
+ continue
+ # The key is not defined, and is not checked
+ elif(key not in self.defs[self["type"]]):
+ continue
+ self._check_result(key, val, self.errors)
+
+ # errors is not None if called recursively
+ if(errors is not None):
+ errors[self["key"]] = self.errors
+ return None
+ # errors is None if it is the first/root call
+ elif(errors is None and self._no_errors(self.errors)):
+ return None
+ else:
+ raise CGECoreOutInputError(
+ "Some input data did not pass validation, please consult the "
+ "Dictionary of ERRORS:{}".format(self.errors),
+ self.errors)
+
+ def _check_result(self, key, val, errors, index=None):
+ # Remember Result is a dict object and therefore this test should
+ # be before the dict test.
+ if(isinstance(val, Result)):
+ val.check_results(errors)
+ elif(isinstance(val, dict)):
+ self._check_result_dict(key, val, errors)
+ elif(isinstance(val, list)):
+ self._check_result_list(key, val, errors)
+ else:
+ self._check_result_val(key, val, errors, index)
+
+ def del_entries_by_values(self, values):
+ values = tuple(values)
+ deleted_keys = []
+ for key, entry_val in self.items():
+ if(key == "type"):
+ continue
+ if(entry_val in values):
+ deleted_keys.append(key)
+ for key in deleted_keys:
+ del self[key]
+ return deleted_keys
+
+ def _no_errors(self, errors):
+ no_errors = True
+
+ for key, val in errors.items():
+
+ if(isinstance(val, dict)):
+ no_errors = self._no_errors(val)
+ if(no_errors is False):
+ return False
+
+ elif(val is not None):
+ return False
+
+ return no_errors
+
+ def _check_result_val(self, key, val, errors, index=None):
+ val_type = self._parser[key]
+
+ if(val_type.endswith("*")):
+ val_type = val_type[:-1]
+
+ val_error = self.val_parsers[val_type](val)
+
+ if(val_error):
+ if(index is not None):
+ val_error = "{}:{} ".format(index, val_error)
+ errors[key] = val_error
+
+ def _check_result_dict(self, result_key, result_dict, errors):
+ errors[result_key] = {}
+ for key, val in result_dict.items():
+ self._check_result(key, val, errors[result_key])
+
+ def _check_result_list(self, result_key, result_list, errors):
+ errors[result_key] = {}
+ for i, val in enumerate(result_list):
+ self._check_result(result_key, val, errors[result_key], index=i)
+
+
+class ResultParser(dict):
+ """"""
+ def __init__(self, result_def):
+ self.classes = set()
+ self.arrays = {}
+ self.dicts = {}
+
+ for key, val_def_str in result_def.items():
+ val_def, *sub_def = val_def_str.split(" ")
+ if(sub_def and val_def == "dict"):
+ self.dicts[key] = sub_def[0]
+ self[key] = sub_def[0]
+ elif(sub_def and val_def == "array"):
+ self.arrays[key] = sub_def[0]
+ self[key] = sub_def[0]
+ else:
+ self[key] = val_def
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/template.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/template.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,18 @@
+#!/usr/bin/env python3
+
+from result import Result
+from exceptions import CGECoreOutTypeError
+
+
+class CGEOutTemplate(dict):
+
+ def __init__(self, template):
+ if(template not in Result.beone_defs):
+ raise CGECoreOutTypeError(
+ "Unknown template given. Template given: {}. Template must be"
+ " one of:\n{}"
+ .format(template, list(Result.beone_defs.keys())))
+
+ for key in Result.beone_defs.keys():
+ self[key] = None
+ self["type"] = template
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/test.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/test.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,78 @@
+#!/usr/bin/env python3
+
+import json
+import os.path
+
+from result import Result
+from exceptions import CGECoreOutTypeError, CGECoreOutInputError
+from template import CGEOutTemplate
+from translate import Translate
+
+
+try:
+ CGEOutTemplate("nonsense")
+except CGECoreOutTypeError:
+ print("Caught expected template error.")
+
+soft_dict = CGEOutTemplate("software_result")
+soft_dict["software_name"] = "ResFinder"
+soft_dict["key"] = "soft_dict key"
+soft_dict["version"] = "3.2.0"
+
+soft_result = Result(**soft_dict)
+
+test_gene = {
+ "type": "gene",
+ "key": "some_gene_key",
+ "name": "gen_name",
+ "identity": "187",
+ "alignment_length": "800",
+ "ref_gene_lenght": "800",
+ "coverage": "89",
+ "ref_id": "some_ref_id"
+}
+
+soft_result.add_class(cl="genes", **test_gene)
+
+test_dict = {
+ "type": "software_result",
+ "software_name": "ResFinder",
+ "software_version": "4.0",
+ "run_date": "20200214",
+ "key": "software_key"
+}
+
+result = Result(result_type="software_result", **test_dict)
+result.add_class(cl="genes", **test_gene)
+
+test_trans_table = {
+ "primary": "key",
+ "gene": "name",
+ "id": "identity",
+ "alignment": "alignment_length",
+ "gene_lenght": "ref_gene_lenght",
+ "cov": "coverage"
+}
+
+translator = Translate("gene", test_trans_table)
+
+test_gene2 = {
+ "primary": "some_gene_key2",
+ "gene": "gen_name2",
+ "id": "97",
+ "alignment": "800",
+ "gene_lenght": "800",
+ "cov": "99"
+}
+
+result.add_class(cl="genes", result_type="gene",
+ **translator.translate(test_gene2))
+
+try:
+ result.check_results()
+ soft_result.check_results()
+except CGECoreOutInputError as e:
+ print("Error dict:\n{}".format(e.errors))
+
+print(json.dumps(result))
+print(json.dumps(soft_result))
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/translate.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/translate.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+
+from result import Result
+from exceptions import CGECoreOutTypeError, CGECoreOutTranslateError
+
+
+class Translate():
+
+ def __init__(self, type, transl_table):
+ self.transl_table = transl_table
+ self.type = type
+
+ if(type not in Result.beone_defs):
+ raise CGECoreOutTypeError(
+ "Unknown type given to Translate object. type given: {}. "
+ "type must be one of:\n{}"
+ .format(type, list(Result.beone_defs.keys())))
+
+ self._check_translation_keys()
+
+ def translate(self, source_dict):
+ dest_dict = {}
+ for key, val in source_dict.items():
+ dest_key = self.transl_table.get(key, None)
+ if(dest_key is not None and val is not None):
+ dest_dict[dest_key] = val
+ return dest_dict
+
+ def _check_translation_keys(self):
+ for key, val in self.transl_table.items():
+ if(val not in Result.beone_defs[self.type]):
+ raise CGECoreOutTranslateError(
+ "Value in the translation table given was not found in the"
+ " definition of the given type. Type given: {}. Value not "
+ "found: {}. Possible values for the given type: {}"
+ .format(self.type, self.key,
+ list(self.transl_table.keys())))
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/util/__pycache__/generator.cpython-36.pyc
Binary file resfinder/cge/out/util/__pycache__/generator.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/util/__pycache__/generator.cpython-38.pyc
Binary file resfinder/cge/out/util/__pycache__/generator.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/util/convert.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/util/convert.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+
+from ..result import Result
+
+
+class Convert():
+ """ """
+
+ @staticmethod
+ def toCSVTable(result_list):
+ """"""
+ out = ""
+ if(not result_list):
+ return out
+
+ # Get all headers
+ headers = set()
+ for result in result_list:
+ headers.update(result.keys())
+
+ headers.remove("key")
+ headers = list(headers)
+
+ out = "\t".join(headers)
+ out = "key\t{}".format(out)
+
+ for result in result_list:
+ entry = [str(result["key"])]
+ for header in headers:
+ val = result.get(header, "NaN")
+ entry.append(str(val))
+ entry_str = "\t".join(entry)
+ out = "{}\n{}".format(out, entry_str)
+
+ return out
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/util/generator.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/util/generator.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+
+from git import Repo
+from git.exc import InvalidGitRepositoryError
+from datetime import datetime, timezone
+
+from ..result import Result
+
+
+class Generator():
+ """ """
+
+ @staticmethod
+ def init_software_result(name, gitdir):
+ """"""
+ version, commit = Generator.get_version_commit(gitdir)
+ date = datetime.now(timezone.utc).date().isoformat()
+
+ result_dict = {
+ "type": "software_result",
+ "software_name": name,
+ "software_version": version,
+ "software_commit": commit,
+ "run_date": date,
+ "key": "{}-{}".format(name, version)
+ }
+ return Result(**result_dict)
+
+ @staticmethod
+ def get_version_commit(gitdir):
+ try:
+ repo = Repo(gitdir)
+ except InvalidGitRepositoryError:
+ return ("unknown", "unknown")
+
+ com2tag = {}
+ for tag in repo.tags:
+ com2tag[tag.commit.hexsha] = str(tag)
+
+ version = com2tag.get(repo.commit().hexsha, repo.commit().hexsha[:7])
+
+ return (version, repo.commit().hexsha)
diff -r 000000000000 -r a16d245332d6 resfinder/cge/out/valueparsers.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/out/valueparsers.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+
+import dateutil.parser
+
+
+class ValueParsers():
+
+ def parse_char64(val):
+ val = str(val)
+ if(len(val) != 64):
+ return ("This field expects a string of lenght 64 but the lenght "
+ "of the string is {}. The string is: {}"
+ .format(len(val), val))
+
+ def parse_date(val):
+ try:
+ # If the date is just a year it might be an integer (ex. 2018)
+ dateutil.parser.isoparse(str(val))
+ except ValueError:
+ return ("Date format not recognised. Date format must adhere to "
+ "the ISO 8601 format (YYYY-MM-DD). Provided value was: {}"
+ .format(val))
+
+ def parse_integer(val):
+ try:
+ val = int(float(val))
+ except ValueError:
+ return "Value must be an integer. Value was: {}".format(val)
+
+ def parse_percentage(val):
+ try:
+ val = float(val)
+ except ValueError:
+ return "Value must be a number. Value was: {}".format(val)
+ if(val < 0 or val > 100):
+ return ("Percentage value must be between 0 and 100. The value "
+ "was: {}".format(val))
+
+ def parse_string(val):
+ try:
+ val = str(val)
+ except ValueError:
+ return "Value could not be converted to a string."
+
+ def parse_float(val):
+ try:
+ val = float(val)
+ except TypeError:
+ return "Value must be a float. Value was: {}".format(val)
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/__init__.py
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/__pycache__/__init__.cpython-36.pyc
Binary file resfinder/cge/output/__pycache__/__init__.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/__pycache__/__init__.cpython-38.pyc
Binary file resfinder/cge/output/__pycache__/__init__.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/__pycache__/exceptions.cpython-36.pyc
Binary file resfinder/cge/output/__pycache__/exceptions.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/__pycache__/exceptions.cpython-38.pyc
Binary file resfinder/cge/output/__pycache__/exceptions.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/__pycache__/orderedset.cpython-36.pyc
Binary file resfinder/cge/output/__pycache__/orderedset.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/__pycache__/orderedset.cpython-38.pyc
Binary file resfinder/cge/output/__pycache__/orderedset.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/__pycache__/table.cpython-36.pyc
Binary file resfinder/cge/output/__pycache__/table.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/__pycache__/table.cpython-38.pyc
Binary file resfinder/cge/output/__pycache__/table.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/exceptions.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/output/exceptions.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,17 @@
+#!/usr/bin/env python3
+
+
+class DuplicateKeyError(Exception):
+ """ Raise when adding the same key to a dict twice."""
+ def __init__(self, message, *args):
+ self.message = message
+ # allow users initialize misc. arguments as any other builtin Error
+ super(DuplicateKeyError, self).__init__(message, *args)
+
+
+class LockedObjectError(Exception):
+ """ Raise when attempting to alter a locked object."""
+ def __init__(self, message, *args):
+ self.message = message
+ # allow users initialize misc. arguments as any other builtin Error
+ super(LockedObjectError, self).__init__(message, *args)
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/orderedset.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/output/orderedset.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# Copyright 2015 Sander
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+import collections
+
+class OrderedSet(collections.MutableSet):
+
+ def __init__(self, iterable=None):
+ self.end = end = []
+ end += [None, end, end] # sentinel node for doubly linked list
+ self.map = {} # key --> [key, prev, next]
+ if iterable is not None:
+ self |= iterable
+
+ def __len__(self):
+ return len(self.map)
+
+ def __contains__(self, key):
+ return key in self.map
+
+ def add(self, key):
+ if key not in self.map:
+ end = self.end
+ curr = end[1]
+ curr[2] = end[1] = self.map[key] = [key, curr, end]
+
+ def discard(self, key):
+ if key in self.map:
+ key, prev, next = self.map.pop(key)
+ prev[2] = next
+ next[1] = prev
+
+ def __iter__(self):
+ end = self.end
+ curr = end[2]
+ while curr is not end:
+ yield curr[0]
+ curr = curr[2]
+
+ def __reversed__(self):
+ end = self.end
+ curr = end[1]
+ while curr is not end:
+ yield curr[0]
+ curr = curr[1]
+
+ def pop(self, last=True):
+ if not self:
+ raise KeyError('set is empty')
+ key = self.end[1][0] if last else self.end[2][0]
+ self.discard(key)
+ return key
+
+ def __repr__(self):
+ if not self:
+ return '%s()' % (self.__class__.__name__,)
+ return '%s(%r)' % (self.__class__.__name__, list(self))
+
+ def __eq__(self, other):
+ if isinstance(other, OrderedSet):
+ return len(self) == len(other) and list(self) == list(other)
+ return set(self) == set(other)
+
+
+if __name__ == '__main__':
+ s = OrderedSet('abracadaba')
+ t = OrderedSet('simsalabim')
+ print(s | t)
+ print(s & t)
+ print(s - t)
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/table.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/output/table.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,498 @@
+#!/usr/bin/env python3
+from .orderedset import OrderedSet
+from .exceptions import DuplicateKeyError
+from .exceptions import LockedObjectError
+
+
+class TableResults(dict):
+ """
+ The hit table is created empty.
+ """
+ def __init__(self, software, version, run_date, run_cmd, id):
+ self.software = software
+ self.version = version
+ self.run_date = run_date
+ self.run_cmd = run_cmd
+ self.id = id
+
+ self.long = {}
+ self.medium = {}
+ self.short = {}
+ self.databases = {}
+
+ def add_database(self, id, version):
+ self.databases[id] = version
+
+ def add_table(self, table_name, copy=False):
+ """
+ TODO: Implement copy argument
+ """
+ if(isinstance(table_name, Table)):
+ name = table_name.name
+ else:
+ name = table_name
+
+ if(self.long.get(name, False)):
+ raise DuplicateKeyError("All table names need to be unique. An "
+ "attempt was made to add a table with a "
+ "name that already exists. The name is:{}."
+ .format(name))
+
+ if(isinstance(table_name, Table)):
+ if(copy):
+ raise NotImplementedError()
+ # self.long[name] = copy.deepcopy(table_name)
+ else:
+ self.long[name] = table_name
+ else:
+ self.long[name] = Table(name)
+
+ def as_txt(self, type, header=True, sep="\t", sort=True, pre_name=""):
+ if(type == "long"):
+ tr = self.long
+ elif(type == "medium"):
+ tr = self.medium
+ elif(type == "short"):
+ tr = self.short
+ else:
+ raise ValueError("as_text method in TableResults class must be "
+ "called with either 'long', 'medium', or "
+ "'short'. It was called with {}".format(type))
+
+ out_str = ""
+
+ for table_name in tr:
+ table_str = tr[table_name].as_txt(header=header, sep=sep, sort=sort)
+ out_str += ("{pre}{name}\n{table}\n"
+ .format(pre=pre_name, name=table_name, table=table_str))
+
+ return out_str
+
+
+ def merge(self, tr2, auto_row_header=False, copy=False):
+ """
+ Merges another table result object into the calling table results
+ instance.
+
+ Table objects with identical names will be merged, as will headers
+ within merged tables.
+
+ The other table is copied with copy.deepcopy so that changes to the
+ merged tables or changes to the other table does not affect each
+ other.
+
+ IMPORTANT: Currently ONLY merges the tables stored in 'self.long'
+ IMPORTANT: Table merge function does not copy the table that gets
+ merged. Thus, a change in the table that gets merged
+ will also occur in the merged table.
+ TODO: Implement the copy argument to create a deepcopy of the
+ merged table instead of just referencing it.
+ """
+ if(copy is True):
+ raise NotImplementedError()
+
+ for table_name in tr2.long:
+ other_tbl = tr2.long[table_name]
+
+ if(table_name not in self.long):
+ self.add_table(table_name)
+ self.long[table_name] = other_tbl
+ continue
+
+ call_tbl = self.long[table_name]
+
+ for row_header in other_tbl:
+ # Get row now as row header might change if a row header
+ # collision occurs.
+ other_row_dict = other_tbl[row_header]
+
+ # Handle row header collisions
+ if(row_header in call_tbl):
+ if(auto_row_header is False):
+ raise DuplicateKeyError(
+ "During merge of two table, row headers were "
+ "found not to be unique across the two tables. "
+ "Row headers needs to be renamed or the merge "
+ "method should be called with "
+ "auto_row_header=True. Note auto row headers will "
+ "become incrementing integers.\n"
+ "Calling table: {}\n"
+ "Other table: {}\n"
+ "Row header: {}\n"
+ .format(call_tbl.name, other_tbl.name, row_header))
+ call_tbl._row_header_count += 1
+ row_header = call_tbl._row_header_count
+
+ call_tbl[row_header] = other_row_dict
+
+
+class Row(dict):
+ """
+ """
+ def __init__(self, table):
+ self.table = table
+ super(Row, self).__init__()
+
+ def __setitem__(self, col_header, col_val):
+ if(not col_header in self.table._headers):
+ if(self.table.lock_headers):
+ raise LockedObjectError("Attempt to add a header via a Row "
+ "insertion to a table, where the "
+ "headers has been locked.\n"
+ "Table: {}\n"
+ "Row header, val: {}, {}\n"
+ "Header: {}\n"
+ .format(self.name, col_header, col_val,
+ header))
+ self.table.add_header(col_header)
+
+ super(Row, self).__setitem__(col_header, col_val)
+
+
+class Table(dict):
+ """
+ Keys of a Table object is considered 'row headers'.
+ The Key can be None in which case the row header will become an
+ increasing integer (starting at 1).
+
+ Values must be lists of length 2. Where the first entry is the name of
+ a column header and the second entry is the value.
+ """
+ NULL_VAL = "NA"
+
+ def __init__(self, name):
+ self.name = name
+ self.lock_headers = False
+
+ self._headers = OrderedSet()
+ self._row_header_count = 0
+ self._sort_key = "row_header"
+ self._sort_list = SortList(container=self)
+ self._iter_count = 0
+
+ def add_header(self, header, exist_ok=True):
+ if(self.lock_headers):
+ raise LockedObjectError("Attempt to add a header to an object "
+ "where the headers has been locked.\n"
+ "Table: {}\n"
+ "Header: {}\n".format(self.name, header))
+
+ if(exist_ok is False and header in self._headers):
+ raise DuplicateKeyError("Attempt to add header that already exists"
+ " to table, but the add_header method was "
+ "called with exist_ok=False.\n"
+ "Table: {}\n"
+ "Header: {}\n".format(self.name, header))
+ self._headers.add(header)
+
+ def add_headers(self, headers, exist_ok=True):
+ for header in headers:
+ self.add_header(header, exist_ok)
+
+ def as_txt(self, header=True, sep="\t", sort=True):
+ """
+ """
+ if(sort):
+ self.set_sort_key(self._sort_key)
+
+ if(header):
+ out_str = ("{sep}{heads}\n"
+ .format(sep=sep, heads=sep.join(self._headers)))
+ else:
+ out_str = ""
+
+ for row in self:
+ row_list = self.get_row_as_list(row, as_txt=True)
+ out_str += ("{}\n".format(sep.join(row_list)))
+
+ return out_str
+
+
+ def extract_column(self, col):
+ """
+ """
+ if(col == "row_header"):
+ return list(self.keys())
+ if(col not in self._headers):
+ raise KeyError("Attempt to extract a column that doesn't exist.\n"
+ "Missing column name: {}\n"
+ "Table name: {}".format(col, self.name))
+ column = []
+ for entry in self._sort_list:
+ row = self[entry._key]
+ column.append(row.get(col, Table.NULL_VAL))
+ return column
+
+ def get_headers(self):
+ """ Returns an OrderedSet """
+ return self._headers
+
+ def get_row_as_list(self, row_header, as_txt=False):
+ if(row_header not in self):
+ raise KeyError("Unable to find the row_header: {}\n"
+ "In Table object named: {}"
+ .format(row_header, self.name))
+
+ if(as_txt):
+ row_list = [str(row_header)]
+ else:
+ row_list = [row_header]
+
+ for col_header in self._headers:
+ if(as_txt):
+ row_list.append(str(
+ self[row_header].get(col_header, Table.NULL_VAL)))
+ else:
+ row_list.append(
+ self[row_header].get(col_header, Table.NULL_VAL))
+
+ return row_list
+
+ def get_sort_list(self):
+ """
+ """
+ if(self._sort_key is None):
+ raise TypeError("The sort key is None. The sort key needs to be "
+ "set before calling the get_sort_list method.\n"
+ "Table: {}".format(self.name))
+ return self._sort_list
+
+ def rename_row(self, old_name, new_name):
+ """
+ """
+ row_dict = self[old_name]
+ del(self[old_name])
+ self._sort_list.remove(old_name)
+ self[new_name] = row_dict
+
+ def set_sort_key(self, key, sort=True):
+ """
+ """
+ if(key not in self._headers and key != "row_header"):
+ raise KeyError("Attempt to set sort_key to a value that is not a "
+ "header.\n"
+ "Key: {}\n"
+ "Available headers: {}\n"
+ "Table name: {}"
+ .format(key, self._headers, self.name))
+
+ self._sort_key = key
+
+ for i, entry in enumerate(self._sort_list):
+ if(self._sort_key == "row_header"):
+ entry._val = entry._key
+ else:
+ row = self[entry._key]
+ entry._val = row.get(self._sort_key, Table.NULL_VAL)
+ self._sort_list[i] = entry
+
+ if(sort is True):
+ self._sort_list.sort()
+
+ def set_sort_list(self, list):
+ """
+ """
+ if(_sort_key is None):
+ raise TypeError("The sort key is None. The sort key needs to be "
+ "set before calling the set_sort_list method.\n"
+ "Table: {}".format(self.name))
+ self._sort_list = list
+
+ def __iter__(self):
+ """
+ """
+ self._iter_count = 0
+ return self
+
+ def __next__(self):
+ """
+ """
+ if(self._iter_count >= len(self)):
+ raise StopIteration
+ entry = self._sort_list[self._iter_count]
+ self._iter_count += 1
+ return entry._key
+
+ def __setitem__(self, row_header=None, col_val=None):
+ """
+ TODO
+ """
+ if(col_val is None):
+ raise TypeError("Column key/value argument must be a dict, list or"
+ " tuple. Value was None.\n"
+ "Table: {}".format(self.name))
+
+ if(row_header is None):
+ row_header = self._row_header_count
+ self._row_header_count += 1
+
+ row_dict = self.get(row_header, Row(table=self))
+
+ # If row is not new. Sort key has been added to the sort list
+ # previously.
+ sort_key_added = True
+ if(not row_dict):
+ # If row is new a sort key needs to be added to the sort list.
+ sort_key_added = False
+ if(self._sort_key == "row_header"):
+ self._sort_list.append(row_header, row_header, ignore_len=True)
+ sort_key_added = True
+
+ # Several values must be added as a dict.
+ if(isinstance(col_val, dict)):
+ for col_name, val in col_val.items():
+ if(col_name not in self._headers):
+ self.add_header(col_name)
+ # Add sort key if needed
+ if(self._sort_key == col_name and sort_key_added is False):
+ self._sort_list.append(row_header, val, ignore_len=True)
+ sort_key_added = True
+ row_dict[col_name] = val
+ # Add sort key if needed
+ if(not sort_key_added):
+ self._sort_list.append(row_header, Table.NULL_VAL,
+ ignore_len=True)
+ return super(Table, self).__setitem__(row_header, row_dict)
+
+ # A single cell value in a table can be added using a list or tuple.
+ if(isinstance(col_val, list) or isinstance(col_val, tuple)):
+ if(len(col_val) == 2):
+ if(col_val[0] not in self._headers):
+ self.add_header(col_val[0])
+ row_dict[col_val[0]] = col_val[1]
+ return super(Table, self).__setitem__(row_header, row_dict)
+ else:
+ raise ValueError("Unexpected number of values. Expected 2. "
+ "Got: {}\n"
+ "Input: {}\n"
+ "Table: {}".format(len(col_val), col_val,
+ self.name))
+
+ raise TypeError("Unexpected type. The value must be of the type Row, "
+ "list, or tuple.\n"
+ "Recieved type: {}\n"
+ "Table: {}\n".format(type(col_name), self.name))
+
+
+class ColumnHeader():
+ def __init__(self, table, header):
+ """
+ """
+ table._col_header_count += 1
+ self._header = header
+ self._index = table._col_header_count
+
+ def __cmp__(self, other):
+ if(not isinstance(other, ColumnHeader)):
+ raise TypeError("A ColumnHeader object cannot be compared to a "
+ "non-ColumnHeader object.\n"
+ "ColumnHeader _header: {} _index: {}\n"
+ "Other object was of type: {}"
+ .format(self._header, self._index, type(other)))
+ return super(ColumnHeader, self._index).__cmp__(other._index)
+
+
+class SortList(list):
+ """
+ Used together with the Table class, as a way to extract rows/data in a
+ specific order defined by objects of the type SortList.
+
+ Programmers are meant to sort this list in the desired order and store
+ it in a Table class object which will then output rows/data in the
+ order defined by the list.
+
+ Implementations details:
+ The SortList object contain SortListEntries containing key variables
+ with unique values which define the order. And value variables which
+ is the 'public' values used to sort on.
+ """
+ def __init__(self, container=None, unique_list=None, val_list=None):
+ self.container = None
+ if(container is not None):
+ self.container = container
+
+ if(unique_list is None and val_list is None):
+ return
+ if(len(unique_list) != len(val_list)):
+ raise IndexError("A SortList object was initiated with two lists "
+ "of different sizes.\n"
+ "len(unique_list) {} != {} len(val_list)"
+ .format(len(unique_list), len(val_list)))
+
+ for i, val in enumerate(val_list):
+ self.append(unique_list[i], val)
+
+ def append(self, key, val, ignore_len=False):
+ entry = SortListEntry(key, val)
+ if(self.container is not None and ignore_len is False):
+ if(len(self.container) != (len(self) + 1)):
+ raise IndexError("Attempt to add an entry to SortList which "
+ "would cause the list to be longer than the "
+ "affiliated SortList container.")
+ return super(SortList, self).append(entry)
+
+ def remove(self, id):
+ """
+ """
+ for i, entry in enumerate(self):
+ if(id == entry._key):
+ del(self[i])
+
+ def __repr__(self):
+ outstr_list = []
+ for entry in self:
+ outstr_list.append("{}\t{}".format(entry._key, entry._val))
+ return "\n".join(outstr_list)
+
+
+class SortListEntry():
+ """
+ """
+ def __init__(self, key, val):
+ self._key = key
+ self._val = val
+
+ def __cmp__(self, other):
+ if(not isinstance(other, SortListEntry)):
+ raise TypeError("A SortListEntry object cannot be compared to a "
+ "non-SortListEntry object.\n"
+ "SortListEntry key: {} val: {}\n"
+ "Other object was of type: {}"
+ .format(self._key, self._val, type(other)))
+
+ sort_val = str(self._val).lower()
+ sort_val_other = str(other._val).lower()
+ return sort_val.__cmp__(sort_val_other)
+
+ def __repr__(self):
+ return "{},{}".format(self._key, self._val)
+
+ def __lt__(self, other):
+ sort_val = str(self._val).lower()
+ sort_val_other = str(other._val).lower()
+ return sort_val.__lt__(sort_val_other)
+
+ def __le__(self, other):
+ sort_val = str(self._val).lower()
+ sort_val_other = str(other._val).lower()
+ return sort_val.__le__(sort_val_other)
+
+ def __gt__(self, other):
+ sort_val = str(self._val).lower()
+ sort_val_other = str(other._val).lower()
+ return sort_val.__gt__(sort_val_other)
+
+ def __ge__(self, other):
+ sort_val = str(self._val).lower()
+ sort_val_other = str(other._val).lower()
+ return sort_val.__ge__(sort_val_other)
+
+ def __eq__(self, other):
+ sort_val = str(self._val).lower()
+ sort_val_other = str(other._val).lower()
+ return sort_val.__eq__(sort_val_other)
+
+ def __ne__(self, other):
+ sort_val = str(self._val).lower()
+ sort_val_other = str(other._val).lower()
+ return sort_val.__ne__(sort_val_other)
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/trash/known_issues.txt
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/output/trash/known_issues.txt Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,17 @@
+* Problem when using __setitem__ in the TableResults object instead of the add_table method:
+tr = TableResults("software X", "6.6.6", "20200128", "runsoft -i arg",
+ "sampleX")
+tr["some table"]
+
+
+* Table merge function should implement the copy argument.
+
+* Table add_table function should implement the copy argument so that the added table will be copied instead of referenced.
+
+* SortList entries does not get updated when the corresponding value in the Table object is changed.
+
+
+REQUIRES ATTENTION SOON:
+ * from testdata Salmonella Agone using raw reads / KMA, results_tab.txt etc. does not report the mdf(A) gene (18% ID), but the Table.as_txt method does.
+ * Test two genes on same contig
+ * cge.phenotype2genotype.feature exists twice also in cge.feature, only one copy should persist
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/trash/output.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/output/trash/output.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+
+
+from .exceptions import DuplicateKeyError
+from .exceptions import LockedObjectError
+
+
+class Write():
+ """
+ """
+
+ def txt_table(tableresult):
+ pass
diff -r 000000000000 -r a16d245332d6 resfinder/cge/output/trash/test.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/output/trash/test.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+import unittest
+from subprocess import PIPE, run
+import os
+import shutil
+import sys
+from collections import namedtuple
+
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+
+from cgecore.cgefinder import CGEFinder
+from cge.resfinder import ResFinder
+from cge.pointfinder import PointFinder
+
+run_test_dir = "running_test"
+working_dir = os.path.dirname(os.path.realpath(__file__))
+
+test_names = ["test1", "test2", "test3", "test4"]
+
+
+class TestFinder(CGEFinder):
+
+ def __init__(results):
+ """
+ Marias minimalistic Finder class
+ """
+ self.results = results
+
+ def resistance_analysis_genes(self):
+ """
+ Running some analysis that yield results appropriate for resistance
+ type results
+ """
+ Gene = namedtuple("Gene",
+ ["name", "length", "aln_ln", "aln_id", "aln_gaps",
+ "name_variant", "acc", "query", "q_start", "q_end",
+ "q_depth", "t_start", "t_end"])
+
+ analysis_results = {
+ "group1": {
+ "gene1": None, "gene2": None},
+ "group2": {
+ "gene3": None},
+ "group3": {},
+ "group4": {
+ "gene1": None}
+ }
+
+ analysis_results["group1"]["gene1"] = Gene(
+ "gene1", 1000, 890, 0.97, 2, "gene1b", "NC_SOMEGENE", "contig12",
+ 24, 1024, 50, 1, 1000)
+ analysis_results["group1"]["gene2"] = Gene(
+ "gene2", 500, 500, 1, 0, None, "NC_SOMEGENE2", "contig3",
+ 24, 1024, None, 1, 500)
+ analysis_results["group2"]["gene3"] = Gene(
+ "gene3", 5000, 4500, 0.85, 10, None, "NC_SOMEGENE3", None,
+ None, None, 50, 1, 5000)
+ analysis_results["group4"]["gene1"] = Gene(
+ "gene1", 1000, 890, 0.97, 2, "gene1b", "NC_SOMEGENE", "contig12",
+ 24, 1024, 49.74, 1, 1000)
+
+ for group in analysis_results:
+ for name, gene in group.items():
+ self.results.add_gene(
+ template_name=gene.name,
+ template_length=gene.length,
+ template_start_pos=gene.t_start,
+ templare_end_pos=gene.t_end,
+ aln_length=gene.aln_ln,
+ aln_identity=gene.aln_id,
+ aln_gaps=gene.aln_gaps,
+ query_id=gene.query,
+ query_start_pos=gene.q_start,
+ query_end_pos=gene.q_end,
+ query_depth=gene.q_depth
+ )
+
+ def resistance_analysis_mutations(self):
+ """
+ Running some analysis that yield results appropriate for resistance
+ type results
+ """
+ pass
+
+ def resistance_analysis_phenotypes(self):
+ """
+ Running some analysis that yield results appropriate for resistance
+ type results
+ """
+ pass
+
+
+class ResFinderRunTest(unittest.TestCase):
+
+ def setUp(self):
+ # Change working dir to test dir
+ os.chdir(working_dir)
+ # Does not allow running two tests in parallel
+ os.makedirs(run_test_dir, exist_ok=False)
+
+ def tearDown(self):
+ shutil.rmtree(run_test_dir)
+
+ def test_create_and_store_results_in_resistance_type(self):
+ """
+ Maria has created a CGE service. The service use the cge_core_module
+ to create a CGEFinder object, then runs some analysis which stores its
+ results using the output module.
+ """
+ # Maria records when the script is being run
+ run_start = time.gmtime(time.time())
+ run_start_cge = ",".join(run_start[0], run_start[1], run_start[2],
+ run_start[3], run_start[4], run_start[5])
+
+ # First she creates a few directories to store her output.
+ test1_dir = run_test_dir + "/" + test_names[0]
+ os.makedirs(test1_dir)
+
+ # Create
+ results = Resistance(date=run_start_cge, name="TestFinder", "0.01", "Fake_ID", dbs)
+ finder = TestFinder()
+ finder.resistance_analysis_genes()
+ finder.resistance_analysis_mutations()
+ finder.resistance_analysis_phenotypes()
+ out_str = results.dump_json()
+ results.dump_json("{}/data.json".format(test1_dir))
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__init__.py
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/__init__.cpython-36.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/__init__.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/__init__.cpython-38.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/__init__.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/abclassdef.cpython-36.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/abclassdef.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/abclassdef.cpython-38.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/abclassdef.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/dbhit.cpython-36.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/dbhit.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/dbhit.cpython-38.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/dbhit.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/feature.cpython-36.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/feature.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/feature.cpython-38.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/feature.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/isolate.cpython-36.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/isolate.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/isolate.cpython-38.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/isolate.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/phenodbpoint.cpython-36.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/phenodbpoint.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/phenodbpoint.cpython-38.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/phenodbpoint.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/phenotype.cpython-36.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/phenotype.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/phenotype.cpython-38.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/phenotype.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/res_profile.cpython-36.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/res_profile.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/res_profile.cpython-38.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/res_profile.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/res_sumtable.cpython-36.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/res_sumtable.cpython-36.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/__pycache__/res_sumtable.cpython-38.pyc
Binary file resfinder/cge/phenotype2genotype/__pycache__/res_sumtable.cpython-38.pyc has changed
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/abclassdef.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/phenotype2genotype/abclassdef.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,24 @@
+#!/usr/bin/env python3
+
+
+class ABClassDefinition(dict):
+ """ A dict mapping antibiotics to classes.
+ """
+ def __init__(self, def_file):
+ with open(def_file, "r") as fh:
+ for line in fh:
+ if(line.startswith("#")):
+ continue
+
+ line = line.rstrip().lower()
+
+ if(not line):
+ continue
+
+ entries = line.split("\t")
+ ab_class = entries[0]
+
+ for antibiotic in entries[1:]:
+ classes = self.get(antibiotic, [])
+ classes.append(ab_class)
+ self[antibiotic] = classes
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/dbhit.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/phenotype2genotype/dbhit.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+
+
+class DBHit(object):
+ """ A DBHit describes an alignment of a feature to a reference/template.
+ The db variable should be used to describe which database the alignment
+ in question was done against. For example 'resfinder'
+
+ The match_category variable stores one of the integers:
+ 1: Match < 100% identity AND match_length < ref_length
+ 2: Match < 100% identity AND match_length == ref_length
+ 3: Match == 100% identity AND match_length == ref_length
+ """
+ def __init__(self, name, identity, match_length, ref_length, start_ref,
+ end_ref, acc, depth=None, db=None):
+ self.name = name
+ self.identity = float(identity)
+ if(match_length == "NA"):
+ self.match_length = None
+ else:
+ self.match_length = int(match_length)
+ self.ref_length = int(ref_length)
+ self.start_ref = int(start_ref)
+ self.end_ref = int(end_ref)
+ self.acc = acc
+ self.depth = depth
+ self.db = db
+
+ if(self.match_length is not None
+ and self.ref_length != self.match_length):
+ self.match_category = 1
+ elif(self.identity < 100.0):
+ self.match_category = 2
+ else:
+ self.match_category = 3
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/feature.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/phenotype2genotype/feature.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,208 @@
+#!/usr/bin/env python3
+
+import argparse
+import os.path
+import re
+import shutil
+from signal import *
+import tempfile
+import sys
+import subprocess
+# import urllib.parse
+from itertools import chain
+
+
+class Feature(object):
+ """ A feature describes a location on a genome/contig.
+ The 'type' variable should be used to describe the type of feature. For
+ example 'gene', 'promoter' etc. It is suggested that features that only
+ describes a part of a gene, promoter etc. is prefixed with "partial_"
+ (e.g. 'partial_gene'). It is also suggested that features describing a
+ part of the genome without anotations/function is named 'region'.
+ """
+ def __init__(self, unique_id, seq_region=None, start=None, hit=None,
+ isolate=None):
+ self.id = unique_id
+ self.unique_id = unique_id
+ self.seq_region = Feature.na2none(seq_region)
+ start = Feature.na2none(start)
+ if(start):
+ self.start = int(start)
+ else:
+ self.start = None
+ self.hit = Feature.na2none(hit)
+ self.isolate = Feature.na2none(isolate)
+
+ @staticmethod
+ def na2none(entry):
+ if(isinstance(entry, str)):
+ if(entry.upper() == "NA"):
+ return None
+ return entry
+
+
+class Gene(Feature):
+ """
+ """
+ def __init__(self, unique_id, seq_region=None, start=None, end=None,
+ hit=None, isolate=None):
+ Feature.__init__(self, unique_id, seq_region, start, hit, isolate)
+ end = Feature.na2none(end)
+ if(end):
+ self.end = int(end)
+ else:
+ self.end = None
+
+
+class ResGene(Gene):
+ """
+ """
+ def __init__(self, unique_id, seq_region=None, start=None, end=None,
+ hit=None, isolate=None, ab_class=None):
+ Gene.__init__(self, unique_id, seq_region, start, end, hit, isolate)
+ self.ab_class = Feature.na2none(ab_class)
+
+
+class Mutation(Gene):
+ """
+ """
+ def __init__(self, unique_id, seq_region=None, pos=None, hit=None,
+ ref_codon=None, mut_codon=None, ref_aa=None,
+ ref_aa_right=None, mut_aa=None, isolate=None, insertion=None,
+ deletion=None, end=None, nuc=False, premature_stop=0,
+ frameshift=None):
+ Gene.__init__(self, unique_id, seq_region, pos, end, hit, isolate)
+ if(pos is not None):
+ self.pos = int(pos)
+ self.ref_codon = Feature.na2none(ref_codon)
+ self.mut_codon = Feature.na2none(mut_codon)
+ self.ref_aa = Feature.na2none(ref_aa)
+ self.ref_aa_right = Feature.na2none(ref_aa_right)
+ self.mut_aa = Feature.na2none(mut_aa)
+ self.nuc = Feature.na2none(nuc)
+ self.insertion = Feature.na2none(insertion)
+ self.deletion = Feature.na2none(deletion)
+ # Indicate how many percent the region was truncated.
+ self.premature_stop = Feature.na2none(premature_stop)
+ self.frameshift = Feature.na2none(frameshift)
+
+ # Create mutation description
+ if(insertion is True and deletion is True):
+ self.set_mut_str_delins()
+ elif(insertion is True):
+ self.set_mut_str_ins()
+ elif(deletion is True):
+ self.set_mut_str_del()
+ else:
+ self.set_mut_str_sub()
+
+ self.mut_string = (
+ "{region}:{mut_str_short}"
+ .format(region=self.seq_region,
+ mut_str_short=self.mut_string_short))
+
+ def set_mut_str_delins(self):
+ # Nucleotide mutation
+ if(self.nuc):
+ # Multiple consecutive deletions (and one or more insertions)
+ if(self.end):
+ self.mut_string_short = (
+ "g.{pos}_{end}delins{mut}"
+ .format(pos=self.pos, end=self.end,
+ mut=self.mut_codon.upper()))
+ # Single deletion (and 1< insertions)
+ else:
+ self.mut_string_short = (
+ "g.{pos}delins{mut}".format(pos=self.pos,
+ mut=self.mut_codon.upper()))
+ # Amino acid mutation
+ else:
+ # Multiple consecutive deletions (and one or more insertions)
+ if(self.end):
+ self.mut_string_short = (
+ "p.{ref}{pos}_{ref_right}{end}delins{mut}"
+ .format(ref=self.ref_aa.upper(), pos=self.pos,
+ ref_right=self.ref_aa_right, end=self.end,
+ mut=self.mut_aa.upper()))
+ # Single deletion (and 1< insertions)
+ else:
+ self.mut_string_short = (
+ "p.{ref}{pos}delins{mut}"
+ .format(ref=self.ref_aa.upper(), pos=self.pos,
+ mut=self.mut_aa.upper()))
+
+ def set_mut_str_ins(self):
+ # Nucleotide mutation
+ if(self.nuc):
+ self.mut_string_short = (
+ "g.{pos}_{end}ins{codon}"
+ .format(pos=self.pos, end=(self.pos + 1),
+ codon=self.mut_codon.upper()))
+ # Amino acid mutation
+ else:
+ self.mut_string_short = (
+ "{ref_left}{pos}_{ref_right}{end}ins{codon}"
+ .format(ref_left=self.ref_aa, pos=self.pos,
+ ref_right=self.ref_aa_right,
+ end=(self.pos + 1), codon=self.mut_aa.upper()))
+
+ def set_mut_str_del(self):
+ # Nucleotide mutation
+ if(self.nuc):
+ # Multiple consecutive deletions
+ if(self.end):
+ self.mut_string_short = (
+ "g.{pos}_{end}del".format(pos=self.pos, end=self.end))
+ # Single deletion
+ else:
+ self.mut_string_short = (
+ "g.{pos}del{codon}".format(pos=self.pos,
+ codon=self.ref_codon.upper()))
+ # Amino acid mutation
+ else:
+ # Multiple consecutive deletions
+ if(self.end):
+ self.mut_string_short = (
+ "p.{ref}{pos}_{ref_right}{end}del"
+ .format(pos=self.pos, end=self.end,
+ ref=self.ref_aa.upper(),
+# ref_right=self.ref_aa_right.upper()))
+ ref_right=self.ref_aa_right))
+
+ # Single deletion
+ else:
+ self.mut_string_short = (
+ "p.{ref}{pos}del".format(pos=self.pos,
+ ref=self.ref_aa.upper()))
+
+ def set_mut_str_sub(self):
+ # Nucleotide mutation
+ if(self.nuc):
+ self.mut_string_short = (
+ "g.{pos}{ref}>{mut}"
+ .format(pos=self.pos, ref=self.ref_codon.upper(),
+ mut=self.mut_codon.upper()))
+ # Amino acid mutation
+ else:
+ self.mut_string_short = (
+ "p.{ref}{pos}{mut}"
+ .format(ref=self.ref_aa.upper(), pos=self.pos,
+ mut=self.mut_aa.upper()))
+
+
+class ResMutation(Mutation):
+ """
+ """
+ def __init__(self, unique_id, seq_region=None, pos=None, hit=None,
+ ref_codon=None, mut_codon=None, ref_aa=None,
+ ref_aa_right=None, mut_aa=None, isolate=None, insertion=None,
+ deletion=None, end=None, nuc=False, premature_stop=False,
+ frameshift=None, ab_class=None):
+ Mutation.__init__(self, unique_id=unique_id, seq_region=seq_region,
+ pos=pos, hit=hit, ref_codon=ref_codon,
+ mut_codon=mut_codon, ref_aa=ref_aa,
+ ref_aa_right=ref_aa_right, mut_aa=mut_aa,
+ isolate=isolate, insertion=insertion,
+ deletion=deletion, end=end, nuc=nuc,
+ premature_stop=premature_stop, frameshift=frameshift)
+ self.ab_class = ab_class
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/isolate.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/phenotype2genotype/isolate.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,418 @@
+#!/usr/bin/env python3
+
+import argparse
+import os.path
+import re
+import shutil
+from signal import *
+import tempfile
+import sys
+import subprocess
+# import urllib.parse
+from itertools import chain
+
+from .feature import Feature, ResGene, Mutation, ResMutation
+from .phenodbpoint import PhenoDBPoint
+from .res_profile import PhenoDB, ResProfile, FeatureGroup
+from .dbhit import DBHit
+
+
+class Isolate(dict):
+ """ An isolate class is a dict of Features.
+ """
+ NO_AB_CLASS = "No class defined"
+
+ def __init__(self, name, species=None):
+ self.name = name
+ self.resprofile = None
+ self.species = None
+ self.feature_classes = {}
+
+ def load_resfinder_tab(self, tabbed_output, phenodb):
+ with open(tabbed_output, "r") as fh:
+ while(True):
+ line = fh.readline()
+ if(not line):
+ break
+
+ line = line.rstrip()
+ if(not line):
+ continue
+
+ db_name = line
+ second_line = fh.readline().rstrip()
+
+ if(second_line == "No hit found"):
+ continue
+
+ # At this point second line must be headers, and are skipped.
+
+ res_hit = fh.readline().rstrip()
+
+ while(res_hit):
+ hit_list = res_hit.split("\t")
+ match_length, ref_length = hit_list[2].split("/")
+ start_ref, end_ref = hit_list[4].split("..")
+ accno = hit_list[8]
+ gene_name = hit_list[0]
+ unique_id = "{0}_{1}".format(gene_name, accno)
+ hit = DBHit(name=gene_name, identity=hit_list[1],
+ match_length=match_length,
+ ref_length=ref_length, start_ref=start_ref,
+ end_ref=end_ref, acc=accno,
+ db="resfinder")
+
+ start_feat, end_feat = hit_list[6].split("..")
+
+ if(start_feat == "NA"):
+ start_feat = None
+ end_feat = None
+
+ phenotypes = phenodb.get(unique_id, None)
+ ab_class = set()
+ if(phenotypes):
+ for p in phenotypes:
+ for ab in p.antibiotics:
+ ab_class.update(ab.classes)
+ else:
+ ab_class.add(db_name)
+
+ gene_feat = ResGene(unique_id=unique_id,
+ seq_region=hit_list[5],
+ start=start_feat, end=end_feat,
+ hit=hit, ab_class=ab_class)
+
+ if(unique_id in self):
+ temp_list = self[unique_id]
+ temp_list.append(gene_feat)
+ self[unique_id] = temp_list
+ else:
+ self[unique_id] = [gene_feat]
+
+ res_hit = fh.readline().rstrip()
+
+ @staticmethod
+ def get_phenodb_id(feat_res_dict, type):
+
+ if(type == "seq_variations"):
+ ref_id = feat_res_dict["ref_id"]
+ var_aa = feat_res_dict.get("var_aa", None)
+
+ # Not Amino acid mutation
+ if(var_aa is None):
+ phenodb_id = ref_id
+ # Amino acid mutation
+ else:
+ phenodb_id = ref_id[:-1] + feat_res_dict["var_aa"]
+ return phenodb_id
+
+ elif(type == "genes"):
+ return "{}_{}".format(feat_res_dict["name"],
+ feat_res_dict["ref_acc"])
+
+ def load_finder_results(self, std_table, phenodb, type):
+ for key, feat_info in std_table[type].items():
+ if(type == "genes"
+ and re.search("PointFinder", feat_info["ref_database"])):
+ continue
+ unique_id = Isolate.get_phenodb_id(feat_info, type)
+ phenotypes = phenodb.get(unique_id, None)
+ ab_class = set()
+ if(phenotypes):
+ for p in phenotypes:
+ for ab in p.antibiotics:
+ ab_class.update(ab.classes)
+ else:
+ ab_class.add(Isolate.NO_AB_CLASS)
+
+ if(type == "genes"):
+ res_feature = self.new_res_gene(feat_info, unique_id, ab_class)
+ elif(type == "seq_variations"):
+ res_feature = self.new_res_mut(feat_info, unique_id, ab_class)
+
+ ResProfile.update_classes_dict_of_feature_sets(
+ self.feature_classes, res_feature)
+
+ feat_list = self.get(unique_id, [])
+ feat_list.append(res_feature)
+ self[unique_id] = feat_list
+
+ def new_res_mut(self, feat_info, unique_id, ab_class):
+ ref_aa = feat_info.get("ref_aa", None)
+ if(ref_aa is None or ref_aa.upper() == "NA"):
+ nucleotide_mut = True
+ else:
+ nucleotide_mut = False
+ feat_res = ResMutation(unique_id=unique_id,
+ seq_region=";;".join(feat_info["genes"]),
+ pos=feat_info["ref_start_pos"],
+ ref_codon=feat_info["ref_codon"],
+ mut_codon=feat_info["var_codon"],
+ ref_aa=feat_info.get("ref_aa", None),
+ mut_aa=feat_info.get("var_aa", None),
+ isolate=self,
+ insertion=feat_info["insertion"],
+ deletion=feat_info["deletion"],
+ end=feat_info["ref_end_pos"],
+ nuc=nucleotide_mut,
+ ab_class=ab_class)
+
+ return feat_res
+
+ def new_res_gene(self, gene_info, unique_id, ab_class):
+ hit = DBHit(name=gene_info["name"],
+ identity=gene_info["identity"],
+ match_length=gene_info["alignment_length"],
+ ref_length=gene_info["ref_gene_lenght"],
+ start_ref=gene_info["ref_start_pos"],
+ end_ref=gene_info["ref_end_pos"],
+ acc=gene_info["ref_acc"],
+ depth=gene_info.get("depth", None),
+ db="resfinder")
+
+ query_start = gene_info.get("query_start_pos", None)
+ query_end = gene_info.get("query_end_pos", None)
+ query_id = gene_info.get("query_id", None)
+
+ feat_res = ResGene(unique_id=unique_id,
+ seq_region=query_id,
+ start=query_start,
+ end=query_end,
+ hit=hit,
+ ab_class=ab_class)
+ return feat_res
+
+ # Not used, delete it.
+ def load_resfinder_results(self, std_table, phenodb):
+
+ for key, gene_info in std_table["genes"].items():
+
+ unique_id = "{}_{}".format(gene_info["name"], gene_info["ref_acc"])
+
+ phenotypes = phenodb.get(unique_id, None)
+ ab_class = set()
+ if(phenotypes):
+ for p in phenotypes:
+ for ab in p.antibiotics:
+ ab_class.update(ab.classes)
+ else:
+ ab_class.add(Isolate.NO_AB_CLASS)
+
+ hit = DBHit(name=gene_info["name"],
+ identity=gene_info["identity"],
+ match_length=gene_info["alignment_length"],
+ ref_length=gene_info["ref_gene_lenght"],
+ start_ref=gene_info["ref_start_pos"],
+ end_ref=gene_info["ref_end_pos"],
+ acc=gene_info["ref_acc"],
+ db="resfinder")
+
+ query_start = gene_info.get("query_start_pos", None)
+ query_end = gene_info.get("query_end_pos", None)
+ query_id = gene_info.get("query_id", None)
+
+ feat_res = ResGene(unique_id=unique_id,
+ seq_region=query_id,
+ start=query_start,
+ end=query_end,
+ hit=hit,
+ ab_class=ab_class)
+
+ ResProfile.update_classes_dict_of_feature_sets(
+ self.feature_classes, feat_res)
+
+ feat_list = self.get(unique_id, [])
+ feat_list.append(feat_res)
+ self[unique_id] = feat_list
+
+ # Not used, delete it.
+ def load_finder_results_old(self, std_table, phenodb):
+
+ for db_name, features in std_table.long.items():
+ for unique_id, feature in features.items():
+
+ # No hits to database
+ if(not feature):
+ continue
+
+ phenotypes = phenodb.get(unique_id, None)
+ ab_class = set()
+ if(phenotypes):
+ for p in phenotypes:
+ for ab in p.antibiotics:
+ ab_class.update(ab.classes)
+ else:
+ ab_class.add(Isolate.NO_AB_CLASS)
+
+ is_mut = feature.get("mutation", None)
+
+ # Load mutation
+ if(is_mut is not None and is_mut != "NA"):
+ ref_aa = feature["ref_aa"]
+ if(ref_aa is None or ref_aa.upper() == "NA"):
+ nucleotide_mut = True
+ else:
+ nucleotide_mut = False
+ feat_res = ResMutation(unique_id=unique_id,
+ seq_region=feature["template_name"],
+ pos=feature["query_start_pos"],
+ ref_codon=feature["ref_codon"],
+ mut_codon=feature["alt_codon"],
+ ref_aa=feature["ref_aa"],
+ mut_aa=feature["alt_aa"],
+ isolate=self,
+ insertion=feature["insertion"],
+ deletion=feature["deletion"],
+ end=feature["query_end_pos"],
+ nuc=nucleotide_mut,
+ ab_class=ab_class)
+ # Load gene
+ else:
+ hit = DBHit(name=feature["template_name"],
+ identity=feature["aln_identity"],
+ match_length=feature["aln_length"],
+ ref_length=feature["template_length"],
+ start_ref=feature["template_start_pos"],
+ end_ref=feature["template_end_pos"],
+ acc=feature["acc_no"],
+ db="resfinder")
+
+ feat_res = ResGene(unique_id=unique_id,
+ seq_region=feature["query_id"],
+ start=feature["query_start_pos"],
+ end=feature["query_end_pos"],
+ hit=hit,
+ ab_class=ab_class)
+
+ ResProfile.update_classes_dict_of_feature_sets(
+ self.feature_classes, feat_res)
+
+ feat_list = self.get(unique_id, [])
+ feat_list.append(feat_res)
+ self[unique_id] = feat_list
+
+ def calc_res_profile(self, phenodb):
+ """
+ """
+ features = self.values()
+ # Flatten features.
+ features = list(chain.from_iterable(features))
+ self.resprofile = ResProfile(features, phenodb)
+
+ def profile_to_str_table(self, header=False):
+ """
+ """
+ output_str = ""
+
+ if(header):
+ output_str = (
+ "# ResFinder phenotype results.\n"
+ "# Sample: " + self.name + "\n"
+ "# \n"
+ "# The phenotype 'No resistance' should be interpreted with\n"
+ "# caution, as it only means that nothing in the used\n"
+ "# database indicate resistance, but resistance could exist\n"
+ "# from 'unknown' or not yet implemented sources.\n"
+ "# \n"
+ "# The 'Match' column stores one of the integers 0, 1, 2, 3.\n"
+ "# 0: No match found\n"
+ "# 1: Match < 100% ID AND match length < ref length\n"
+ "# 2: Match = 100% ID AND match length < ref length\n"
+ "# 3: Match = 100% ID AND match length = ref length\n"
+ "# If several hits causing the same resistance are found,\n"
+ "# the highest number will be stored in the 'Match' column.\n"
+ "\n"
+ )
+ output_str += ("# Antimicrobial\t"
+ "Class\t"
+ "WGS-predicted phenotype\t"
+ "Match\t"
+ "Genetic background\n")
+
+ # For each antibiotic class
+ for ab_class in self.resprofile.phenodb.antibiotics.keys():
+ # For each antibiotic in current class
+ for ab_db in self.resprofile.phenodb.antibiotics[ab_class]:
+ output_str += ("{ab:s}\t{cl:s}"
+ .format(ab=ab_db.name, cl=ab_class))
+
+ # Isolate is resistant towards the antibiotic
+ if(ab_db in self.resprofile.resistance):
+ ab = self.resprofile.resistance[ab_db]
+ output_str += "\tResistant"
+
+ # Find the resistance causing gene with the best match
+ # Mutations will always have best match as they are only
+ # either present or absent.
+ best_match = 0
+ for unique_id in ab.features:
+ feature = ab.features[unique_id]
+ if(isinstance(feature, Mutation)
+ or isinstance(feature, FeatureGroup)):
+ best_match = 3
+ # Note: Mutations do not have "hits"
+ elif(feature.hit.match_category > best_match):
+ best_match = feature.hit.match_category
+
+ output_str += "\t" + str(best_match)
+
+ gene_list = ab.get_gene_namewacc(tostring=True)
+ mut_list = ab.get_mut_namewannot(tostring=True)
+
+ if(gene_list and mut_list):
+ gene_mut_str = gene_list + " " + mut_list
+ elif(gene_list):
+ gene_mut_str = gene_list
+ elif(mut_list):
+ gene_mut_str = mut_list
+ else:
+ gene_mut_str = ""
+
+ output_str += "\t" + gene_mut_str + "\n"
+
+ # TODO: delete elif clause.
+ # Isolate is susceptibile towards the antibiotic
+ elif(ab_db.name in self.resprofile.susceptibile):
+ ab = self.resprofile.susceptibile[ab_db.name]
+ # Genetic background is not written if susceptibile
+ gene_list = ""
+ # Uncomment next line to write genetic background for susc.
+ # gene_list = ab.get_gene_namewacc(tostring=True)
+ output_str += "\tNo resistance\t0\t" + gene_list + "\n"
+ else:
+ output_str += "\tNo resistance\t0\t\n"
+
+ if(self.resprofile.missing_db_features):
+ output_str += ("\n# WARNING: Missing features from phenotype "
+ "database:\n")
+ output_str += "# Feature_ID\tRegion\tDatabase\tHit\n"
+
+ for feature in self.resprofile.missing_db_features:
+ output_str += ("{}\t{}\t"
+ .format(feature.unique_id, feature.seq_region))
+
+ if(feature.hit is None):
+ output_str += "\t"
+ else:
+ output_str += str(feature.hit.db) + "\t" + feature.hit.name
+
+ output_str += "\n"
+
+ if(self.resprofile.unknown_db_features):
+ output_str += ("\n# WARNING: Features with unknown phenotype \n")
+ output_str += "# Feature_ID\tRegion\tDatabase\tHit\tClass\n"
+
+ for feature in self.resprofile.unknown_db_features:
+ output_str += ("{}\t{}\t"
+ .format(feature.unique_id, feature.seq_region))
+
+ if(feature.hit is None):
+ output_str += "\t"
+ else:
+ output_str += str(feature.hit.db) + "\t" + feature.hit.name
+
+ output_str += "\t" + ",".join(feature.ab_class)
+
+ output_str += "\n"
+
+ return output_str
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/phenodbpoint.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/phenotype2genotype/phenodbpoint.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,158 @@
+#!/usr/bin/env python3
+
+from __future__ import print_function
+import argparse
+import os.path
+import re
+import shutil
+from signal import *
+import tempfile
+import sys
+import subprocess
+
+from .phenotype import Phenotype
+
+
+def eprint(*args, **kwargs):
+ print(*args, file=sys.stderr, **kwargs)
+
+
+class PhenoDBPoint(dict):
+ """ Loads a text table into dict.
+ The dict consists of Phenotype objects. The keys are unique ids.
+ """
+ def __init__(self, txt_file, alt_name_file=None):
+
+ # Stores non-redundant complete list of antibiotics in DB.
+ self.antibiotics = {}
+
+ with open(txt_file, "r") as fh:
+ # Skip headers
+ fh.readline()
+ line_counter = 1
+
+ for line in fh:
+ try:
+ line_counter += 1
+
+ line_list = line.split("\t")
+ line_list = map(str.rstrip, line_list)
+
+ # ID in DB is just Gene ID and is not unique
+ phenodb_id = line_list[0]
+ codon_pos = line_list[3]
+ res_codon_str = line_list[6].lower()
+ unique_id = (phenodb_id + "_" + codon_pos + "_"
+ + res_codon_str)
+
+ ab_class = self.get_csv_tuple(line_list[7].lower())
+
+ pub_phenotype = self.get_csv_tuple(line_list[8].lower())
+ if("unknown" in pub_phenotype or "none" in pub_phenotype):
+ pub_phenotype = ()
+
+ pmid = self.get_csv_tuple(line_list[9].lower())
+
+ phenotype = list(pub_phenotype)
+
+ if(len(line_list) > 10 and line_list[10]):
+ sug_phenotype = self.get_csv_tuple(line_list[10])
+ for p in sug_phenotype:
+ if p not in pub_phenotype:
+ phenotype.append(p)
+ else:
+ sug_phenotype = None
+
+ if(len(line_list) > 11 and line_list[11]):
+ res_mechanics = line_list[11]
+ else:
+ res_mechanics = None
+
+ if(len(line_list) > 12 and line_list[12]):
+ susceptibile = self.get_csv_tuple(line_list[12])
+ else:
+ susceptibile = ()
+
+ if(len(line_list) > 13 and line_list[13]):
+ notes = line_list[13]
+ else:
+ notes = ""
+
+ # Create non-redundant complete list of antibiotics in DB.
+ for ab in phenotype:
+ for _class in ab_class:
+ if(_class in self.antibiotics):
+ self.antibiotics[_class][ab] = True
+ else:
+ self.antibiotics[_class] = {}
+ self.antibiotics[_class][ab] = True
+ for ab in susceptibile:
+ for _class in ab_class:
+ if(_class in self.antibiotics):
+ self.antibiotics[_class][ab] = True
+ else:
+ self.antibiotics[_class] = {}
+ self.antibiotics[_class][ab] = True
+
+ pheno = Phenotype(unique_id, phenotype, ab_class,
+ sug_phenotype, pub_phenotype, pmid,
+ susceptibile=susceptibile, notes=notes,
+ res_mechanics=res_mechanics)
+
+ self[unique_id] = pheno
+
+ # A pointmutation with several different res codons will
+ # never be found using all the res_codons. Instead it will
+ # be found with just one.
+ # Alternative unique ids are therefore made using just a
+ # single res_codon.
+ res_codon = self.get_csv_tuple(line_list[6].lower())
+ if(len(res_codon) > 1):
+ for codon in res_codon:
+ unique_id_alt = (phenodb_id + "_" + codon_pos
+ + "_" + codon)
+ self[unique_id_alt] = pheno
+ except IndexError:
+ eprint("Error in line " + str(line_counter))
+ eprint("Split line:\n" + str(line_list))
+
+ @staticmethod
+ def get_csv_tuple(csv_string):
+ """ Takes a string containing a comma seperated list, makes it all
+ lower case, remove empty entries, remove trailing and preseeding
+ whitespaces, and returns the list as a tuple.
+ """
+ csv_string = csv_string.lower()
+ string_list = csv_string.split(",")
+ # Remove empty entries.
+ out_list = [var.strip() for var in string_list if var]
+ return tuple(out_list)
+
+ def print_db_stats(self):
+ """ Prints some stats about the database to stdout.
+ """
+ counter_ab_class = 0
+ counter_ab = 0
+
+ ab_output = ""
+
+ print("-------------- LIST OF CLASSES --------------")
+ for ab_class in self.antibiotics:
+ counter_ab_class += 1
+ print(ab_class)
+ print("--------------- END OF CLASSES --------------")
+ print("|")
+ print("|")
+ print("------------ LIST OF ANTIBIOTICS ------------")
+ for ab_class in self.antibiotics:
+ print(ab_class)
+ for ab in self.antibiotics[ab_class]:
+ counter_ab += 1
+ print("\t" + ab)
+ print("------------ END OF ANTIBIOTICS -------------")
+ print("|")
+ print("|")
+ print("------------------ SUMMARY ------------------")
+ print("No. of classes: " + str(counter_ab_class))
+ print("No. of antibiotics: " + str(counter_ab))
+ print("-------------------- END --------------------")
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/phenotype.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/phenotype2genotype/phenotype.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+
+
+class Phenotype():
+ """ A Phenotype object describes the antibiotics a feature/gene causes
+ resistance and susceptibility against.
+ unique_id: the id is used to locate the specified phenotype.
+ phenotype: Tuple of antibiotics that gene causes resistance toward.
+ ab_class: Class of resistance (e.g. Beta-Lactamase).
+ pub_phenotype: Tuple of published resistance (antibiotics).
+ pmid: Tuple of PubMed IDs of publications presenting resistance and
+ susceptibility.
+ susceptibility: Tuple of antibiotics that the gene is known to be
+ susceptibil towards.
+ gene_class: resistance gene class (e.g. class D)
+ notes: String containing other information on the resistance gene.
+ species: Species exceptions, where resistance is not observed. NOTE:
+ This information is not yet used for anything.
+ """
+ def __init__(self, unique_id, phenotype, ab_class, sug_phenotype,
+ pub_phenotype, pmid, susceptibile=(), gene_class=None,
+ notes="", species=None, res_mechanics=None):
+ self.unique_id = unique_id
+ self.phenotype = phenotype
+ self.ab_class = ab_class
+
+ self.sug_phenotype = sug_phenotype
+ self.pub_phenotype = pub_phenotype
+ self.pmid = pmid
+ self.susceptibile = susceptibile
+ self.gene_class = gene_class
+ self.notes = notes
+ self.species = species
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/res_profile.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/phenotype2genotype/res_profile.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,761 @@
+#!/usr/bin/env python3
+
+from __future__ import print_function
+import argparse
+import os.path
+import re
+import shutil
+from signal import *
+import tempfile
+import sys
+import subprocess
+from .feature import Feature, ResGene, Mutation, ResMutation
+from .abclassdef import ABClassDefinition
+
+
+def eprint(*args, **kwargs):
+ print(*args, file=sys.stderr, **kwargs)
+
+
+class PhenoDB(dict):
+ """ Loads a text table into dict.
+ The dict consists of Phenotype objects. The keys are unique ids.
+ """
+
+ def __init__(self, abclassdef_file, acquired_file=None, point_file=None):
+
+ # Stores non-redundant complete list of antibiotics in DB.
+ self.antibiotics = {}
+
+ # ID in DB is __. Ex: blaB-2_1_AF189300
+ # The should be redundant, as the acc will be enough to
+ # define which variant it is.
+ # This code uses the 'new' ID _, but has this dict so other
+ # parts can translate the new ids into the old ones that includes
+ #
+ self.id_to_idwithvar = {}
+
+ self.ab_class_defs = ABClassDefinition(abclassdef_file)
+
+ if(acquired_file is None and point_file is None):
+ eprint("ERROR: No phenotype database files where specified.")
+ quit(1)
+
+ if(acquired_file):
+ self.load_acquired_db(acquired_file)
+
+ if(point_file):
+ self.load_point_db(point_file)
+
+ self.unknown_pheno = Phenotype(unique_id="unknown",
+ antibiotics=[],
+ sug_phenotype=(),
+ pub_phenotype=(),
+ pmid="-",
+ notes="Phenotype not found in database")
+
+ def load_acquired_db(self, txt_file):
+
+ # Test file for illegal encodings
+ with open(txt_file, "r") as fh:
+ line_counter = 1
+ try:
+ for line in fh:
+ line_counter += 1
+ except UnicodeDecodeError:
+ eprint("PhenoDB load_acquired_dbacq UnicodeDecodeError in "
+ "line {0}".format(line_counter))
+ eprint("\t\"" + line + "\"")
+ sys.exit("UnicodeDecodeError")
+
+ with open(txt_file, "r") as fh:
+ # Skip headers
+ fh.readline()
+ line_counter = 1
+
+ for line in fh:
+ if(line.startswith("#")):
+ continue
+
+ try:
+ line_counter += 1
+
+ # line = line.encode("latin_1")
+ line = line.rstrip()
+ line_list = line.split("\t")
+ line_list = list(map(str.rstrip, line_list))
+
+ # ID in DB is __. Ex: blaB-2_1_AF189300.
+ # The gene + acc should be unique and is used here.
+ id_with_group = line_list[0]
+ phenodb_id = id_with_group.split("_")
+
+ # This code is temporary
+ # TODO: Remove when database has been reformatted.
+ if(len(phenodb_id) < 3):
+ unique_id = phenodb_id
+ else:
+ accno = "_".join(phenodb_id[2:])
+ unique_id = "{0}_{1}".format(phenodb_id[0], accno)
+
+ self.id_to_idwithvar[unique_id] = id_with_group
+
+ # ab_class = self.get_csv_tuple(line_list[1].lower())
+
+ pub_phenotype = self.get_csv_tuple(line_list[2].lower())
+ if("unknown" in pub_phenotype or "none" in pub_phenotype):
+ pub_phenotype = ()
+
+ abs = []
+ for ab_name in pub_phenotype:
+ # TODO: Fix database
+ if(ab_name == "see notes"):
+ continue
+ classes = self.ab_class_defs.get(ab_name, None)
+ if(classes is None):
+ eprint("Entry {id:s} contained antibiotic "
+ "'{ab:s}' not found in ab class "
+ "def file."
+ .format(id=unique_id, ab=ab_name))
+ continue
+ ab = Antibiotics(name=ab_name, classes=classes)
+ abs.append(ab)
+ for class_ in classes:
+ if(class_ in self.antibiotics):
+ self.antibiotics[class_][ab] = True
+ else:
+ self.antibiotics[class_] = {}
+ self.antibiotics[class_][ab] = True
+
+ # phenotype = list(pub_phenotype)
+
+ pmid = self.get_csv_tuple(line_list[3].lower())
+
+ if(len(line_list) > 4 and line_list[4]):
+ res_mechanics = line_list[4].lower()
+ else:
+ res_mechanics = ""
+
+ if(len(line_list) > 5 and line_list[5]):
+ notes = line_list[5]
+ else:
+ notes = ""
+
+ # Line list pos 6 is required genes
+
+ #
+ # The following should be written out
+ #
+ # if(len(line_list) > 6 and line_list[6]):
+ # sug_phenotype = self.get_csv_tuple(line_list[6])
+ # for p in sug_phenotype:
+ # if p not in pub_phenotype:
+ # phenotype.append(p)
+ # else:
+ sug_phenotype = ()
+
+ if(len(line_list) > 7 and line_list[7]):
+ gene_class = line_list[7].lower()
+ else:
+ gene_class = None
+ if(len(line_list) > 8 and line_list[8]):
+ susceptibile = self.get_csv_tuple(line_list[6])
+ else:
+ susceptibile = ()
+ if(len(line_list) > 9 and line_list[9]):
+ species = self.get_csv_tuple(line_list[9])
+ else:
+ species = None
+
+ pheno = Phenotype(unique_id, abs,
+ sug_phenotype, pub_phenotype, pmid,
+ susceptibile=susceptibile,
+ gene_class=gene_class, notes=notes)
+
+ pheno_lst = self.get(unique_id, [])
+ pheno_lst.append(pheno)
+ self[unique_id] = pheno_lst
+
+ except IndexError:
+ eprint("PhenoDB load_acquired_dbacq IndexError in line {0}"
+ .format(line_counter))
+ eprint("Split line:\n{0}".format(str(line_list)))
+
+ def load_point_db(self, txt_file):
+
+ with open(txt_file, "r") as fh:
+ # Skip headers
+ fh.readline()
+ line_counter = 1
+
+ for line in fh:
+ if(line.startswith("#")):
+ continue
+
+ try:
+ line_counter += 1
+
+ line_list = line.split("\t")
+ line_list = list(map(str.rstrip, line_list))
+
+ # ID in DB is just Gene ID and is not unique
+ phenodb_id = line_list[0]
+ codon_pos = line_list[2]
+ res_codon_str = line_list[5].lower()
+
+ # Check if the entry is with a promoter
+ phenodb_id = PhenoDB.if_promoter_rename(phenodb_id)
+
+ unique_id = (phenodb_id + "_" + codon_pos + "_"
+ + res_codon_str)
+
+ pub_phenotype = self.get_csv_tuple(line_list[6].lower())
+ if("unknown" in pub_phenotype or "none" in pub_phenotype):
+ pub_phenotype = ()
+
+ pmid = self.get_csv_tuple(line_list[7].lower())
+
+ # TODO: Remove this tuple and its dependencies.
+ sug_phenotype = ()
+
+ abs = []
+ for ab_name in pub_phenotype:
+ # TODO: Fix database
+ if(ab_name == "see notes"):
+ continue
+ classes = self.ab_class_defs.get(ab_name, None)
+ if(classes is None):
+ eprint("Entry {id:s} contained antibiotic "
+ "'{ab:s}' not found in ab class "
+ "def file."
+ .format(id=unique_id, ab=ab_name))
+ continue
+ ab = Antibiotics(name=ab_name, classes=classes)
+ abs.append(ab)
+ for class_ in classes:
+ if(class_ in self.antibiotics):
+ self.antibiotics[class_][ab] = True
+ else:
+ self.antibiotics[class_] = {}
+ self.antibiotics[class_][ab] = True
+
+ if(len(line_list) > 8 and line_list[8]):
+ res_mechanics = line_list[8]
+ else:
+ res_mechanics = None
+
+ if(len(line_list) > 9 and line_list[9]):
+ notes = line_list[9]
+ else:
+ notes = ""
+
+ # Load required mutations.
+ # A mutation can dependent on a group of other
+ # mutations. It is also possible for a mutation to
+ # be dependent on either group A, B, C etc.
+ # The string stored in this field divides each
+ # group using a semicolon, and each mutation using
+ # a comma.
+ # The individual mutation notation is also a little
+ # different from elsewhere, see MutationGenotype
+ # class for more info.
+ # Requied mutations are stored in a tuple of tuples
+ # of MutationGenotypes. Outer tuple seperate
+ # groups, inner tuples seperate mutations.
+ if(len(line_list) > 10 and line_list[10]):
+ mut_groups_str = PhenoDB.get_csv_tuple(line_list[10],
+ sep=";",
+ lower=False)
+ if(mut_groups_str):
+ mut_groups = []
+
+ for group in mut_groups_str:
+ group_list = []
+ mut_strings = PhenoDB.get_csv_tuple(
+ group, lower=False)
+ for mut_str in mut_strings:
+ mut = MutationGenotype(mut_str)
+ group_list.append(mut)
+
+ mut_groups.append(tuple(group_list))
+
+ mut_groups = tuple(mut_groups)
+
+ else:
+ mut_groups = None
+ else:
+ mut_groups = None
+
+ pheno = Phenotype(unique_id, abs,
+ sug_phenotype, pub_phenotype, pmid,
+ notes=notes, res_mechanics=res_mechanics,
+ req_muts=mut_groups)
+
+ pheno_lst = self.get(unique_id, [])
+ pheno_lst.append(pheno)
+ self[unique_id] = pheno_lst
+
+ # A pointmutation with several different res codons will
+ # never be found using all the res_codons. Instead it will
+ # be found with just one.
+ # Alternative unique ids are therefore made using just a
+ # single res_codon.
+ res_codon = self.get_csv_tuple(line_list[5].lower())
+ if(len(res_codon) > 1):
+ for codon in res_codon:
+ unique_id_alt = (phenodb_id + "_" + codon_pos
+ + "_" + codon)
+ self[unique_id_alt] = pheno_lst
+ except IndexError:
+ eprint("Error in line " + str(line_counter))
+ eprint("Split line:\n" + str(line_list))
+
+ @staticmethod
+ def if_promoter_rename(s):
+ out_string = s
+ regex = r"^(.+)_promoter_size_\d+bp$"
+ promoter_match = re.search(regex, s)
+ if(promoter_match):
+ reg_name = promoter_match.group(1)
+ out_string = reg_name + "-promoter"
+ return out_string
+
+ @staticmethod
+ def get_csv_tuple(csv_string, sep=",", lower=True):
+ """ Takes a string containing a comma seperated list, makes it all
+ lower case, remove empty entries, remove trailing and preseeding
+ whitespaces, and returns the list as a tuple.
+ """
+ if(lower):
+ csv_string = csv_string.lower()
+
+ string_list = csv_string.split(sep)
+ # Remove empty entries.
+ out_list = [var.strip() for var in string_list if var]
+ return tuple(out_list)
+
+ def print_db_stats(self):
+ """ Prints some stats about the database to stdout.
+ """
+ counter_ab_class = 0
+ counter_ab = 0
+
+ ab_output = ""
+
+ print("-------------- LIST OF CLASSES --------------")
+ for ab_class in self.antibiotics:
+ counter_ab_class += 1
+ print(ab_class)
+ print("--------------- END OF CLASSES --------------")
+ print("|")
+ print("|")
+ print("------------ LIST OF ANTIBIOTICS ------------")
+ for ab_class in self.antibiotics:
+ print(ab_class)
+ for ab in self.antibiotics[ab_class]:
+ counter_ab += 1
+ print("\t" + ab)
+ print("------------ END OF ANTIBIOTICS -------------")
+ print("|")
+ print("|")
+ print("------------------ SUMMARY ------------------")
+ print("No. of classes: " + str(counter_ab_class))
+ print("No. of antibiotics: " + str(counter_ab))
+ print("-------------------- END --------------------")
+
+
+class MutationGenotype(object):
+ """
+ """
+ def __init__(self, mut_string):
+ mut_match = re.search(r"^(.+)_(\D+)(\d+)(.+)$", mut_string)
+ self.gene = mut_match.group(1)
+ self.ref = mut_match.group(2).lower()
+ self.pos = mut_match.group(3)
+ alt_str = mut_match.group(4).lower()
+ self.alternatives = tuple(alt_str.split("."))
+ self.mut_id_prefix = "".join((self.gene, "_", self.ref, self.pos))
+
+ def create_mut(self, mut_aa):
+ """ Given an aa alternative, creates a Mutation object.
+ """
+ unique_id = self.mut_id_prefix + "_" + mut_aa
+ mut = Mutation(unique_id, seq_region=gene, pos=self.pos,
+ ref_aa=self.ref, mut_aa=mut_aa)
+ # Check if the created mutation is part of the MutationGenotype
+ if(self.is_in([mut])):
+ return mut
+ else:
+ sys.exit("An attempt was made to create a mutation from a"
+ "MutationGenotype that was not defined in that "
+ "genotype.")
+
+ def is_in(self, feat_dict):
+ """ Checks if any of the mutation genotypes exists in the given
+ feature dict. Retuns feature if found. Returns False
+ otherwise.
+ """
+ for feat_id in feat_dict:
+ feat = feat_dict[feat_id]
+ if(self == feat):
+ return feat
+
+ return False
+
+ def __eq__(self, other):
+ """ Compare MutationGenotype to other MutationGenotypes,
+ Mutation objects, or strings.
+
+ Returns the matched mutation aa if compared to a mutation
+ or a string. Returns boolean if compared to another
+ MutationGenotype object.
+ """
+ if isinstance(other, Mutation):
+ if(self == other.mut_string):
+ return other.mut_aa
+ else:
+ return False
+ elif isinstance(other, MutationGenotype):
+
+ # Returns True if gene, ref base, position and the tuple of
+ # alternatives match.
+ if(self.mut_id_prefix == other.mut_id_prefix):
+
+ if(len(self.alternatives) != len(other.alternatives)):
+ return False
+ for self_alt in self.alternatives:
+ if(self_alt not in other.alternatives):
+ return False
+ return True
+ else:
+ return False
+
+ elif isinstance(other, str):
+ mut_match = re.search(r"^(\D+\d+)(.+)$", other)
+ if(mut_match):
+
+ if(mut_match.group(1) == self.mut_id_prefix):
+ if(mut_match.group(2) in self.alternatives):
+ return mut_match.group(2)
+ else:
+ return False
+ else:
+ return False
+
+ else:
+ return False
+
+ else:
+ return False
+
+ def __ne__(self, other):
+ result = self.__eq__(other)
+ if result is NotImplemented:
+ return result
+ return not result
+
+
+class Phenotype(object):
+ """ A Phenotype object describes the antibiotics a feature/gene causes
+ resistance and susceptibility against.
+ unique_id: the id is used to locate the specified phenotype.
+ phenotype: Tuple of antibiotics that gene causes resistance toward.
+ ab_class: Class of resistance (e.g. Beta-Lactamase).
+ pub_phenotype: Tuple of published resistance (antibiotics).
+ pmid: Tuple of PubMed IDs of publications presenting resistance and
+ susceptibility.
+ susceptibility: Tuple of antibiotics that the gene is known to be
+ susceptibil towards.
+ gene_class: resistance gene class (e.g. class D)
+ notes: String containing other information on the resistance gene.
+ species: Ignore resistance in these species as it is intrinsic.
+ req_mut: Mutations required to cause the penotype. This is a tuple of
+ tuples of MutationGenotypes. The outmost tuple represent
+ groups of mutations that are needed for the phenotype,
+ but each of the groups are independent of each other. The
+ inner tuples represent individual mutations for a specific
+ reference aa/nucs found at the position. The MutationGenotype
+ objects contain information on known mutations.
+ """
+ def __init__(self, unique_id, antibiotics, sug_phenotype,
+ pub_phenotype, pmid, susceptibile=(), gene_class=None,
+ notes="", species=None, res_mechanics=None, req_muts=None):
+ self.unique_id = unique_id
+ self.antibiotics = antibiotics
+
+ self.sug_phenotype = sug_phenotype
+ self.pub_phenotype = pub_phenotype
+ self.pmid = pmid
+ self.susceptibile = susceptibile
+ self.gene_class = gene_class
+ self.notes = notes
+ self.res_mechanics = res_mechanics
+ self.req_muts = req_muts
+
+
+class Antibiotics(object):
+ """ Class is implemented to be key in a dict. The class can be tested
+ against isinstances of itself and strings.
+ """
+ def __init__(self, name, classes, feature=None, published=None):
+ self.name = name
+ self.classes = classes
+ self.published = published
+ self.features = {}
+ if(feature):
+ self.add_feature(feature)
+
+ def __hash__(self):
+ return hash(self.name)
+
+ def __eq__(self, other):
+ if isinstance(other, Antibiotics):
+ return other.name == self.name
+ elif isinstance(other, str):
+ return other == self.name
+ else:
+ return NotImplemented
+
+ def __ne__(self, other):
+ result = self.__eq__(other)
+ if result is NotImplemented:
+ return result
+ return not result
+
+ # TODO: Overwrites identical features. Should check to keep only
+ # the most resistant feature.
+ def add_feature(self, feature):
+ self.features[feature.unique_id] = feature
+
+ def get_mut_names(self, _list=False):
+ names = {}
+ for f in self.features:
+ feature = self.features[f]
+ if(not (isinstance(feature, Mutation)
+ or isinstance(feature, FeatureGroup))):
+ continue
+
+ if(isinstance(feature, FeatureGroup)):
+ feature_lst = list(feature.values())
+ else:
+ feature_lst = [feature]
+
+ for entry in feature_lst:
+ names[entry.unique_id] = [entry.seq_region,
+ entry.mut_string_short]
+
+ if(_list):
+ return names.keys()
+ else:
+ return names
+
+ def get_mut_namewannot(self, tostring=False):
+ names = self.get_mut_names()
+
+ output = []
+ for unique_id in names:
+ annot = names[unique_id]
+ name_w_annot = annot[0] + " (" + "".join(annot[1:]) + ")"
+ output.append(name_w_annot)
+
+ if(tostring):
+ return ", ".join(output)
+ else:
+ return output
+
+ def get_gene_names(self, list_=False):
+ names = {}
+ for f in self.features:
+ feature = self.features[f]
+ if(not isinstance(feature, ResGene)):
+ continue
+
+ if(feature.hit.name):
+ names[feature.unique_id] = feature.hit.name
+ else:
+ names[feature.unique_id] = "Not Available"
+
+ if(list_):
+ return names.keys()
+ else:
+ return names
+
+ def get_gene_namewacc(self, tostring=False):
+ names = self.get_gene_names()
+
+ output = []
+ for acc in names:
+ name_w_acc = names[acc] + " (" + acc + ")"
+ output.append(name_w_acc)
+
+ if(tostring):
+ return ", ".join(output)
+ else:
+ return output
+
+ def get_pubmed_ids(self, phenodb):
+ pmids = {}
+ for feature in self.features:
+ phenotype = phenodb[feature.unique_id]
+ for pmid in phenotype.pmid:
+ pmids[pmid] = True
+ return tuple(pmids.keys())
+
+
+class ResProfile(object):
+ """ Given a list of features and a PhenoDB object, an object is created
+ that will contain a resistance profile based on the features given and
+ the phenotypes described in the PhenoDB object.
+ The class contains an add_feature method that makes it possible to add
+ features after the object has been created. Per default the add_feature
+ method will call the update_profile method, but this can be turned off
+ if one needs to add a lot of genes and wish to call the update_profile
+ method only once after adding the features.
+ """
+ def __init__(self, features, phenodb):
+ self.phenodb = phenodb
+ self.resistance = {}
+ self.features = {}
+ self.susceptibile = {}
+ self.resistance_classes = {}
+ self.missing_db_features = []
+ self.unknown_db_features = []
+
+ for feature in features:
+ if(feature.unique_id in phenodb):
+ # Add feature
+ self.features[feature.unique_id] = feature
+ # Several phenotypes can exist for a single feature ID.
+ for phenotype in phenodb[feature.unique_id]:
+ if(phenotype.antibiotics):
+ self.add_phenotype(feature, phenotype, update=False)
+ else:
+ self.unknown_db_features.append(feature)
+ self.update_classes_dict_of_feature_sets(
+ self.resistance_classes, feature)
+ else:
+ self.missing_db_features.append(feature)
+ self.update_classes_dict_of_feature_sets(
+ self.resistance_classes, feature)
+ self.update_profile()
+
+ @staticmethod
+ def update_classes_dict_of_feature_sets(classes, feature):
+ """
+ """
+ if(isinstance(feature, ResGene) or isinstance(feature, ResMutation)):
+ for _class in feature.ab_class:
+ if(_class not in classes):
+ classes[_class] = set()
+ classes[_class].add(feature)
+
+ def add_phenotype(self, feature, phenotype, update=True):
+ """
+ """
+ # Handle required mutations
+ if(phenotype.req_muts is not None):
+
+ # Iterate through the different groups of mutations (See
+ # Phenotype description).
+ mut_found = False
+ mut_groups_found = []
+ for mut_group in phenotype.req_muts:
+ feat_group = FeatureGroup([feature])
+ # Iterate through the individual mutations.
+ for mut in mut_group:
+ mut_feat = mut.is_in(self.features)
+ if(mut_feat):
+ feat_group[mut_feat.unique_id] = mut_feat
+ mut_found = True
+ # Mutation not found, the requied mutations in this
+ # group are therefore not fullfilled.
+ else:
+ mut_found = False
+ break
+ # All mutations from a group was found.
+ if(mut_found is True):
+ mut_groups_found.append(feat_group)
+ break
+ # No group contained all required mutations.
+ if(mut_found is False):
+ return
+ else:
+ # If several mut groups exist, then choose the one that
+ # contains most req mutations.
+ feature = {}
+ for fg in mut_groups_found:
+ if(len(fg) > len(feature)):
+ feature = fg
+
+ for antibiotic in phenotype.antibiotics:
+ resprofile_ab = self.resistance.get(antibiotic, None)
+ if(resprofile_ab):
+ antibiotic = resprofile_ab
+
+ # Create collection of features grouped with respect to ab class
+ for _class in antibiotic.classes:
+ if(_class not in self.resistance_classes):
+ self.resistance_classes[_class] = set()
+ self.resistance_classes[_class].add(feature)
+
+ antibiotic.add_feature(feature)
+ self.resistance[antibiotic] = antibiotic
+
+ # TODO: delete this for-loop
+ for antibiotic in phenotype.sug_phenotype:
+
+ # Create collection of features grouped with respect to ab class
+ for _class in phenotype.ab_class:
+ if(_class not in self.resistance_classes):
+ self.resistance_classes[_class] = set()
+ self.resistance_classes[_class].add(feature)
+
+ if(antibiotic not in self.resistance):
+ self.resistance[antibiotic] = Antibiotics(antibiotic,
+ phenotype.ab_class,
+ feature,
+ published=False)
+ else:
+ self.resistance[antibiotic].add_feature(feature)
+
+ # TODO: delete this for-loop
+ for antibiotic in phenotype.susceptibile:
+ if(antibiotic not in self.resistance):
+ self.susceptibile[antibiotic] = Antibiotics(antibiotic,
+ phenotype.ab_class,
+ feature)
+
+ if(update):
+ self.update_profile()
+
+ def update_profile(self):
+ """
+ """
+ susc_abs = self.susceptibile.keys()
+ for ab in susc_abs:
+ if ab in self.resistance:
+ del self.susceptibile[ab]
+
+
+class FeatureGroup(dict):
+ """ This class is a dict with a unique_id variable created from the
+ keys in the dict.
+
+ LIMITATION: The class does not handle the deletion of keys,
+ only additions.
+ """
+ def __init__(self, features):
+ feature_ids = []
+ for feature in features:
+ feature_ids.append(feature.unique_id)
+ super(FeatureGroup, self).__setitem__(feature.unique_id, feature)
+ # self[feature.unique_id] = feature
+
+ self.unique_id = "_".join(feature_ids)
+
+ def __hash__(self):
+ return hash(self.unique_id)
+
+ def __setitem__(self, k, v):
+ self.unique_id = self.unique_id + "_" + k
+ return super(FeatureGroup, self).__setitem__(k, v)
diff -r 000000000000 -r a16d245332d6 resfinder/cge/phenotype2genotype/res_sumtable.py
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/resfinder/cge/phenotype2genotype/res_sumtable.py Wed Dec 08 01:46:07 2021 +0000
@@ -0,0 +1,279 @@
+#!/usr/bin/env python3
+
+import sys
+import re
+from string import Template
+
+
+class PanelNameError(Exception):
+ """ Raise when panel name given does not match panel names from file.
+ """
+ def __init__(self, message, *args):
+ self.message = message
+ # allow users initialize misc. arguments as any other builtin Error
+ super(PanelNameError, self).__init__(message, *args)
+
+
+class ResSumTable(dict):
+ """
+ """
+ def __init__(self, text):
+ """
+ """
+ self.panels = {}
+ self.inclusions = {}
+ self.name = ""
+
+ has_missing_features = False
+ self.missing_features = []
+
+ for line in text.splitlines():
+
+ # Skip Comments
+ if(line.startswith("#")):
+ # Storing missing feature headers
+ if(has_missing_features):
+ self.missing_features.append(line)
+
+ if(line.startswith("# Sample: ")):
+ self.name = line[10:].strip()
+ # Only exists if the table has a missing feature warning
+ elif(line.startswith("# WARNING")):
+ has_missing_features = True
+ self.missing_features.append(line)
+ continue
+
+ # Skip empty lines
+ if(not line):
+ continue
+
+ if(has_missing_features):
+ self.missing_features.append(line)
+ else:
+ line_list = line.split("\t")
+ self[line_list[0]] = line_list
+
+ def _merge_inclusions(self):
+ """
+ """
+ for panel in self.inclusions:
+ panel_list = self.panels[panel]
+ include_list = self.inclusions[panel]
+ include_abs = []
+ for incl_panel in include_list:
+ include_abs = include_abs + self.panels[incl_panel]
+ self.panels[panel] = panel_list + include_abs
+
+ def _remove_redundancy(self):
+ for panel in self.panels:
+ panel_list = self.panels[panel]
+ self.panels[panel] = list(set(panel_list))
+
+ def load_amr_panels(self, panel_file):
+ """
+ """
+ with open(panel_file, "r") as fh:
+ panel_name = None
+ re_panel = re.compile(r':Panel:\s{0,1}(.+)$')
+ re_include = re.compile(r':Include:\s{0,1}(.+)$')
+ for line in fh:
+
+ line = line.rstrip()
+
+ # Skip empty lines
+ if(not line):
+ continue
+
+ # Skip Comments
+ if(line.startswith("#")):
+ continue
+
+ # Get panel name
+ match_panel = re_panel.search(line)
+ if(match_panel):
+ panel_name = match_panel.group(1).lower()
+ self.panels[panel_name] = []
+ species_panel_name = None
+ continue
+
+ # Get inclusions
+ match_inclusion = re_include.search(line)
+ if(match_inclusion):
+ include_panel = match_inclusion.group(1).lower()
+ tmp_list = []
+
+ if(panel_name in self.inclusions):
+ tmp_list = self.inclusions[panel_name]
+
+ tmp_list.append(include_panel)
+ self.inclusions[panel_name] = tmp_list
+
+ continue
+
+ # Antibiotics
+ # Stores list of antimicrobials in dict of panel names.
+ if(panel_name):
+ if(panel_name in self.panels):
+ tmp_list = self.panels[panel_name]
+ tmp_list.append(line.lower())
+ self.panels[panel_name] = tmp_list
+ else:
+ tmp_list = [line.lower()]
+ self.panels[panel_name] = tmp_list
+
+ self._merge_inclusions()
+ self._remove_redundancy()
+
+ def check_panel_name(self, name):
+ """ Panel names are expected to consist of "Genus species" or
+ only "Genus". The method checks the name against the loaded
+ panel names and returns the panel name that matches the
+ given name. If no panel name matches it checks if the first
+ word of the given name matches any of the genus panel
+ names, and considers that a match if found.
+
+ Returns False if no match is found
+ Returns None if no panels has been loaded
+ Returns the panel name that match
+ """
+ if(not self.panels):
+ return None
+
+ name = name.lower()
+ if(name in self.panels):
+ return name
+
+ if(name == "complete"):
+ return name
+
+ genus_name = " ".split(name)[0]
+ if(genus_name in self.panels):
+ return genus_name
+
+ return False
+
+ def get_amr_panel_str(self, panel_name_raw, header=False):
+ """
+ """
+ panel_name = self.check_panel_name(name=panel_name_raw)
+ if(not panel_name):
+ raise(PanelNameError("ERROR: Panel name given was not found among "
+ "the loaded panels. Panel name given: "
+ + str(panel_name_raw)))
+
+ output_str = ""
+
+ if(header):
+ output_str = (
+ "# ResFinder phenotype results for " + panel_name + ".\n"
+ "# Sample: " + self.name + "\n"
+ "# \n"
+ "# The phenotype 'No resistance' should be interpreted with\n"
+ "# caution, as it only means that nothing in the used\n"
+ "# database indicate resistance, but resistance could exist\n"
+ "# from 'unknown' or not yet implemented sources.\n"
+ "# \n"
+ "# The 'Match' column stores one of the integers 0, 1, 2, 3.\n"
+ "# 0: No match found\n"
+ "# 1: Match < 100% ID AND match length < ref length\n"
+ "# 2: Match = 100% ID AND match length < ref length\n"
+ "# 3: Match = 100% ID AND match length = ref length\n"
+ "# If several hits causing the same resistance are found,\n"
+ "# the highest number will be stored in the 'Match' column.\n"
+ "\n"
+ )
+ output_str += ("# Antimicrobial\t"
+ "Class\t"
+ "WGS-predicted phenotype\t"
+ "Match\t"
+ "Genetic background\n")
+
+ for ab in self.panels[panel_name]:
+ na_list = [ab, "NA", "NA", "NA", "Not in database"]
+ ab_list = self.get(ab, na_list)
+ output_str += "\t".join(ab_list) + "\n"
+
+ if(self.missing_features):
+ output_str += "\n" + "\n".join(self.missing_features)
+
+ return output_str
+
+ def get_html_panel_table(self, panel_name_raw, panel_id, indent=' '):
+ panel_name = self.check_panel_name(name=panel_name_raw)
+ if(not panel_name):
+ raise(PanelNameError("ERROR: Panel name given was not found among "
+ "the loaded panels. Panel name given: "
+ + str(panel_name_raw)))
+
+ beg = Template(
+ '$indent\n'
+ '$indent
\n'
+ '$indent \n'
+ '$indent \n'
+ '$indent | Antimicrobial | \n'
+ '$indent Class | \n'
+ '$indent WGS-predicted phenotype | \n'
+ '$indent Genetic background | \n'
+ '$indent
\n'
+ '$indent \n\n')
+
+ output_str = beg.substitute(panel_name=panel_name,
+ panel_id=panel_id,
+ indent=indent)
+
+ ab_row = Template(
+ '$indent \n'
+ '$indent | $ab | \n'
+ '$indent $abclass | \n'
+ '$indent $pheno | \n'
+ '$indent $genes | \n'
+ '$indent
\n')
+
+ output_str += indent + ' \n'
+
+ if(panel_name == "complete"):
+ for ab in self:
+ na_list = [ab, "NA", "NA", "NA", "Not in database"]
+ ab_list = self.get(ab, na_list)
+ if(ab_list[3] == "1"):
+ res = 'bggrey'
+ elif(ab_list[3] == "2"):
+ res = 'bglightgreen'
+ elif(ab_list[3] == "3"):
+ res = 'bggreen'
+ else:
+ res = 'sus-col'
+ output_str += ab_row.substitute(indent=indent,
+ ab=ab,
+ abclass=ab_list[1],
+ res=res,
+ pheno=ab_list[2],
+ genes=ab_list[4])
+ else:
+ for ab in self.panels[panel_name]:
+ na_list = [ab, "NA", "NA", "NA", "Not in database"]
+ ab_list = self.get(ab, na_list)
+ if(ab_list[3] == "1"):
+ res = 'bggrey'
+ elif(ab_list[3] == "2"):
+ res = 'bglightgreen'
+ elif(ab_list[3] == "3"):
+ res = 'bggreen'
+ else:
+ res = 'sus-col'
+ output_str += ab_row.substitute(indent=indent,
+ ab=ab,
+ abclass=ab_list[1],
+ res=res,
+ pheno=ab_list[2],
+ genes=ab_list[4])
+
+ output_str += (indent + ' \n\n'
+ + indent + '
\n'
+ + indent + '