From 2eac8c65f50444c89a589cd40b392657daf1fb36 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 22 Mar 2026 19:48:10 +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.9037-py3-none-any.whl | Bin 0 -> 10603 bytes dist/amr-3.0.1.9037.tar.gz | Bin 0 -> 10480 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.9037-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9037.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..10140f681 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9037 +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.9037-py3-none-any.whl b/dist/amr-3.0.1.9037-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..14c503575d367c12ae3c0a7f9a16c806b67ac8b2 GIT binary patch literal 10603 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9037.tar.gz b/dist/amr-3.0.1.9037.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..57570866d962233a59e860eb5b455ee77c38426a GIT binary patch literal 10480 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..0c359977f --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9037', + 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', +)