From c60db1c320bb675199fef85c8bbc9d256561bbe1 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 8 Jan 2026 13:05: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.9017-py3-none-any.whl | Bin 0 -> 10515 bytes dist/amr-3.0.1.9017.tar.gz | Bin 0 -> 10351 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.9017-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9017.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..981b10d12 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9017 +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.9017-py3-none-any.whl b/dist/amr-3.0.1.9017-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..0dca978a24eb9b74dd15a5515a3d42eb1ba87ae3 GIT binary patch literal 10515 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9017.tar.gz b/dist/amr-3.0.1.9017.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6c470e3bdddc7f464f034e0c6626263426431ece GIT binary patch literal 10351 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..b27fee338 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9017', + packages=find_packages(), + install_requires=[ + 'rpy2', + 'numpy', + 'pandas', + ], + author='Matthijs Berends', + author_email='m.s.berends@umcg.nl', + description='A Python wrapper for the AMR R package', + long_description=open('README.md').read(), + long_description_content_type='text/markdown', + url='https://github.com/msberends/AMR', + project_urls={ + 'Bug Tracker': 'https://github.com/msberends/AMR/issues', + }, + license='GPL 2', + classifiers=[ + 'Programming Language :: Python :: 3', + 'Operating System :: OS Independent', + ], + python_requires='>=3.6', +)