From ae20fba907f2bc9b533a9dfebc270cc5d96766a6 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 6 Mar 2026 12:12:21 +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.9027-py3-none-any.whl | Bin 0 -> 10559 bytes dist/amr-3.0.1.9027.tar.gz | Bin 0 -> 10439 bytes setup.py | 27 + 12 files changed, 1673 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.1.9027-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9027.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..64ef9d209 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9027 +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.9027-py3-none-any.whl b/dist/amr-3.0.1.9027-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..93159ad44a2d17f5d0848a20f3efffda31262bf8 GIT binary patch literal 10559 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 -~vW_KdhUhj;4Ue1V?T9Mozcf=Y7*u6XT=Z4yx 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 Mk@IhY2?XT-0GsP=rT_o{ literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9027.tar.gz b/dist/amr-3.0.1.9027.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c8ce461f774a33613270f103f872918e8d8a3f89 GIT binary patch literal 10439 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%0AI3FZf?*u&ri#yJwDKtZFEAB&4;Pp_cv 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 HSeX9<)Pc!; literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..85aba38b8 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9027', + 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', +)