From 768586bf996bbd2c2a3e1380bdafafe1fdc564a8 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 23 Jul 2025 20:15:04 +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.9016-py3-none-any.whl | Bin 0 -> 10440 bytes dist/amr-3.0.0.9016.tar.gz | Bin 0 -> 10310 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.9016-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9016.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..3c7183364 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9016 +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.9016-py3-none-any.whl b/dist/amr-3.0.0.9016-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..588a893e50464cb5335cf990a94ba6468da477dc GIT binary patch literal 10440 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9016.tar.gz b/dist/amr-3.0.0.9016.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..4261bf07b4a6c35a5b606087417cf5aa2748167d GIT binary patch literal 10310 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