From 82c2e0233f440c4c2ee876a3a7caf9bf8a35403f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 7 Jan 2026 14:11:35 +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.9014-py3-none-any.whl | Bin 0 -> 10515 bytes dist/amr-3.0.1.9014.tar.gz | Bin 0 -> 10358 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.9014-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9014.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..f5631b613 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9014 +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.9014-py3-none-any.whl b/dist/amr-3.0.1.9014-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..1acd5841f779a7825578abd9056d3107ed87c2e7 GIT binary patch literal 10515 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9014.tar.gz b/dist/amr-3.0.1.9014.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..d9c8f1bf2adcabac29b9745de98841ee9394caf3 GIT binary patch literal 10358 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 O@CZG