From 72abacd7feb6343c006c5d3c1d2f1dbcef3d7c24 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 8 Jan 2026 11:29:52 +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 | 223 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 920 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9016-py3-none-any.whl | Bin 0 -> 10514 bytes dist/amr-3.0.1.9016.tar.gz | Bin 0 -> 10357 bytes setup.py | 27 + 12 files changed, 1658 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.9016-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9016.tar.gz create mode 100644 setup.py diff --git a/AMR.egg-info/PKG-INFO b/AMR.egg-info/PKG-INFO new file mode 100644 index 000000000..326396530 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9016 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..7067250ce --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,223 @@ +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 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 eucast_rules +from .functions import eucast_dosage +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..bf9cdc0f8 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + except Exception as e: + print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = robjects.r(''' + df <- AMR::example_isolates + df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } + }) + df <- df[, !sapply(df, is.list)] + df + ''') + example_isolates['date'] = pd.to_datetime(example_isolates['date']) + + # microorganisms + microorganisms = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]') + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..dbbd4a128 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,920 @@ +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 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 eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.translate_AMR(x, *args, **kwargs) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.1.9016-py3-none-any.whl b/dist/amr-3.0.1.9016-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..572465b2a736c639db32da8733a109d0ca828fc7 GIT binary patch literal 10514 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 TOUpozf6n{Ar1+=31O)V7PB=p~ literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9016.tar.gz b/dist/amr-3.0.1.9016.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..21edd119516993f97b876d6083dcb0f443c3e74c GIT binary patch literal 10357 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

9!@<(Hv3IyyRV4&48X3Z$8>s2AX8^S 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 a&+NM^