From 5a6de872e3ed8cfa4762f2682e147e94f858048d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 8 Mar 2026 10:32:07 +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 | 226 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 932 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9031-py3-none-any.whl | Bin 0 -> 10558 bytes dist/amr-3.0.1.9031.tar.gz | Bin 0 -> 10427 bytes setup.py | 27 + 12 files changed, 1673 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.1.9031-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9031.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..6dcd8fe64 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9031 +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..abf581284 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,226 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import peptides +from .functions import phenicols +from .functions import phosphonics +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import spiropyrimidinetriones +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import custom_mdro_guideline +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import interpretive_rules +from .functions import eucast_rules +from .functions import clsi_rules +from .functions import eucast_dosage +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..bf9cdc0f8 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + except Exception as e: + print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = robjects.r(''' + df <- AMR::example_isolates + df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } + }) + df <- df[, !sapply(df, is.list)] + df + ''') + example_isolates['date'] = pd.to_datetime(example_isolates['date']) + + # microorganisms + microorganisms = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]') + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..0c11968a2 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,932 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def peptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.peptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phosphonics(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phosphonics(only_sir_columns = False, *args, **kwargs) +@r_to_python +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.polymyxins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.quinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rifamycins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.streptogramins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs) +@r_to_python +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs) +@r_to_python +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_class(amr_class, *args, **kwargs) +@r_to_python +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(filter, *args, **kwargs) +@r_to_python +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs) +@r_to_python +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs) +@r_to_python +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs) +@r_to_python +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(x, *args, **kwargs) +@r_to_python +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_ab(x) +@r_to_python +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_reset_session(*args, **kwargs) +@r_to_python +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_av(x, *args, **kwargs) +@r_to_python +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_av(x) +@r_to_python +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_disk(x, *args, **kwargs) +@r_to_python +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_disk(x) +@r_to_python +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mic(x, *args, **kwargs) +@r_to_python +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mic(x) +@r_to_python +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(x, *args, **kwargs) +@r_to_python +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p50(x, *args, **kwargs) +@r_to_python +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p90(x, *args, **kwargs) +@r_to_python +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(x, *args, **kwargs) +@r_to_python +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mo(x) +@r_to_python +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_uncertainties(*args, **kwargs) +@r_to_python +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_renamed(*args, **kwargs) +@r_to_python +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_failures(*args, **kwargs) +@r_to_python +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_reset_session(*args, **kwargs) +@r_to_python +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_cleaning_regex(*args, **kwargs) +@r_to_python +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_sir(x, *args, **kwargs) +@r_to_python +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir(x) +@r_to_python +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir_eligible(x, *args, **kwargs) +@r_to_python +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_interpretation_history(clean) +@r_to_python +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_property(atc_code, *args, **kwargs) +@r_to_python +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_groups(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd_units(atc_code, *args, **kwargs) +@r_to_python +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_from_text(text, *args, **kwargs) +@r_to_python +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_name(x, *args, **kwargs) +@r_to_python +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_cid(x, *args, **kwargs) +@r_to_python +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_synonyms(x, *args, **kwargs) +@r_to_python +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_tradenames(x, *args, **kwargs) +@r_to_python +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_group(x, *args, **kwargs) +@r_to_python +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_atc(x, *args, **kwargs) +@r_to_python +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_loinc(x, *args, **kwargs) +@r_to_python +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd(x, *args, **kwargs) +@r_to_python +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd_units(x, *args, **kwargs) +@r_to_python +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_info(x, *args, **kwargs) +@r_to_python +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_url(x, *args, **kwargs) +@r_to_python +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_property(x, *args, **kwargs) +@r_to_python +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.availability(tbl, *args, **kwargs) +@r_to_python +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.bug_drug_combinations(x, *args, **kwargs) +@r_to_python +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_resistant(*args, **kwargs) +@r_to_python +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_susceptible(*args, **kwargs) +@r_to_python +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_S(*args, **kwargs) +@r_to_python +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_SI(*args, **kwargs) +@r_to_python +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_I(*args, **kwargs) +@r_to_python +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_IR(*args, **kwargs) +@r_to_python +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_R(*args, **kwargs) +@r_to_python +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_all(*args, **kwargs) +@r_to_python +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.n_sir(*args, **kwargs) +@r_to_python +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(data, *args, **kwargs) +@r_to_python +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_eucast_rules(*args, **kwargs) +@r_to_python +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_mdro_guideline(*args, **kwargs) +@r_to_python +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def interpretive_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.interpretive_rules(x, *args, **kwargs) +@r_to_python +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def clsi_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clsi_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.translate_AMR(x, *args, **kwargs) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.1.9031-py3-none-any.whl b/dist/amr-3.0.1.9031-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..aea8ec0ffbcb2cbf0fd2aac799547ca7a7e6d321 GIT binary patch literal 10558 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