From 8aee5db89269b21377de7bb4c13b67e8884fe90f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 6 Jan 2026 22:12:24 +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 | 223 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 920 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9008-py3-none-any.whl | Bin 0 -> 10514 bytes dist/amr-3.0.1.9008.tar.gz | Bin 0 -> 10355 bytes setup.py | 27 + 12 files changed, 1658 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.9008-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9008.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..802acff91 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9008 +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..7067250ce --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,223 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import 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 eucast_rules +from .functions import eucast_dosage +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..bf9cdc0f8 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + except Exception as e: + print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = robjects.r(''' + df <- AMR::example_isolates + df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } + }) + df <- df[, !sapply(df, is.list)] + df + ''') + example_isolates['date'] = pd.to_datetime(example_isolates['date']) + + # microorganisms + microorganisms = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]') + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..dbbd4a128 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,920 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def 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 eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.translate_AMR(x, *args, **kwargs) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.1.9008-py3-none-any.whl b/dist/amr-3.0.1.9008-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f7150b8ba904f1a4e310992cefc5a2b207582a7d GIT binary patch literal 10514 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 MtaaAILE+*42d0mXfB*mh literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..699f8707c --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9008', + 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', +)