From 1f3e3ac9b2a32bc65e222c3c1a2045fae3481790 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 3 Mar 2026 14:45:40 +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.9022-py3-none-any.whl | Bin 0 -> 10558 bytes dist/amr-3.0.1.9022.tar.gz | Bin 0 -> 10436 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.9022-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9022.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..9b5c693e1 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9022 +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.9022-py3-none-any.whl b/dist/amr-3.0.1.9022-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..34df56b29b3ec38a196ca8f818d1ea8a6c778be4 GIT binary patch literal 10558 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 L?0@o0ARzw>P~LEA literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9022.tar.gz b/dist/amr-3.0.1.9022.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ec8adbed9fb96a9cf1ae8c47056d9b04cebba440 GIT binary patch literal 10436 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