From f4d5bfa7708e11de6db1e63102dd875abe637313 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 7 Jan 2026 12:33:53 +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.9013-py3-none-any.whl | Bin 0 -> 10515 bytes dist/amr-3.0.1.9013.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.9013-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9013.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..a925a1198 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9013 +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.9013-py3-none-any.whl b/dist/amr-3.0.1.9013-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..520ab22cad28c62bb78768e983482c86aee98de6 GIT binary patch literal 10515 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 F{{W}`U~K>Z literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..0d0ca36b4 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9013', + 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', +)