From b9ebedb38cb48fd26538bdc2732a3b2cfbd9ba0c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 2 Apr 2026 10:25:07 +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 | 228 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 940 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9043-py3-none-any.whl | Bin 0 -> 10603 bytes dist/amr-3.0.1.9043.tar.gz | Bin 0 -> 10462 bytes setup.py | 27 + 12 files changed, 1683 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.9043-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9043.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..97ea21e55 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9043 +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..42012c791 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,228 @@ +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 amr_course +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 ionophores +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..4f28a517f --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,940 @@ +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 amr_course(github_repo, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_course(github_repo, *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 ionophores(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.ionophores(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.9043-py3-none-any.whl b/dist/amr-3.0.1.9043-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..4776f00cc8306010282a6b3f5a4aefb2396a356e GIT binary patch literal 10603 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9043.tar.gz b/dist/amr-3.0.1.9043.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b9175ec6becd75ae133b52bb6470b32acbec0046 GIT binary patch literal 10462 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 YJ(RQkU(8_fbqL}Y@q8nw18AuK0jc`r@c;k- literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..b5221da20 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9043', + 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', +)