From e81b73215308332e22217b79ce8d0373e59a6466 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 8 Mar 2026 19:39:49 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 ++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 226 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 932 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9032-py3-none-any.whl | Bin 0 -> 10558 bytes dist/amr-3.0.1.9032.tar.gz | Bin 0 -> 10439 bytes setup.py | 27 + 12 files changed, 1673 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.1.9032-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9032.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..0821801d4 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9032 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..abf581284 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,226 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import peptides +from .functions import phenicols +from .functions import phosphonics +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import spiropyrimidinetriones +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import custom_mdro_guideline +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import interpretive_rules +from .functions import eucast_rules +from .functions import clsi_rules +from .functions import eucast_dosage +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..bf9cdc0f8 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + except Exception as e: + print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = robjects.r(''' + df <- AMR::example_isolates + df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } + }) + df <- df[, !sapply(df, is.list)] + df + ''') + example_isolates['date'] = pd.to_datetime(example_isolates['date']) + + # microorganisms + microorganisms = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]') + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..0c11968a2 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,932 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def peptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.peptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phosphonics(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phosphonics(only_sir_columns = False, *args, **kwargs) +@r_to_python +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.polymyxins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.quinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rifamycins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.streptogramins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs) +@r_to_python +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs) +@r_to_python +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_class(amr_class, *args, **kwargs) +@r_to_python +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(filter, *args, **kwargs) +@r_to_python +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs) +@r_to_python +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs) +@r_to_python +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs) +@r_to_python +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(x, *args, **kwargs) +@r_to_python +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_ab(x) +@r_to_python +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_reset_session(*args, **kwargs) +@r_to_python +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_av(x, *args, **kwargs) +@r_to_python +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_av(x) +@r_to_python +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_disk(x, *args, **kwargs) +@r_to_python +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_disk(x) +@r_to_python +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mic(x, *args, **kwargs) +@r_to_python +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mic(x) +@r_to_python +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(x, *args, **kwargs) +@r_to_python +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p50(x, *args, **kwargs) +@r_to_python +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p90(x, *args, **kwargs) +@r_to_python +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(x, *args, **kwargs) +@r_to_python +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mo(x) +@r_to_python +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_uncertainties(*args, **kwargs) +@r_to_python +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_renamed(*args, **kwargs) +@r_to_python +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_failures(*args, **kwargs) +@r_to_python +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_reset_session(*args, **kwargs) +@r_to_python +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_cleaning_regex(*args, **kwargs) +@r_to_python +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_sir(x, *args, **kwargs) +@r_to_python +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir(x) +@r_to_python +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir_eligible(x, *args, **kwargs) +@r_to_python +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_interpretation_history(clean) +@r_to_python +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_property(atc_code, *args, **kwargs) +@r_to_python +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_groups(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd_units(atc_code, *args, **kwargs) +@r_to_python +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_from_text(text, *args, **kwargs) +@r_to_python +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_name(x, *args, **kwargs) +@r_to_python +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_cid(x, *args, **kwargs) +@r_to_python +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_synonyms(x, *args, **kwargs) +@r_to_python +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_tradenames(x, *args, **kwargs) +@r_to_python +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_group(x, *args, **kwargs) +@r_to_python +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_atc(x, *args, **kwargs) +@r_to_python +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_loinc(x, *args, **kwargs) +@r_to_python +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd(x, *args, **kwargs) +@r_to_python +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd_units(x, *args, **kwargs) +@r_to_python +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_info(x, *args, **kwargs) +@r_to_python +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_url(x, *args, **kwargs) +@r_to_python +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_property(x, *args, **kwargs) +@r_to_python +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.availability(tbl, *args, **kwargs) +@r_to_python +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.bug_drug_combinations(x, *args, **kwargs) +@r_to_python +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_resistant(*args, **kwargs) +@r_to_python +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_susceptible(*args, **kwargs) +@r_to_python +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_S(*args, **kwargs) +@r_to_python +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_SI(*args, **kwargs) +@r_to_python +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_I(*args, **kwargs) +@r_to_python +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_IR(*args, **kwargs) +@r_to_python +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_R(*args, **kwargs) +@r_to_python +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_all(*args, **kwargs) +@r_to_python +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.n_sir(*args, **kwargs) +@r_to_python +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(data, *args, **kwargs) +@r_to_python +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_eucast_rules(*args, **kwargs) +@r_to_python +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_mdro_guideline(*args, **kwargs) +@r_to_python +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def interpretive_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.interpretive_rules(x, *args, **kwargs) +@r_to_python +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def clsi_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clsi_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.translate_AMR(x, *args, **kwargs) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.1.9032-py3-none-any.whl b/dist/amr-3.0.1.9032-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..73eafa97cca19194ff920dbab8cf6c9b8b407bca GIT binary patch literal 10558 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

&Mzqoos*f`qz=xQMz)v+kMWnsoX{ZCSYobF_tY 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 JeF+5Qe*xNaW)=Vd literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9032.tar.gz b/dist/amr-3.0.1.9032.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b50d800ef6f5f8a8a62280631625a584a1c06624 GIT binary patch literal 10439 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..f7a64318a --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9032', + 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', +)