From 0f71a59bb5706857bb2415185ed11a5de5516200 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 8 Jan 2026 09:28:32 +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.9015-py3-none-any.whl | Bin 0 -> 10514 bytes dist/amr-3.0.1.9015.tar.gz | Bin 0 -> 10348 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.9015-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9015.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..7797b7633 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9015 +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.9015-py3-none-any.whl b/dist/amr-3.0.1.9015-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..ca6b03ac7d4d84657c004d8d8838b027addf7248 GIT binary patch literal 10514 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 D1SfMH literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..e8cf1bcbc --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9015', + 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', +)