From 66969c4c2e837546afe68538c3ef5d3da921a95a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 24 Mar 2026 12:24:44 +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.9040-py3-none-any.whl | Bin 0 -> 10603 bytes dist/amr-3.0.1.9040.tar.gz | Bin 0 -> 10470 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.9040-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9040.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..376855573 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9040 +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.9040-py3-none-any.whl b/dist/amr-3.0.1.9040-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..ebf1a5174483ef9a2a2e06719d96df9a57e052a8 GIT binary patch literal 10603 zcma)i1yCK^+9mGp?sjl@cXtc!uE9gFgA?@N!QF#vkl;>mcXvpDgTv(gZ>H{hw`Oil zckSBM-L+PKRlC=>`xA8~Xc!y_2nYlSEK6S_Uw=LII#>vZ5DEwg^gnkcR5aO4P3>Lm zJxxtn-TYEND0#2*Vyr*o2ukE0418g3oS-5;g7BqSp-F;-gdukrDpLzdsjlC1F~ggc zKkcgxDhD1Ox0adG<#-il=T6{#o>22#Fsv(9{;g}PNPd{t$IB&qwO5#XQz=3A~6vLA zoylb*JUeFy(SKF$XgVj=DpB6iUw8^v*@xEtc|0bo!QUIv_JD|0T z5&0+e95iD;X39;qJRHBXAT-~_t3^;7LxnS2qXdG@?=-||f)-4>x>n)`fT(~NZk)6x zx`%IF&O|CRF$m{@iCXCQs<$4|U$<`kM7eqkfI>p5TY~EPXC%37w9-^N$P{Eid8gK@ zx-Z@~(p--7E$nhga6YFjySt%=4y~X=C4t?2IiZw8W^b_SR9tMyt#4I|I)u4liXQp( zC{U4x%j>Rh^+HA!Q9M~&mA^fN{1)OAg|o2p2hL@^jV;%b?d_=18YC;PHp5UpQ{x<6 z34C`HEHwd+Oca?jKosGX!;PII(8n&6uLqho^MoOZ{tsYi#Iw!sQ{gx38<$&F_F=UEZn+!5TKrmsUO=TU2XhZ9mTEIq zCBcF7oCiNVYskmqLNyY7Pkd1=AV(cI=gN#h-Tgf*|_UI>7FSQFQ=Jo*h@h_SxPK>IdYFPkA$SzeM*- z2F_>X{WAT`8}nPBS_*8g|lKaVhN-EX1h|zWupN%0m$lxp%FH%lk ziwZYNI-edKY6wRQPQb1={zdT<2nrLa<}+NDlY(Hqe%z;psa8jU%BPFnr**TRL6nd( zVvGEE=%?mIcN;kN+r-UUhv2eCX6Z{lG?Ds(^Kl$^kVbAI{D4Q?`CSB8)j5kyMdDO@ z^PDy@PA%h(oe@!?-Isw`Vtp?Of(LqYifw2BzO%fh-PDrt@Yp5MPOrRB?C;~nt`ElZ ziGb!p#juxDDjz$X<{4fDwqqVApl-QE_7YMv1CfD5zM)@991SmQoCJ7&0R94(jEl(l zEz1UjXS_WzOCtQt*$t!FxUsBOZrFBVi+QD|{~EYMHXpJRJ}y!Y-Cq@Tintl`k~w!kEf@b0g_^)^TA+zRP;1fCpaz1@xKscAs3%qk#rRSJ5!g9Y_;x7K?s`aCcO zGlKhr)c?!5hXk`{?n6UBpdkI_+^x(#%{{C=J^ncN8eOG?HC~MFGd=bx39Mb*S+cmN zM7pd#adKo=0~mc~7z3gjLM<94O%viTuUDj+^W(bHWDd*}4*UtOHr<3QRjKo7^4RrY ztEpEF4Gm4HYqivz>HxQvafiC5;0-j-+HJ*JK5s!%YXp;im9Bl|T7jJsx z9sY*+soMtiH;vC9i@(m0!Z(B}Iv`|n{E}`Gd_N|EzlikBdhd9A6z$pi+#W}cxro6K z!^q<3ib;aO;jka@`pLZe@ z3?FXKkHLd~g6S#)hkz&8&6y8K6!r2|{JV-`hvMoi-mOoH(@ zDU!!5Ky-ek2Gy>C*Qjl{rM-fdC)^9RKhZ-2G_!FhetS3`Gx{I7$Zp&&lHaS7AXEwG ziN3VZQnE|{Z|%3Eov5|3X5;6SESjRyS-sHda}?p|eW=&@sAWz|>PUBs z^B%(dPHvuEHoa>2?zXZW5piYq#z1WHhe}R;O|~0X^JWE_QD?gI9M^zX2GFM_u}WLLoWa$9IhV^ipk)O83d;!9L^LtOYO_dFMhgJJmZIqo4{ng(XVos|Fp>~gxMK{ZUGimC z&WYFPL6NjRXg_irJ0zLgQBzm>Hv zy&=D(u9OT27uQQ=0?@b1XiO1Kwz0jpC2Q{@Wpt7eI^8pg=&R zwLw5&{O`X#8!s12PkUFFe|dz39AnpYUc88_SEev9)t=KX@8-oI9Ky847l?K{%(fq! zNGSs|b*1tw3M;uUPa-KcLvzQ8Df{_?*f1?}Qi?yv6Z)^HXPQ>qoYpF4?O85T30O0{ zgZwQ$f6=q$OlC~R2bns@xx78ysf>^L>w097Qla;t;N3z7I(Q&GMsmGh)OL=Fa=t%5 zoFsoNV=J~PL+{}n7A0DAJ3lPZMPJu1Sorm(nXZhMPC6VM56RSRo#XikIL}h{LJi~I zRaxZJ;Xn=|)3R;bPA;j5UwYbp13A=w>;5TmrRP@QGm@fJxlRY}&)UpwZ&Ehr3NslxtAr6}gSOYf$C<|&_RC%td zv8agRlZ5*>+(z}13;MFDY>4SlZ5Q73_x)0FpO0eT?sk|6yQvTlT$wwwx4s{8>9k zylCsR+${W3$AC9>+4^nwOYZ_zcyeo}qX+gg-lDh6fn{#r#x42twA;Nf^TW`I==;#4 zjqiqn&D716aG5A4U<=QT^jqS0H1FP*K`LL%fbECN?^l5bCA<^(Dy^1gZ9)t9X08Wt zjhB<=WsK}d=Z^lzt~(`CyOO-kH8^Gia+)ZoRkID2l~SyMGvRuK0F4n9 z@uT-EQ|*i0?>q2z^qZ2wt%tH%PZ@{sE#0W?h`{`bwDHYL^&e;r`TN}qQ=~y3iQl0m zYuPBm!%o%B9(dJg9;6t2?eTFj&mj;^Ht!Xy0xYBRhuzczZS@BOL^U)p;3awHWqnvM zUnr0jr;HTBgv7B5$vnG@pvfU)9NS7tAz>wX$DDBgwUW$z#bd#2|W}xEZ|okl$#pC`2{- zDR2epoUOng=aRwH@+gbxdWCtTB~av2eO}@R6p#t-FwqqypP>+!G!XsOfMl?UTv|#m zICJ{ZUY!>=%BN4>mcD=&;n!7zQVrPohmIh9(?VK1Bm&LFZ8+Mx58V~vYhE%gzEw-< z+^NVKFr@vG$E$S_($u8Ggg0VHhMY+I5{VpK16)9{>&}Ga)(JKWK{Q^Aw&~-T@jG0W zfdPj&^^UY>O+yX$?=y;*&q(?XD?DR1UdqToRz%y<1g*%LUvUzg;z3Brf6{! z_3T>g>;&1KQ*1@j^S`}^i(6`Vn=T$Krc(}Ia=h@1{OO!DpKB^v<(`F?i@`x(k!MBG zc`IH`U3>&qk9z5v-#r!n%<;{x)@5;Trtmpt6}TsmW60{m9nT@EmK2RvG8l zl`IQy+AhhCvM8q_5pBNCYT6CYwj9jaDeOpehGR2FJs&((L(Y3MFx{nLFd9EW_@z6t zX$%j`qQG#z4?*AnX_JKuI%45#FEwH?jmny3BV(0)X4bYUmHlqSa8=tE!^yXfbd?YM z-SBHXI%&OCfQjK;4h3k&1RF4oYx5F$R7k%{A=C!_Y}s{RbjRme7JLo57B8X6r|?zq z)vurt-lpwEJA$w)wnTtc8Kt}?viI}l{QC7x964?PB{AQACDNE05D9PT-{w4;KSKk` zMkKMq9VJJ7I*~&<$4r5^?>TYXWAL3Uawijo0WJx3X*SQ<)i`=?R)C0y^S9_8p5VJc z;^lC2{y7y4(~;`xmn_%~T-+d$5iEIk#ja5rjLKeeGCj!!jMhUn9BG;;b*AG4&N=o_ zNUV7@u=x^uSbwOLvOszvxSI_?a{@zSrAlVu+mlxs?$2?x%CXhUZj|*}%4Qt&e(sNi z09g1o(fqq{>1Vv!OS7gPjE%tIjLZV*I(_1Nn$;J^o9;~cv6#>jZqm=Z8ainMQnw=0 zH@TUzl3t0watUQ6+ADm2qJZ+}i#u(H+|>guHo3I^m@c@dY(WbTs@xw!|TBpKf*`a};A zu!0JK!f=QjS`xVupXFfvP_QgYfx>D#+0uj|9cRT-Av3)3&>{_}5Jr z$rcAHJk7NPrG?!PazSL6({XOb;tjE@Ta4+X-QG=6b6CDpnf%?m<1ad>$F{=T{3Ad1z!6ltFH6s(fxpm&I(COeS?2Dc~@+#@=q^3k~c73 z!>Ua$<>MkDJT(p$E&CAA537@&!vkYi96YQii_IwT=gTKu8z$Z~oBD*|5-V2)8sE5a9}rL#(akf}rMLUp8NOeEuqn|C zwrfC^@v-LU{o6dLy=5KukMeu@{Wx@;UOd(H@v1uszw?p8E~pP;mL}LHu`xMenJR6U z;U!hoP?(Bs(GzJ}vT5BUUoymGI34KvcDg#tMD$VGSlcPN__$D+QuLHLE|+-ZNicJQ z!&>7M{oiG{al*`@Orl$)fBf0JdCssiYal{Tc#CmFpxxLg)Yg9ddd2G*Qg}}WwH1lvej)-=;!ReOv4P> zbvWKc@WIm0Nz!IszY$`ppyi_xR1p_pTRP6H;=N5D*FFgEA{Shha2asvr7BZ&^w|!s6at(G)NMQ1RyXh2n8&Y1=JcMF~D%E2hxc zK$L3i-~}hf!l+IJLC_M;l_##Z9VNufE!*Q*O2}4rOagN0v&O;~JuZKn27Vte0lT6Y zbftq}BtODVWZ!KXedfkmNrLKl`j7Aj`%khPV5kP&hzbGWN)G`+`6v7_cmBx2#mdgg z!79Mc&CY6N@8QW}?_%T1rXr&)AuXXT(QI($vL>JQR$Er?#U5oXUwqjBGhs%0)PZek zRyMcc4)t9+t=J)%ne|IkkqH}nEk|vuTEiBgL0%(`l=v7yUYRUc@ZJ#Dk4E$ICZ$#E zi?kB1%7>qX-0^-4rRUqn)f&KO)!`Gth#T) z_we;~D@$WUIvRGTY# zk!sX??BA6z3^Rh$!V_Etq`lhWeL|*3A|fxLr$VK>QWa}3+2hs-LSS=#{|I&;GqFYn z144wU>|fOp^c->!H~3N77C*AW?n5@q^!2ODB7>9UzM!1eoy-$K=)DrXAx`va^@*CE zXorQlf1DDP?vCn}leXVee(|BhE?5(Y13V9JJx`VYGO%Mya!0CaMb}AzYJRoHm8#YL ztY)nLwyM{v(frapf09D`tFjgGO9Q)!Gn6ISqYsTAd`C)*|G16&jhYouW z$djq=0(Z9zqo+@Q)va7y;<5t?1Al59#6yTx6@@O-5^QNXd>S&f*ED1ISyI`gw^5Im zPNg`Pqk_=3z5{nu7+Jqk+l=g*AvHg-JaZrN*ztNViGG>Yj{8>zJkt*nFeR;mD@}@x z8=7Y#Up|ZPSM$_@=CF3?n9vvs3SwpkXi_j4a9ut4(7w3ItW{~yMdu?bFILBh*`Sp+ zjPaKZB)kg4ItZ;P$y5Yk6|PJW&e%inFXD%!pHMO6`a4v7QkX5_Jlz+oDN%a$p4ts= z$nY7Sc7j$C%az@Xt+^@zx#cLIN=iz`U-)dsxX;bWH1l->gFC50L_$;hF&^uc!zI3i zL2#s=!O6*7i(?@4ScgOON^>R14Z#2%8{#+?SY}tXDH<4WFo{fJY)`PTSkt__%05GO znNT!_M^m6KcBs!Q`i%2vVY1-KTZqw5t_;R0&!PlkV}8@dp&D7aM7{i)3J5r`r$<+? zoarVW`2h6wM4b6hYCi3`e8tG6Xa`9=i0}a&rI2W6C5H9`4rN4X+|a^;4(1_SB98`m zLt1O3EBVHrI;d}zk{WL!&acB$>p*sQkww~ji6I%>GlsAry=Can|EgHkQ+mpz8^od; zWNeD6p==}Lq{HCeD-uS=X4Dq(%v{x}U%AG+al-r9xMJ}+o# zb$K?N;Q_%M*tk55cZ|~Mzm?w(fZZ||kMbeSGS~R$=^rAX`i=G(k@T$c1#fWo+zk|y zn(8HSm^P72X+Im7Kh1Ow2s0(3VN%l{U9LRykuweG;JHwMl8#*g<zPR@1h1#DB)%L!zl=9Ro z0l5`AOg%+Yry56!y36xys1iGU{X9R~vzrD&`(e0CdJz(y9u@>X*4SUmZ=x!TReBIzMaIUQpk9DTd-u^yh?EmU>|Kl!H z9K$TU9|>+~ez5tMF7Oj`y9@y1Fyv`U1O*Tg?B1A)vB^{tKm{2SuQ=Fu^%InjQuSM) z@L&`sF)Ag`O?O~2du>_jfaOJOW6jdWs7_+gPWjdk_=vNjlfZt^v{s=Pqd}|HIA>rbXI>bgOoX^{!joZ6~i4)^ZbN*7h+i`NU&d5!b$~5O25<|wcphRc(RYm&4j7K8xbiF4CrH-FO%rh6vgBy zB-cxY?feSu9p30hk>ZYA@dcw$Ool>#u*R^p(wM>7nhT^4O2Y&w(5Azi;O(#RYAswY zhyh)g!u?JPV%biAm&`Nfe_S8A`R;3QL0e99PD1k95*m|O78tKzEcWU%;~tSr`6|2h zk-_RSJ=OO{;oxxF*>fe1wp?lMPJQ?<&5C;BXT%f_&KgOQGuya48L1^U44fOZTXG6Q zy-TE3To=(9X>gpzn6-qZ;?fwoABgwOT?O%Z=!K|oUk2fPc-6G^Zwn33$57|@T3U3K zMl$e)3J@_H>~R5k-PxC)*Vx??(s{r*T;G5sI&lIBm9(twiqV8 zJ)R@k<2 z`)N*jB4TTXD5ymJZp9U4=CAR9BtRLOMlDQZBxA1@QZE-%Z}RLLeCjqSj=h{k?<6KV ztw6XzE#F7ESE_GxIDjIPCDIG@m^SukVG`7hnS6gXXVg)BdwT`6C%U|dC}5!KM`7MG zq02Ts5clT_1C$728sa!~4N(G|u4xi&5$$tZrc#+;_pntA6)DC!JV+s}9G^oAbQ%%a zMiC+W3R$ZS-AMEI89S0`_xaTm^=^Fh1B=WCaTEN>SV8^rI=-K4{QL(;(qH8l1+Ck| zUFxe=nagS+D!e41e_=p3rFIW|1DOsZnajF;RsY6Y1_h*lJTdly>OGOR41uJncOV!& zY)YPKR<+}$>&P#1RG*k;!Q%vx9Z2%WH@-D_e}8R_XnOq^IuTIFBkvN;)T*?)#x9xN z-KwS#9jijiIxnfLQlazOZIKdw+>cSTZIh~0y7 zYO`D98*6ib6RmJ*J*f2u}=j`hKZs6B@Y?ARZSGjnfaqeMQg?fCN! zP0gR&JI{;s_Q|~$e-a=|03)|F?IkXGJJ!o?2WNL7Y=3a}>XduU{bp=Cx7Kp^Qm!Km z*L`2Nsdqjp2-Oz&CLZ3rmJ>_g|HgiQW}9iI$L3L{Ya!;abM$z3gXm7`Be$Vpzw?tZ ziEMQ}kFmT`CRe~in~mMWFG;59-mKje-rH}oHrTcP+O-x%uc=pJ^o~zJOQ9HuO8pkz z5%_rhwJrW$g8?o)yoW;n+~tdCMK%B$_uzCP*rFQTa^)SNE14UOgG@bndp09fk zrYCVPQm%DmPx@w}!&7V+2JlRWnfGpvWhIBV?q{|rht;Mq$MQ*jGrECg;#-csF}%K8 z7x$=94edr&3hoUmSwDU&VdnPuI?U)HS9w>iVz9kqSj5kq{bEzEbX7ZMFka@1gmotG z(lE#G0gJK+k;;RTpSaYc_QdgycB?XYs}Ju4vSrx>F4iJW8U7SoO29Er<0qojOw~F0 zdYYE#?+!ZMn0#zJwUy9b=iyB6cD?<5Tvkak7Cm$j^aiGZhFVSwKY0_HPiP}w87C`Y z-+EZX5nocrOf2>;R?@3%BAroO&JD1MrL~>}Wm?H%+3|imns0tfW^>G=($33IiNsOe zdx!k1;PtPFk6!sO#^_I^XZUB3{ZquJCodzT4BN|r)X$CrJ8fJxy^O}G&;etb@5w|< z(}*y>kxoy-#ItTyuYx&LHeiE ziFTD=^1_+7BsGttc}w*K{oi(xGk~$+{@4TaXVCqVU7oIPrcT!0)=sRRzMdYpsJl=Q z|II{tVw7tM`KO%=3Ic-spO`ddq|`K}1E$9tzOq9=Om}TTt!9UmfAVlnL&OR zDFxFtFy0Tjlp|k{Z^(vHv*^I!FPhRTN%vK3n`TGzV^3^!aHDDA;4_@-3)c&1d;EB6 zBtKs>s|FcGeF9KAxJQyy9wJ7^hz6tyS-aazRY1ynX#NQ1JVcSGQ@j&L-5? zgL+X&1ul$5JcT=u4lIK@M+jU>tUG0+psT2`Py?^7Ro6+f_v3)UQ?*pJKwXbUP#e0r z7Rl-+%WVG_FYjt-0qHeuAVkK4|5HP&^Zf zuDySO|D&Pf@8G|ed;bDoBK{lvpT*z*ME~EiC4ZqW@cut?Cx55=yA=PT+oJggy8jX8 z-?{!SpTD?#X#auhzr^%+&c6%k|8O>i^!^j)zh$Ma1p6;JL%{zzZ~v&#{7;4n0^)xG DG@Nv1 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9040.tar.gz b/dist/amr-3.0.1.9040.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..d99998209f4a62976b28f5a983f2d1ec7ab7767a GIT binary patch literal 10470 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

Qu-|K5Pm3ni1AWFPb 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