From ae436a8386d96750dec32f93e65df55a47eed7d7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 17 Jul 2025 17:48:19 +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 | 219 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 904 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.0.9012-py3-none-any.whl | Bin 0 -> 10440 bytes dist/amr-3.0.0.9012.tar.gz | Bin 0 -> 10294 bytes setup.py | 27 + 12 files changed, 1638 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.0.9012-py3-none-any.whl create mode 100644 dist/amr-3.0.0.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..49298c37a --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.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..dba238d35 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,219 @@ +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_mic +from .functions import all_mic_predictors +from .functions import all_sir +from .functions import all_sir_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 polymyxins +from .functions import quinolones +from .functions import rifamycins +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..0916f6cb0 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,904 @@ +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_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_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 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 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 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.0.9012-py3-none-any.whl b/dist/amr-3.0.0.9012-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..3f07423b0b5ef0c403906f62a346901a717267eb GIT binary patch literal 10440 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