From be9f5fa10b222c0ce20acad3a49bdfb0cb369e66 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 22 Dec 2025 08:42:18 +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 | 221 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 912 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9007-py3-none-any.whl | Bin 0 -> 10464 bytes dist/amr-3.0.1.9007.tar.gz | Bin 0 -> 10303 bytes setup.py | 27 + 12 files changed, 1648 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.9007-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9007.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..22ceee3e6 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9007 +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..775bbd109 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,221 @@ +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 polymyxins +from .functions import quinolones +from .functions import rifamycins +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..9b8203a42 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,912 @@ +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 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 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.9007-py3-none-any.whl b/dist/amr-3.0.1.9007-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..a97e75220285c210a9b69a7a3ce0d451af53efa0 GIT binary patch literal 10464 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

-2xV%5IN;RHlXs3+n}FojKf5Is3hS@rwgK1y>JZ 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�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 Q_rlQoVk6ZNb`cT&7q|9~9{>OV literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..1deecd423 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9007', + 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', +)