From bc117ce1d2f4fd58913999fac6df680db668676d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 4 Mar 2026 08:04:41 +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.9023-py3-none-any.whl | Bin 0 -> 10556 bytes dist/amr-3.0.1.9023.tar.gz | Bin 0 -> 10425 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.9023-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9023.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..b2c9b437c --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9023 +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.9023-py3-none-any.whl b/dist/amr-3.0.1.9023-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..b0e3dd3ed53e4cf399eda7899825f826a1e6e910 GIT binary patch literal 10556 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 IB@mGR1p#4J00000 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9023.tar.gz b/dist/amr-3.0.1.9023.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..ed85068399ebcc37691a73732b582c9bdd040330 GIT binary patch literal 10425 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