From 5cd743d77748106d237d7e2a1a5045ab3e21918c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 28 Jul 2025 10:25:59 +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.9017-py3-none-any.whl | Bin 0 -> 10441 bytes dist/amr-3.0.0.9017.tar.gz | Bin 0 -> 10290 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.9017-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9017.tar.gz create mode 100644 setup.py diff --git a/AMR.egg-info/PKG-INFO b/AMR.egg-info/PKG-INFO new file mode 100644 index 000000000..aa2800182 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9017 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..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.9017-py3-none-any.whl b/dist/amr-3.0.0.9017-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..03ca7d969f60dbf144a57d0c503695e46fbfbd6e GIT binary patch literal 10441 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 Dz(7+b literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9017.tar.gz b/dist/amr-3.0.0.9017.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c6ad7fbcf63426437a2b6e0e88ce0835b9a18dc3 GIT binary patch literal 10290 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..eb3ff7f7f --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9017', + packages=find_packages(), + install_requires=[ + 'rpy2', + 'numpy', + 'pandas', + ], + author='Matthijs Berends', + author_email='m.s.berends@umcg.nl', + description='A Python wrapper for the AMR R package', + long_description=open('README.md').read(), + long_description_content_type='text/markdown', + url='https://github.com/msberends/AMR', + project_urls={ + 'Bug Tracker': 'https://github.com/msberends/AMR/issues', + }, + license='GPL 2', + classifiers=[ + 'Programming Language :: Python :: 3', + 'Operating System :: OS Independent', + ], + python_requires='>=3.6', +)