From eafc145a258df17aa4afc50508837c4f5a500c73 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 18 Mar 2026 09:35:11 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 ++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 228 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 940 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9035-py3-none-any.whl | Bin 0 -> 10602 bytes dist/amr-3.0.1.9035.tar.gz | Bin 0 -> 10480 bytes setup.py | 27 + 12 files changed, 1683 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.1.9035-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9035.tar.gz create mode 100644 setup.py diff --git a/AMR.egg-info/PKG-INFO b/AMR.egg-info/PKG-INFO new file mode 100644 index 000000000..e5d4a877d --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9035 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..42012c791 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,228 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import amr_course +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import ionophores +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import peptides +from .functions import phenicols +from .functions import phosphonics +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import spiropyrimidinetriones +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import custom_mdro_guideline +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import interpretive_rules +from .functions import eucast_rules +from .functions import clsi_rules +from .functions import eucast_dosage +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..bf9cdc0f8 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + except Exception as e: + print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = robjects.r(''' + df <- AMR::example_isolates + df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } + }) + df <- df[, !sapply(df, is.list)] + df + ''') + example_isolates['date'] = pd.to_datetime(example_isolates['date']) + + # microorganisms + microorganisms = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]') + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..4f28a517f --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,940 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def amr_course(github_repo, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_course(github_repo, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def ionophores(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ionophores(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def peptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.peptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phosphonics(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phosphonics(only_sir_columns = False, *args, **kwargs) +@r_to_python +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.polymyxins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.quinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rifamycins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.streptogramins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs) +@r_to_python +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs) +@r_to_python +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_class(amr_class, *args, **kwargs) +@r_to_python +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(filter, *args, **kwargs) +@r_to_python +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs) +@r_to_python +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs) +@r_to_python +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs) +@r_to_python +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(x, *args, **kwargs) +@r_to_python +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_ab(x) +@r_to_python +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_reset_session(*args, **kwargs) +@r_to_python +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_av(x, *args, **kwargs) +@r_to_python +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_av(x) +@r_to_python +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_disk(x, *args, **kwargs) +@r_to_python +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_disk(x) +@r_to_python +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mic(x, *args, **kwargs) +@r_to_python +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mic(x) +@r_to_python +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(x, *args, **kwargs) +@r_to_python +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p50(x, *args, **kwargs) +@r_to_python +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p90(x, *args, **kwargs) +@r_to_python +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(x, *args, **kwargs) +@r_to_python +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mo(x) +@r_to_python +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_uncertainties(*args, **kwargs) +@r_to_python +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_renamed(*args, **kwargs) +@r_to_python +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_failures(*args, **kwargs) +@r_to_python +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_reset_session(*args, **kwargs) +@r_to_python +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_cleaning_regex(*args, **kwargs) +@r_to_python +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_sir(x, *args, **kwargs) +@r_to_python +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir(x) +@r_to_python +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir_eligible(x, *args, **kwargs) +@r_to_python +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_interpretation_history(clean) +@r_to_python +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_property(atc_code, *args, **kwargs) +@r_to_python +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_groups(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd_units(atc_code, *args, **kwargs) +@r_to_python +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_from_text(text, *args, **kwargs) +@r_to_python +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_name(x, *args, **kwargs) +@r_to_python +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_cid(x, *args, **kwargs) +@r_to_python +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_synonyms(x, *args, **kwargs) +@r_to_python +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_tradenames(x, *args, **kwargs) +@r_to_python +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_group(x, *args, **kwargs) +@r_to_python +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_atc(x, *args, **kwargs) +@r_to_python +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_loinc(x, *args, **kwargs) +@r_to_python +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd(x, *args, **kwargs) +@r_to_python +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd_units(x, *args, **kwargs) +@r_to_python +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_info(x, *args, **kwargs) +@r_to_python +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_url(x, *args, **kwargs) +@r_to_python +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_property(x, *args, **kwargs) +@r_to_python +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.availability(tbl, *args, **kwargs) +@r_to_python +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.bug_drug_combinations(x, *args, **kwargs) +@r_to_python +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_resistant(*args, **kwargs) +@r_to_python +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_susceptible(*args, **kwargs) +@r_to_python +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_S(*args, **kwargs) +@r_to_python +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_SI(*args, **kwargs) +@r_to_python +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_I(*args, **kwargs) +@r_to_python +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_IR(*args, **kwargs) +@r_to_python +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_R(*args, **kwargs) +@r_to_python +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_all(*args, **kwargs) +@r_to_python +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.n_sir(*args, **kwargs) +@r_to_python +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(data, *args, **kwargs) +@r_to_python +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_eucast_rules(*args, **kwargs) +@r_to_python +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_mdro_guideline(*args, **kwargs) +@r_to_python +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def interpretive_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.interpretive_rules(x, *args, **kwargs) +@r_to_python +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def clsi_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clsi_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.translate_AMR(x, *args, **kwargs) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.1.9035-py3-none-any.whl b/dist/amr-3.0.1.9035-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..5328ee179a34fe540299324a71c99a6635b1a35b GIT binary patch literal 10602 zcma)i18^qW+HP#y))(8hZQFJx6MbEM`R~ipxIvIU>iYj&&*r zHYouW1932h*))2U zr1MdKmv3*pAXF=s-_>4x2~{`%SD!u^lT_jE4QqWuL%((?8ZdrCyB`uUl*i++icT)f z&t3>p6)__lqiD5dn__z4d@-lWw@}w6X;d?t)$k#Bh!bK|6Qm{FDnB0Jd?$|2C0L*L7yiKWP3Spn zLVwPXnrePJ`DB1;x{p-~BR2pGrME!ve=xaM5vB-OH0tVFjU50Y0;1S4QX8qBesnqD zDa=N}T=>VUAwMeKxkY~8zVi`e>&*x9@hNWeDr=t;>Wt)B_GjyJ}6GbL>J$AS0*cinCK;I5#NjgWhvM^ z?)%m*B@|(WlhhTt+k%MiK+X_Y3p#&dT-8}xu`OHOjq0z1GIFZZ4CT=^%u^LZcSk^y z<6u~pMyr)T1UG_p=#k^HsJ5TP*bi9;IpNGk1&ip$L-34@9mf?sdoAg64YO*I<8mQu z@&j9J#aE>jkao*ugSspN)0^rfPWFZ=2w9+hps87H072mmLfzo)=iIe1bsBIMK-QT9 zgY0O4pB4rRwi1X>Bj|n+xYxF~)^tL=PaLSBZ!U|Ha2PDY$aX5Eu%#$t6Jl{C5 zP5ggf%*1q@%yf+>6gX~3Y__(znM-M$_GR5 zQDTUOX8r8JKN7O=9eSoG%6&VWe^M}0nyoAj^j}~- z{OMjzJQfqI67PNLjbK*Z8mawuUmOjsbH}_GYA}Q09SZC|J&{oPNslfxj7DE3wsUw) zCwlWC>YQ%Q)GDd&2YqYr-P7a;o@VkYd^-ujOKZsmwwz!@1{h#Dd@S9(9XKQ~69uyB;%u4%Y z_?R^0HG?(hO9j;rhFU4Asb?InEb=-Y%@12W_?&SBoPKflqoJ&sQBonA z5ld%rfZI=aR75=614HlJKiRE`l`cu_BlRVrMBOw>-ClSuidZ+DwMe*7K50E7R6pTj zW^kxJ6e%zcz0Tkl$uuxAM4*aGZ$(NBgz@J2fD)og838PhD*AxZ*=812L`)q>acB_$_z1KP+%lHI(kr#VvI)WC5D*@1l!2P33_@q)Obfrq-V{D_ z-X#B_^3}EI`z#@JeXy)8Oa{v@@kZXy69VYVaPQ2|_UC88p6#z~F~q1#C^S*D40cYa z1Skw%+j+H?t)sjun$j*14(S-#oN17U)hoc9x>F3fGV6Yat#igmYukkddtBbo;kLXe zEa(@AuF{8~hY4mA`a=R)tvm(au0kl77xEa34e<|;O2{M|n|DjZkIDovmHfGaZ_SjX z3=_aRo1I8|a&@%1*m*hA#)vdV&sa>OxUV&2K%wG{TA3!{Cd}1F%UHN9UFM}>d@{0f zBPiq=om7U@qP>_^=w_a{ZXzAwcrSsIKx^f>s(r#K1xY)Km>u=N`u77%FNVJD;&*y{ zl`UI_`<|!ReZbF4h|KQVljpJ|+7fPf-wK-`aYa#=4>%YDbgXVI+y^)Y?0s9NIgEZo zUN2{=`tZj%1_$%%GS3x)VlmhbNhpJT9Jc!>OMxU$z1Z#}tY zldRI2HN8*g)t#`gYvT_Ze8U$P8-g#|3E19U!Z-@_&T%gk_@NSnOzK+3X>El`p!Rnf z6)SPbp%zln`@`v+noHXCz-TP;k|zWb(cwO>6ZDt2DjP(qFP2X>=|3h9Y&b*RTMx7igQ+ z3!Eoq6ahY`zQN-1=_|pOOBAJ)fJDd=B<1{kFFN$@e;3X z$avNm7pi8^d=wzrJoLKCPYS@hPt;;i?=sd^7(oRvVJ1&6a1I+jO7YS@N?Vpc;NOy& z5A3?w$t9$_)tz-faMEA0B6F64o1-+qsC>v9kZX2$dzNSifk>(4E?{}`IGqMgFIezh-N7<+3E4P{%i8t#65VmMh-EKA20U`<72*>ZkdE+$UO*HccA{ZZg9`xY@e4kouh)RpRZ4+Nv@?# zMV6(=J*>lmcuUR~N5z`R8`}AczdlscAEel-Jby$nerZpA?$k!ORO3! z@Bu_>R;@cp#nrLPFFPNJwlzPxrv(wUHe;=N-aOMbEyBgyO=CtC9(L2EGqrB+E6*$G zNJfy9rn9HkyVh-*SlX`i*W1n?wQ%2F1z)FQ(;hQcEc?2^fX5gUoL)L@W>AR9M@Tj5uJv(c7~ZIID~~;CJH&*)R4EHwY^!~d{#kN;*VH4io^1J zp&19D;&;*;^{_80wFlasU*k^(=8tqUc+9g>!;OjvL#6=MADRH9`PGh!9M@H7WO%U& z{QaBGqgqM%eOY9d_*95iiyzttJ}H>5$5BxCyL7nSWUz-$^qpDT9Y<^noMt$0>Ke_r zi@%gnpbZ?ie_Q|3x^Pf&7ZKI`TP(IG%Gp$nVLTuuIZ}yYOpDCBo8dQ*s}wUdS!hx%ka%zO#WtYn(DL?s z##;BNVNZ9!T|hSFZlQBWO*$vJT-N)(d6d%>Qx4qt?P7yoZZV~$hQKMz#S1?)(w&x2 zE~S4iZqc1lDltQMS_0EHZD{S=rx8d(cl%MFj;~lw(2CivjhG1YUMZ zUnYc47_ETFy}J;c7&OYRwYUTnQj|lQ0VCx%y1B?`WmHr(a(qbHt)d8V3X*R+v=-u!>4bLSJD~#A(_(a}qUvkI67FU>l>{ zp8Be)r{dBvD|__{r)|5+F=k2pmY7dzjF*}OrQV_+sVWV?@L3&KcKKF+seU<}5kkpS zFtEs}Y#8OA7L~{Jh2=uqx0f)(^mA&d~bp@l;EB{K-L%?_VIYDI3@^>Rg zFP^pIUaF=~cbPwPY?G5kY0QTabhdFh<|*hHyz+4SYmnl&p43)WpEVTseBMlr?Y+W4*|wP)=cjH5^CFHE9h=C6i1Z_Pmd^8vYF&*)OG6uX zinAh2%g6`>n{F~2_d>JG2D5hy+T$Idm`o5a2G5k>b3b&A_9$rd$4_B?X^w0eKtnRf z&|DmV;Mjs%W@08DGjO$)=+hWQWX>@WF-pGDtDBcdcIeYw*YriPa&5p}=K+7${~C`> z*l6LQqq&em02&Pc8yY?RP+)PX^AePv>Yj6h*Lx;)1Abz&NBytqAegj zm@G4g^aqQ{^Q09#bTa`cP9Z4F6^Tr}dvZ%ceOa#8Shjna^)uf~m<$3wFMQ!(0E<5+ zntnGdPsb{~HK}SrSn?drN-Pp?P{%K%nt!9c?aq)MiwZ7gC;ZB(qLDfvb|)}%o0B0a z>Jk4d2Uk+0t=xMWAu(^EsMBi5McLnUi%sp1>AYKP6vv31!_$z3~lM?P^!{0=^CaKu$c^`s&=Z#A6aHJNrO{DD4MHpWqP;T0jAi z9}1R5O(aL;s}!UU0-9+FkUu+JMkWN8T*Ol);f5zlEo82B&G8LBYRQQWog3zJCo;{8 zvSCKlBk||j5=Kd0VhJm64WEjO(6FS09MHBZOz2r_^ss_n+z=*!yS=z>hy@qn7b_{k zL20cnE3`^I^6IrNYIqV?qp@*Yk$-|=AT#a?xtfD z*YbN^$k1(GaP|ADFQ>7AGnAdf8yKj~FyoixGKjUG&u$uCG!x_2d$Hu#SLXo_+eN}5}lUk&!11Y#-99y&Mp0tsf)U&w3By8?FC5* z2_VrITa8#J-rht*Pb`6pm3UU`+53T+)aJEPve|u@j2Bs)CH>)2;u)5v89b0DzbW=ukwQ(^9cq~7TF|2S$wCTnWp195uFq{f2TUp zEH>H%xqpWvrMI;G@mYF5uOEY|(}Sa`E>>|j?spzs$R+t<)ba$=BswZ9BwdBo3bd%A z5&~V36>>a9a~7qu=v%sw1gkAo-)>iDsem>@D`Oie8y6cQU9y%u%hfW6Gy!UMU`R`h ztna4;J4T2Jm|f1tza$#>Qvp@_ zFfK^yc~Q!Yn-5%6B?MHA4IyeoB?J?+uc^Rz>M)3@^xP5BjL}lF9b80emnjZ;;6ykE7{G(zxWT+=E#cPsIPYGrj<>vqfxah{Ly zd9Fe3Sg1B-t;yOQ68o|jK1yh0J-YKeN@?VL5-@jI@h7587L}qBoIepCZa9)!y0f0F zq$mcIO+ZFP=P-ndW7SjN=p93eD>WCG=$v3Gv{E7{RnTTXX`y?QTI&&;^$?fX5k$=Z{@q-hBZdY0& zgs3azMArS5{#SOi)daBim;VTV%>E?1F;~7?G$4Y2I8lRukp2mOOdMPp*ch1^Sr~bk z**F-@ZQR@$Y#c3}m=q+`MZ`taMVfTa9oMB(KWa+LJeVUaq>HZVAtsCokK56Wj7#S? zUBEiTQ;Teq=o!B?78)`!*Ra&IDAjKR>ZMgu3Gq*0q~(cncpvpJeJE6~Zj)PtzKP3W zD(Fn(vd8++lw9nbRH*=86^BoGlN1A1xTpK#sp&{+=QY~ZQ9Bg83BH9)YV^$&=cQak z4{mfE!Owcvh|b2ka9E79$J{S?V6z%nvJI={8lOa-FD+<*c?z5`|z%V&{x<0s!8Ct+U0D}0* zY~Gb&v~06sH@Oj7ms}Yk4?vqF`ude6;U5yDz9F2|o-W{lXuacoz)tk4^$8lCs)vNQ zxK0U*cSrO}iQDYUzj;xi=dbg`0A7c;U#H4`=~^=-xWHAmAZsLpHND$liq)upRWi{2 zSkr1zX?kl~I8CPfRnY?bt)AJ?0nCi(S)a?WhKxwoX{?py;>geO1nw-QU4ywN(VedL z5_7Ka)`#w~J#jvB6roM`PM#)IbS5C-2i z;jqf}YC+VdL{nh+71%NoF~*((f8jqROoK%cYwwbAiJ>-!a&%v=B}Zu0xvSSZ!$YUL zTl1QWtWYAV z4kaaVBa8ymV-X6{E6x@tH3R{)tB+w>WSCo1C#k2sMa46WvN}aWV@&nzD*X!DWk}Kx z8cBk<)ULcB>ov}yhRT2?Z7M`PxjGmlKZoFtj`~9#gKT8=3i0ZD3c&Bsh8kJMY_=PJ zLmPCY68Yi3vA9lAy+&Mr(MfGLV z`%a9Az9fL79f>b3xuelp4rKi(%CEX6FSDHk{B-e1sN~egSF5jF#B>81SdJu#2`5f~vPj?NOdHx-Y<8;&G#5Rd z$SZ;_d(P6uc8|~#AIb+$B8jlZ6~vT?&IqC$LISq4zMwt9Z+4Uma^43Nmt^!b;@=Mn z&@z8FsgDnwXI}G1gD*&NSoK)jM#o^+%8+nV3cL>VR7!`Qm|gF_e!edEG?k+~la2JN zv2Q8|QBWZ%i@czS#Vs8hK(huWBOy8o_0oqR!A@*AYRoLm7iv0~<5W^Ggh9iVt+X&F zSu(BoFd}1ahLv{)SbdsBx4O9(c$Hl29pXc4aK$s}T^wfK_V*{nxre%l;6^-v0sy*c&g2HRZl)%1QalyKC^0oi5R zjobxOrW!^HyUTJd$>KY`ecWAbn2r3weNbFPJ#cZ)j`IDVt8H$iw-Dt8E16GO@~+H?{o|q_`Z8R{=5$sMllZU zhl3hg7;O5b3H(CeCILV>3VN9mKmddVx-_JqY|$0_k%30V$`1BjPbcOfRQ~2EI2?tD zk4VmS)*P73T3-=6WOx(WTsO1SuN4`zmcR1>K4YwE#L=NErvHlXV?dz1<+gK2S>%1`p0S)3B7yGx`ZW>zDsVq(wKjx zChKV64-B=MyO3jP%@Jqs)Q0}nB&#KSj!*LBppqauyMxJ*o>FW{!@5biEhWR(yG&Tg zb{UzT3dL%GT7z36ERK?+gMVP+#EZ>A%}0j$HVEa#sidxbSD=eLhPbfb+^i`#l8()n z4~trFg9*s(&bs=#&g>GG#_@o`_5(EFHk=0^P5Il!1UybdA(rctkZCz)K%19wsC1YBCdPI!t)QB}bKn zD%{`AN1)sGNF9hUbmg3xT#B?0=BFSjd&`mdt|(EzPO9Alu~lb=3EO)$$n5_016G42``bOTA3sH2@p4D^L&{c5J$CbY-EsLsB*(1fc}cE{G8`}SFKu! z>|e`u5yJ2(@MDlw1aUCBW(d>;)Gw^)N+beZLe@|e#AxTSK>5_Ny^c(gDFh@N1o*Ja zCCxWA!%aSCtqEpa7S>LcyRnfEO*86+4Y4Pqd9}-Gxu(~-xet%Uze_LiTC{~a)>W?2 zm)3xkdx(JlLIH0~=^przXfzCGBI*2H`3Gky7?Aq;)W8F*_f*_02$Z7E7H9ORF=@6* z(VCN#Bf%ag+;$Ti2Mibpl~WC{Pl(4Y2N-%?;2GXv4l?OY9Bi1*+*?dc&S-Az;<>-e zMQeE>m~9{;Ll8D>z`se6eW9Cs7=P$r&tO1_I@e0Oo_$4Z)h+M? zKH=s$YiL_R#2<*_L^_bRy{&Qe1@rDNiabLEvwKOh-b$)&Tt z{}jFCGiOv--!z)9K}q|KIFS$vk(Fmd!+pWNfS;Lu{36k?HVprvw(a~DtUs+J(=qBD zuyN`UQGHlpX1^+162P(?cg#Mm7#2L%2OXsJ8qBk6b2v`VzJrbs{=B~H%Q-Z)aQf)5 zAkf<<^;z_VhbZm=zPWKfe%aHmPI4zOs|#jF$HAjh>OJR&fz|wa^Zi?y20v8yW9^pK z#Uw9StN({^Xw!OjGleQmktbl)0M=^F;4kuFnCU}VCnY3}gM5zf`%gxvF>hi{ zwL~x4#)89BOenh0bVnJF&UU56M|UpgRtQH`Mi3{`2|lx${-wg(cHU8(-rJXth!OQ| z`sOk&^$M9kf6Jlf^myCOYQa}}R;-~geWIAg&Yu5bQm$}PI-xOG;R=UzAnsBz!R~nw zWDX#dPE2}XQ;ygd#yZ}sOy{gRy64G~Wa7D84?CmzQ*0@Ih_W9)6(pyt%FfeLHADWi z)#yg$V&bT&0Qa~ErTet*?eAkVPmnO}p#q`SHS*U}vtOL%jB7fj41cGctbqLJVGMj^&^SNE|*L_H!nFHLvjBT^sj=~ zzalVg{DNE)P5kX60HRIj{4o8&;=v~2pHe5%bzbos zYwohx0*2}x*$eo8+eJ+CfClx)9*94K>Ywa#cXBqexA3&EXLR>=ce_K}0|WVQCcmj5 zRa4ME?Ob3WAjJQ~q$(k%q$=(=Bj*Za1_7DrvJ&}@^32coUJxh=YJ;Ba z{Nl;GFVA%exwWUW`vPmWrW#wf0UMbeQD8e=3RNEF$F|GcY(VM57k(Jqg$!+#psP?@ z>RTMQIK4yJ^_m!j!Clv#4Rr34o$}`adj-=J(L1jpn~as6o0p$q5y8xBalr63;Abz| z>*S!2SWF=k>Fzsd#kJQO}?XWS__M z;3S}HJ;E2Y{H*ygW`Fp1?$2^KR&N3NlUm$9yHV3VVxx%Q5qGs-X;$a>$pw=D+!b zUXW$nI3*kL>8G{Sr#}BAZvChTCFbr=&@!J*52*lIdx*hU<>`qorW)#oGtM`2;FkW> zugdmmG?bn@fLE3S1;YUUe|OmZ`9}Y96b1cj`dh!<-@$+H;P^Kb1f(cv^H0;>zrg>| z&+&Kg->bcUfv;fy4gSyC?|-8IZ^@Fs(3e>MAE}eS)BRnEf6;AI`~%(p=<@Gee^<|6 xTwav_!1Z5R`a9>}b@YEY8-sfPiSys8QkH}KmzqJK|D1P!#Ay5{!2|;GzW@y3cPan? literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9035.tar.gz b/dist/amr-3.0.1.9035.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..bc2f48aefa24d85e2620f2d2c677dd48198300fd GIT binary patch literal 10480 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..8d8444867 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9035', + packages=find_packages(), + install_requires=[ + 'rpy2', + 'numpy', + 'pandas', + ], + author='Matthijs Berends', + author_email='m.s.berends@umcg.nl', + description='A Python wrapper for the AMR R package', + long_description=open('README.md').read(), + long_description_content_type='text/markdown', + url='https://github.com/msberends/AMR', + project_urls={ + 'Bug Tracker': 'https://github.com/msberends/AMR/issues', + }, + license='GPL 2', + classifiers=[ + 'Programming Language :: Python :: 3', + 'Operating System :: OS Independent', + ], + python_requires='>=3.6', +)