From a481ea7a785e28dd32d9c33b35398cc2be781d44 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 7 Mar 2026 17:08:26 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 ++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 226 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 932 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9030-py3-none-any.whl | Bin 0 -> 10556 bytes dist/amr-3.0.1.9030.tar.gz | Bin 0 -> 10419 bytes setup.py | 27 + 12 files changed, 1673 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.1.9030-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9030.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..07195f0e7 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9030 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..abf581284 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,226 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import peptides +from .functions import phenicols +from .functions import phosphonics +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import spiropyrimidinetriones +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import custom_mdro_guideline +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import interpretive_rules +from .functions import eucast_rules +from .functions import clsi_rules +from .functions import eucast_dosage +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..bf9cdc0f8 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + except Exception as e: + print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = robjects.r(''' + df <- AMR::example_isolates + df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } + }) + df <- df[, !sapply(df, is.list)] + df + ''') + example_isolates['date'] = pd.to_datetime(example_isolates['date']) + + # microorganisms + microorganisms = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]') + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..0c11968a2 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,932 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def peptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.peptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phosphonics(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phosphonics(only_sir_columns = False, *args, **kwargs) +@r_to_python +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.polymyxins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.quinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rifamycins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.streptogramins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs) +@r_to_python +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs) +@r_to_python +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_class(amr_class, *args, **kwargs) +@r_to_python +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(filter, *args, **kwargs) +@r_to_python +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs) +@r_to_python +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs) +@r_to_python +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs) +@r_to_python +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(x, *args, **kwargs) +@r_to_python +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_ab(x) +@r_to_python +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_reset_session(*args, **kwargs) +@r_to_python +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_av(x, *args, **kwargs) +@r_to_python +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_av(x) +@r_to_python +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_disk(x, *args, **kwargs) +@r_to_python +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_disk(x) +@r_to_python +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mic(x, *args, **kwargs) +@r_to_python +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mic(x) +@r_to_python +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(x, *args, **kwargs) +@r_to_python +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p50(x, *args, **kwargs) +@r_to_python +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p90(x, *args, **kwargs) +@r_to_python +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(x, *args, **kwargs) +@r_to_python +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mo(x) +@r_to_python +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_uncertainties(*args, **kwargs) +@r_to_python +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_renamed(*args, **kwargs) +@r_to_python +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_failures(*args, **kwargs) +@r_to_python +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_reset_session(*args, **kwargs) +@r_to_python +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_cleaning_regex(*args, **kwargs) +@r_to_python +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_sir(x, *args, **kwargs) +@r_to_python +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir(x) +@r_to_python +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir_eligible(x, *args, **kwargs) +@r_to_python +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_interpretation_history(clean) +@r_to_python +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_property(atc_code, *args, **kwargs) +@r_to_python +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_groups(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd_units(atc_code, *args, **kwargs) +@r_to_python +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_from_text(text, *args, **kwargs) +@r_to_python +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_name(x, *args, **kwargs) +@r_to_python +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_cid(x, *args, **kwargs) +@r_to_python +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_synonyms(x, *args, **kwargs) +@r_to_python +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_tradenames(x, *args, **kwargs) +@r_to_python +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_group(x, *args, **kwargs) +@r_to_python +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_atc(x, *args, **kwargs) +@r_to_python +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_loinc(x, *args, **kwargs) +@r_to_python +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd(x, *args, **kwargs) +@r_to_python +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd_units(x, *args, **kwargs) +@r_to_python +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_info(x, *args, **kwargs) +@r_to_python +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_url(x, *args, **kwargs) +@r_to_python +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_property(x, *args, **kwargs) +@r_to_python +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.availability(tbl, *args, **kwargs) +@r_to_python +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.bug_drug_combinations(x, *args, **kwargs) +@r_to_python +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_resistant(*args, **kwargs) +@r_to_python +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_susceptible(*args, **kwargs) +@r_to_python +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_S(*args, **kwargs) +@r_to_python +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_SI(*args, **kwargs) +@r_to_python +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_I(*args, **kwargs) +@r_to_python +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_IR(*args, **kwargs) +@r_to_python +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_R(*args, **kwargs) +@r_to_python +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_all(*args, **kwargs) +@r_to_python +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.n_sir(*args, **kwargs) +@r_to_python +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(data, *args, **kwargs) +@r_to_python +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_eucast_rules(*args, **kwargs) +@r_to_python +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_mdro_guideline(*args, **kwargs) +@r_to_python +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def interpretive_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.interpretive_rules(x, *args, **kwargs) +@r_to_python +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def clsi_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clsi_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.translate_AMR(x, *args, **kwargs) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.1.9030-py3-none-any.whl b/dist/amr-3.0.1.9030-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..6a3423d2d42255994d0d67134475f4f043b7cbe6 GIT binary patch literal 10556 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 HARzw-T1;EJ literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9030.tar.gz b/dist/amr-3.0.1.9030.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..54684a7c8dbe62cc8cb60fb489d623dd40f0989d GIT binary patch literal 10419 zcmciIMNk}2n=W81xVw|!?hw3jcMI#_HU^^S$^!1!lARdJ`K&r4j(JLgqaoLZF^5VcZ`Oo(NWLtGqv$opPU0!L^oXh z$Tbrhd;}YqekX2X8%zg}uKd4iSr2~&rCIPrUg^KF_11u&{Dv2PlP|sXiUDt;w}t(J znPSX{#UGRUX6#+$x7WQkq#(x@E~_Ny{=KtJK(B3pu&wao8t`3e=f-CJ!t<5P=H2MI z^bwMFO9**V8T)wbmnytYdOI?8783az!g7ugIea8z@t*tvP!v+Jg8Fj@SgI|(>TieW zKS6$Y2M8=bL8em;Kp|qSbqF*%y8ROn>I1kfcp*&L8+8dWuKFm9>{AfHPp}<1j9z!z zkK!=(UPdFeT2Hy2&z550$g%%kd>zI0dm}|(N>aFqO_r~@T0_c0pvaxpGhS}uTxoyH zC@)PJXD;4xPaltuLorIa0lJW&^4f=}=Kz z#zeGLaUoo40P**`?H}PmI3*$B6Cu(mD;Bz$LTj=EbrXDTz13`!%HlGqB;i2=Lq584 zFi?u;m-D~H6Sn;ZJP6Ue{VnRzP1lmw7A~;_%v0-r5YCDpy~TqwngH5_~mgsQ5o za5$aBv-zB}&!RDCytaJB14wBe82B^QM>01OLv}e+=Q6GmQz6zoWu%cx3^KPpUrsu6 z-F{OCokIjeD!c+3^@uvV;FzN=iDAt_WFI@;naZ$jAwsI6s+@8miDaMzJ1+)8ZW;Ll ze}fO|*iYut=PGH*+F{Bstt^;Xk~(Oejpp>(=0tr|UxH8b-$XT)U|0@Vuc_&OZwddX z#Pw?^i>Gfg6*7oqw+Ydi$Df>vJH+HW8&lS{I#di)X&~Xyl=?-Zd`2w^6*uY*2=332 zl$&sppvi!TfZo=Q&&zCngh8AAQEB&1DK z(8^X+igT^&At?fyzH4K(3cj2BoR07ggv5cwwNE6s z(2MUJGHP=tph>K_OY%e1s-6G?PJWlGCeZ0-T3H+@q}c*+E3=l;UsAyFAp;gKNT^is z4W=&{zx1=6NVausVR`H%=~_rK%*4KHHM*|vTMfmtn@KBP5BR%e@uc^EEgH!%Jo?(? ziMD1!%A4R_jB&LQP>E0xb95O2K}oi_arrPHbWupn#N3amgJ)C z4|_ocq!0={=5*x(ngZ%$g!}TePV7*UrYgq8sv&{g||e)5KVY2AW`ZrmDzXfCe%gHwWFHS1G}8IC9zgI8P-cv zF}L@0YNGZ_30d9g6d74_8iQwj+8TrNOUAw>D|Q_6yXQFYeiDIqS1-&~@u!I+;?eHA zAu1D5&`bFmQO%wRA5hX>l(9|q=Z4_px)z?BjRcFQ=%RKv^KP2>MJF@)~rdzO7pxn__ywBoYg6c?=H8 zr>ifw*aY+vZ|wFAop@Trs`rtz>vliWAR%X0h&_L@1;k8!GSNCiXEr0{UR^+njCB4M`t;VTGPc;EqvCP;5JoU$G9{gc}ye zW;p{fY5ZgO?dvBCg9NNk(V8m_3I`NZ;#u}XaUBN8e%e8&oQ?mvYHG!R2n*7WZ}usA!md?l=b+4~^Af7Rv*RfjY)9?U6Mwt7eVdzJWBIO__-b={En_lq)EHSmQy+;b=cuEyC0BH9X~iYZppd;5*yeYA$~orKiR z&DRV5YMi6E6W`@qUn%kdED@Wro_zE@i|Y3$dp&Kh$w)=pilLMlt{kroYk2!e<}sU# z<*g}aNH|LqRL!Soz*ph}UW|$2r}}>P=1{4U^$gXOYofX$c|#_0x=SK+1SJdNt;jPf zA0y2^-g212f^@(pz*o$6d6i(Y6Gd8RM9-a~lHinkGjP)=FWu=yyv_6_7ohM>4#j8eD80kay=mSX)qoe&R%`X%T6JJeI3-k z#9fEYr?o@@^!O@-YfehAH3dtsti1EHS{6u$NGE^&>kVBO(G{b-YT^$(-c=^{=DZ&Z zFb3zAu{`IY+dM{`4=2xBC3n-f-%qmKJEjQ&w?EfNNp|RFMOPRcJwc&*KJxnCa_yOa z-_h`w@cWQygq%N8^n&lD8X>rGU=;kgjwCwO>kdz_8rPAh(q z7;a|3a+(;A36*m3(_W;ps?qp?iqJ`N&wlIX` z%fd1@<+DQByoLxLS|)iR17W`=H*^VnI(GAsjpG_8BWGkZ0)Wk587jQn%JaZ5nQY}% zCX=}QT8q5Yj8`lIWSs!^}h+eXn9)s&T%zH5`l7VwM5Du)rB)T{&LQ4HD zC%#mGcGJvI1XQce27=MlVE(oVRXs(X(@8$`Or5r@L8r0%-A)IJt>N6)K3{b}0*q@05msAgt^t6$%4dJJl7GcF+ zW0VM#UvNehXwm`Gh+hbJv!~)!s?q=;PYxRoCkbLn{uYl2C{=U2fuSdJ;@JVYz<1Co z{`IOPC}q`+S5MYL3+n>EDeMt{V!or#2uH*@UI;Au$@p`DLexQx?+D=pGj)dp_6EnW zNSt1e9!cJvw0S@`n`?EJ>RH~*5nuFd_s$}tG3z}l35A3}hG=;9y~@63uwjf;bPs5~ zA^`&RSZQ5^o|=rYO&J&GhrHhyO1bK_r4Hxy3A?$^S|0~5gf)z6r2n-?0So;&I9%u^ zKR`fodsr+pfvUd*G&d-Q;BJRsLpN zhAM5+o^<>wY*%V;TK+K!->dGZ9;P%;%f-`EudAU_i?~;T=zv5F{mSjNU1@AsHJ}#b z!_tz+xNn&}5+Hh}3e$rqLu0l=Z44_ngAgQ80q6H6*>0u=sULlbm#*9==_)ygw_yor zXOvr9vv0-1Uap7A15G>MriH0Q6Uoh==lCwPGHOxbwd;hi}3)dQAnZ(unfd zXinePb;sQ`7-XiIhYwZxpF4!PPsFo4UEE=beFn2^B!K>kX?v{YGB^6zRE!Z_j+bJsWugvEB6%O&goeLSU91 z`xNNl=w}`RU7g&Sg>1zBA>*ziQe7c=G5gVTIK!d$5jARgP9I>^arT>xKmE*IuPCyQ zA(?s!XX~^0&tF%YzD&sO{($tY?aZV^wd@0b*qzgtd%}E?{AT0l(^OyO{)iT zLa99bC}xIVe*#sJJ6UGq)N?l8g11i}TW?ZDl7T-2h80YWu0N^YIO+Qk=L`ivEC))S z-~L$FRnNQyh9LVG334b~CSD`Bf8SfY@J9Z3>O7dlwWK?ZoFo6k?NgsW2I3Jv!Av?* z{^%`X_**47mXKzHZ)c*!+u$z$ta-y8%Rm>!bc4+6m9}KhR3uxmXe`U{#9;z*t$KwL$ zoU*7>3Rf+fp?L(7^98=5vz3vnBF*E@1bc48({A)cQS#kL@ww~BKp*9+qPKcxp0{>Md zd${eWRyOMCI#+x_Rj4e9D0bcCFwW@Y?)wjab9ARp3f3)yZt|eVUi4(qTJxnFVS`?y zh}i+|r4CJ<;|-+z^zKX802<%gQQ8yK(l`3aOi~>(72RbDE&kdFx_#$jqxaF#z(Y3H z<(U4?bsF%Ycn&Boj_f}W`ww{jLEAsrIbvhQ{SPqwe?4$x-#XSA{_ctAbOQek0kh!7 z{R94gkpB-1|3P}pKlt(w>i+{rV3w+@`IxKq8%ZHoO_O5ulzoL~3oD&3@8++6N1kl_ z6mwv%76`NV-=qPzhi%Urh3`0H#6nu6l5!(S@gt*fJU+=^Y7P(eurAkrVfAZ%x|<%$ z)(Yu?J!I1QY|JxOhkSe*U429!sv9oZ6ek~3m0>iToxxze`XfPRoBpQ0hcpoiNIacE zLz`d{E>HSt*O6yXb27$0qK`wtA?|?qJ7dps(dKF7&Vi{#q_whxx!KY9LJ09SA2BSB zq*0TE&D>?t!4uif&y9g95$q^vt}%Q=!h?}r@mFvvm|R2Ay12DPUMsTU&hWxs_DxVa z?V7$EI$^S(-*opu%~(}fH|mKM*uv-~cJc9T!Ei$CP1_*ReOPLtHl>Wj9nzfO+Hk4P zE5c_lCW~6)A?$~zcdfQwlMM^82=YC|43ll+!iOsM?X`WZd}GXw-}_mm)#?48aK01S zFU4@Od={fV$KmjFSW3*sS`ys5-?0=Fj?oB7Tp-n>G48LOUb}uiLP=`j4Z3%9{u7Rg zr?`Q>566+S&aIu%X4n)%2|sf>)zXf`7h(X zb3-oRp*3U-EAtuRa#~Fdi#6W&U)pryiM-`a8$v%S@}1}RlWi7j*45 zJf9Xw>J~TSpyCVPE%UV#5|yi5Jx5RqrMWpx zc5IcThE(vk&sZfDNbks6If=6Khzns-8l$?kp_C(6a4C#9N&oiOrWOR>>RmcjQw5jk zv--7J>!M6cb);R2EGMdaqI(@s5nV_dLPeg08_T5*E7L=p9{xqcYLQk<B0dC5JMFkXm)*mVYIBL^VOON4{8L7BVuWk`{qsBW$d86lN`WngxS3>W2wi8|C$)-_SW$!6aiK^5qLg(aXg!yzHQCbH66?`?TQ#)2E=XmuvDN{kwR*>igcq z4T_>swAmx=nnd_zCU8e=kIeDeCf~0n!1)YZ9X7GGsZ>FTck8)#y-?hRlCc zSq_K7Cj2X21x9g%3^KTyZ&?z2q@@k&I`dsV3JimFA!UI1z;l$&`BikmUgdt+guOqZ z{8vpImxz0!9smmnfGFwK8Dg<*4AFmh0e1q(pT>@k$k#)`HrxWfl4BSfkYTtZWzD6P z6Z4P|2#syZBVWChCo-ZRhBATQAW|fnO_J@B00{0hG&E=7oM}*LlL~ z#w@iNgEAj?B_lt4lp^xe(R!w*>k)Y8cY2niy!X90)3eUUcquEJd$z5lf>$HdG8q6f z>^@3T*YD6{XJ*K%zA$(u@z5O`etOU-2djf*pmb7ah zVb6~n=Ue(S@jo|2lVQojKr$niM!qy(3ksFuhFUq6XZ|RThn=XH#a#IM_QX3|$`6LMw_MC3un}KZCImAFw4(@J0r>d&fYyY}KtYEf9Li8Ti zfJK}$iGzMd#WyVSuILkKlx`G1B0YP2w45+2j5Jj`8o>&ShrLsXYRw4D3cLA4+*z;- z?_A;d{dI6-W05sigIK33o@M;$xs$DA00xECd`$fh8~I(r*#*_mx$0w>=HjGo(qliFRSN zRb>u1SP6{zFy6l~Zm9(70*Q-m3Qkfi$42z+LVqvRA+6bXr%ruyhddzyrDWC%5Te4B z#pH_E)<2Un=TL=PArIQ>mSo~y&FVi`)-VUW+dT>%Z;tiFVIbr3U6aqx=8Y68JL0?@ zZ^eT+sicD)VjFl0NQ$L_ z0^_~7rUr+6F+8s|=@cp;rpZ*X!6cv`qVfr~ROvCvq*%PiD?d>}nW~LHXE>ku{^#$C z_gud*7AuZ-7-mE`5T(fAT23%#exPsEcZ}MiqgHyzINv5HnMKu^Bm9MF{ZOEV+)WnW zhEkpC_2KuVeQ0UZkwzRG4US#p@}F>-9KE7gQWG4!<#l6}_Rc<${v)+3Dg#;w)^LM3 ztGx)Rnv*7oWVOOwXNB3n;=<ja z8Yx}z?vLcVha)1W;sHZ*<(+exG$}9|@VASHWjV z6gVP=6B)7l+zTaNW>kv3Gah4Wab|9dP$-7VECi&0RJ17B%jGf&rq{q8q~9F2l^UVZ zmzMR--iRFr4L(sYq5V~D{!B*CCaK87aJhupVZ(XYbZkXNB5Qn07_Q15o#<;ra+Uts zcrB48jcIpzws%M4XY2)C>{gMpcbKuY7X3oQzt+cNK(Q~$pFq5eao@1n70~9b@^ukJ zZ>_|<#3F7~DiHaPd|Qz>X0vCTU8#Lje5EF+a}9oH$E0;RZr3<&02J|ZhL#_0R??PP z&(4e`>wf^Pf7R|ntfpPm$);9xv= zyY=JJHaPbj3Nwur>a}|4+HF9GdVQ~tg((&LRvw}wH$x{C;34-xFIYI3Mbh4Li~lEg zfEkk;@y?B?%x+GGl{D{;L0ucLRh4gI(d59)m>^ai4A0$BUn`@U?fh)eKuN!pQSp9r zf3n++hJ|5cYR=X=0LMgfKk`Y5)3nCI|BqLrs+{7_9}C?oF&-2qtT8JsWVufEn1sO__wFABN3LK(Yo;+a**s$89pI;`>E?whcVy}< zH0xSeAU1VgCWv3$bBQ@+V$doKD6yA9_phaV6ILX_kGX!qXQu3Gp)?dcj?$JkyUY8f z=IxVLnvU;_MsGS+ASnesabnv6xTL_9a=R#a=>BL0iloIHI`1dZIqvS16%x^ z0mp?rhxk~eOZzXqly2j@ku=$wx}mg@CNc{1Ra`WR`w|f_EUFZDI1qjxH89&ZNAM<HM zj@r?t{x&@o7k)cOPx{AELsZ4NBc{qQqC}Ghj6Pq1cnPHo0kv?cOzEki2odW3Oz)r% zWQG&=m29(6^dct5;BRuyFcizEORkZ3e@^S5mWDkZo!Vf;T&2w6agy1s!>GQO(BWiA zi~kKz|9oP1`C8tWDI-O_vgV%(Pk7j&>%!PGnpEhH-18M?iq3JPF_}WjnTWmDPsN0| zqX<2ysihu-oq&(s>wNfQ`GIEnk8`|pV?mE!e(St)4+&<+x4+_Qli=h$c&GkJD-IeQ zZC-22Bi{3eRl#q_hw7-5*B%rUBWY_Y1;%8(L10HDNvt<>1zHNMk(2NCMA1As0YaGi zznWoERE#i0jNCm0@*lSs=W1B>Fk_s*#%{3wNKchNJOlRnJ#Kae-2Y}c2KRUb5{@n8 z+#1?(PQiVyis1@$sg_SYe^!<*RfD7_Nr#C6mnpcN(V<*l3=85uhyJ{xPMOgu-&<42 zJ#z5i{7XS`jX2a9@VcZ$Bq@rsWCY?%StlBqjm-(|^t(OuB$AY^)W`!n!Mq@THiC*S zggjo=@CO;s26)@HRCV#M`i;kpeBb!4HF#_qu<49yW**Ok(egqlLkG&U)weH4MBpc^ zVaFB4^TMn$*U8M-qb)#l4}KmovZ!`RE4K{We50k>dfP$hYNNQGE?rOirs5*+B_uFC z3fG@lH7!gz&YN`u@KD_Ho6CY-v|-AD^foXDV!E@XO?IIgEv=ED4ciC4#tIT188sHR zW0d7E8wucB2Haz&};}!0kj44Q^rvZS$zvP8ErvfWe;pNjm0WbUk++WyjB zA%1?5Uo}!m!+n#6C@p=I&jN^*(gyg7tuY zF_CS106~5djB(p;utn7V%9d?ugNXu7kA64!0p4Etg5o&|1qpH-)s8g0ecd;_N`v~S zH0UR0X_)&+`5@flMfNCpg?s^n1i2?MVnPioEm;L_;s723tR{83<$5 zXb%d-blsdEs8(JNH(t3eilBS34J>NQ##1fB4edue=u`sd!i!Vb#v!nK6W@9VYc`qL z^Fzz2QFw|Y7Bf3S0thD8us;v0EYkyLk^ZC z`2%K^h)TvnWQPqACu)}z&^;bhBe)etcVzUny>y-Fvv*&kbT{zh6GVJ&?XO{%)t?C=S<7{!@ySN-RS$Q z-2Mjq(ee3!f0qQ@R>k`=b?+k7E^;IE&(|9KEqRP|Y zE$@9+?e_2~%$Xa@V5GSDc0M+lwjH7C1=^AGS~H7+K9;t=YOGXjq92Lu=n9_j!DH@ucgE0~~^{jhxr7oi8CGjoLG^H9IM06yseGq*%P~iX9wx*pKG>t|ANuzAKCamu~kw z-oKJTl>QGQ5c22?gz)eQuIvE=f4=p{xtLINK?>u?wch#>K+WTJkY}i8AjKaL8;1Ku zeY2l^-7ax$$Jp=xr3glFN?5rq^n5>K;{o4a+=`9^!7$H|iYTb>OB=(Zz_BBW#IJ{d zq*rq?$ctD*hXXIy&5tDS`s~?wIWs~0pP%2OB5>kS7VT{n{@wS-M-mt;V{AMIqF@I2 zK(gW?9|tz~Z-rRONDm+g6oK*LL49H&NOGeV!hMpg=s3s82^6tw^RfGWEjnhI5EpoJ z^t?ni8TXJE9ruyJY03X`L{L7oiD2v0zOywE1~Tq(JgGH)>oiEm8v@=Rp|0XA21e@2 zxAO=H_wAbj@1bHo9v#98om`sP_@pUI^##YE)*U=%rT+b0@Mrhb^WVnEUfX5stJ?yc z?~fDxgyNk{xSWTB#Zc;8XUl&{UP%sz>ivruXYhJq(X|8Q^FyOE8r zn+I^6UsR(JyuA-3FgtsyN>;Owo=I literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..a1c3f58d9 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9030', + 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', +)