From 30b1c0a5980a76176770c416e806e8b46821eb77 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 7 Jan 2026 10:02:22 +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 | 223 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 920 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9012-py3-none-any.whl | Bin 0 -> 10514 bytes dist/amr-3.0.1.9012.tar.gz | Bin 0 -> 10344 bytes setup.py | 27 + 12 files changed, 1658 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.9012-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9012.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..5a2ecfc17 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9012 +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..7067250ce --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,223 @@ +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 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 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 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 eucast_rules +from .functions import eucast_dosage +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 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..dbbd4a128 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,920 @@ +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 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 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 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 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 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 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 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.9012-py3-none-any.whl b/dist/amr-3.0.1.9012-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..b48368689791d54659b833e5c37d3cc650cec6c9 GIT binary patch literal 10514 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 YQjmuHmzF`G|K9iilH%X?5(vou0?Z3FF8}}l literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9012.tar.gz b/dist/amr-3.0.1.9012.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..86c31450279ba1b2ab0efb3c83614c61bf1fc4f3 GIT binary patch literal 10344 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