From 824f5856e543ad189647f67c6c39f3589936f239 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 23 Mar 2026 09:40: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.9039-py3-none-any.whl | Bin 0 -> 10602 bytes dist/amr-3.0.1.9039.tar.gz | Bin 0 -> 10495 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.9039-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9039.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..16e0d771b --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9039 +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.9039-py3-none-any.whl b/dist/amr-3.0.1.9039-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..9d43f587012b8dcd0820a7dacc685df342e9af0a GIT binary patch literal 10602 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9039.tar.gz b/dist/amr-3.0.1.9039.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..be43a1b97c4b33a43908196ab28ccc877f52fd4c GIT binary patch literal 10495 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