From a6ce62c197c9d456d8d025965f5c229335a49cc1 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 7 Aug 2025 14:26:13 +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 | 219 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 904 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.0.9018-py3-none-any.whl | Bin 0 -> 10440 bytes dist/amr-3.0.0.9018.tar.gz | Bin 0 -> 10301 bytes setup.py | 27 + 12 files changed, 1638 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.0.9018-py3-none-any.whl create mode 100644 dist/amr-3.0.0.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..d8a1854be --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.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..dba238d35 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,219 @@ +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_mic +from .functions import all_mic_predictors +from .functions import all_sir +from .functions import all_sir_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 polymyxins +from .functions import quinolones +from .functions import rifamycins +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..0916f6cb0 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,904 @@ +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_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_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 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 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 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.0.9018-py3-none-any.whl b/dist/amr-3.0.0.9018-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..ae951fd12925506c39bacf2b8f56f587d9e6a1a5 GIT binary patch literal 10440 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 G4fQ|mL4|+- literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..30402c57c --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.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', +)