From 86b36a4c3b8b1e2b02146a0945521662b1258866 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 16 Jan 2026 09:59:22 +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.9018-py3-none-any.whl | Bin 0 -> 10515 bytes dist/amr-3.0.1.9018.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.9018-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9018.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..fc75ac01e --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9018 +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.9018-py3-none-any.whl b/dist/amr-3.0.1.9018-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..6f3969f9b7bac4744737d7a0f32711a05211016c GIT binary patch literal 10515 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 Zs1#)&|0QM+=s)+}A1%WE=`VqR{1=p{S6Ki6 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9018.tar.gz b/dist/amr-3.0.1.9018.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..a6a2fb7f66738c43906ce4f5237ad4d7d78c9816 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..bce2bbe95 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9018', + 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', +)