From 12ec5d473e16fd3aef745e8641824c60927f03d3 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 28 Mar 2025 10:20:59 +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 | 213 +++++++++ AMR/datasets.py | 77 ++++ AMR/functions.py | 665 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9228-py3-none-any.whl | Bin 0 -> 10220 bytes dist/amr-2.1.1.9228.tar.gz | Bin 0 -> 10046 bytes setup.py | 27 ++ 12 files changed, 1393 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-2.1.1.9228-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9228.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..a000ef8da --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9228 +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..0dd6e1f18 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,213 @@ +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 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 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 custom_mdro_guideline +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..348bbc339 --- /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 import 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='https://msberends.r-universe.dev', quiet=True) + +# # Retrieve Python AMR version +# try: +# python_amr_version = metadata.version('AMR') +# except metadata.PackageNotFoundError: +# python_amr_version = '' +# +# # 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='https://msberends.r-universe.dev', 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 +pandas2ri.activate() + +# example_isolates +example_isolates = pandas2ri.rpy2py(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 = pandas2ri.rpy2py(robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]')) +antimicrobials = pandas2ri.rpy2py(robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]')) +clinical_breakpoints = pandas2ri.rpy2py(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..fd4987d69 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,665 @@ +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects import pandas2ri +import pandas as pd +import numpy as np + +# Activate automatic conversion between R data frames and pandas data frames +pandas2ri.activate() + +# 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): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + elif isinstance(r_output, DataFrame): + return pandas2ri.rpy2py(r_output) # Return as pandas DataFrame + + # 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 ab_class(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_class(*args, **kwargs)) +def ab_selector(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_selector(*args, **kwargs)) +def ab_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_from_text(text, *args, **kwargs)) +def ab_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_name(x, *args, **kwargs)) +def ab_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_cid(x, *args, **kwargs)) +def ab_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_synonyms(x, *args, **kwargs)) +def ab_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_tradenames(x, *args, **kwargs)) +def ab_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_group(x, *args, **kwargs)) +def ab_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_atc(x, *args, **kwargs)) +def ab_atc_group1(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_atc_group1(x, *args, **kwargs)) +def ab_atc_group2(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_atc_group2(x, *args, **kwargs)) +def ab_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_loinc(x, *args, **kwargs)) +def ab_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_ddd(x, *args, **kwargs)) +def ab_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_ddd_units(x, *args, **kwargs)) +def ab_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_info(x, *args, **kwargs)) +def ab_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_url(x, *args, **kwargs)) +def ab_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_property(x, *args, **kwargs)) +def add_custom_antimicrobials(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.add_custom_antimicrobials(x)) +def clear_custom_antimicrobials(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.clear_custom_antimicrobials(*args, **kwargs)) +def add_custom_microorganisms(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.add_custom_microorganisms(x)) +def clear_custom_microorganisms(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.clear_custom_microorganisms(*args, **kwargs)) +def age(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.age(x, *args, **kwargs)) +def age_groups(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.age_groups(x, *args, **kwargs)) +def antibiogram(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.antibiogram(x, *args, **kwargs)) +def wisca(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.wisca(x, *args, **kwargs)) +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs)) +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs)) +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs)) +def antifungals(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.antifungals(only_sir_columns = False, *args, **kwargs)) +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs)) +def betalactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.betalactams(only_sir_columns = False, *args, **kwargs)) +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs)) +def carbapenems(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.carbapenems(only_sir_columns = False, *args, **kwargs)) +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs)) +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs)) +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs)) +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs)) +def lincosamides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.lincosamides(only_sir_columns = False, *args, **kwargs)) +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs)) +def macrolides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.macrolides(only_sir_columns = False, *args, **kwargs)) +def monobactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.monobactams(only_sir_columns = False, *args, **kwargs)) +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs)) +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs)) +def penicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.penicillins(only_sir_columns = False, *args, **kwargs)) +def phenicols(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.phenicols(only_sir_columns = False, *args, **kwargs)) +def polymyxins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.polymyxins(only_sir_columns = False, *args, **kwargs)) +def quinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.quinolones(only_sir_columns = False, *args, **kwargs)) +def rifamycins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.rifamycins(only_sir_columns = False, *args, **kwargs)) +def streptogramins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.streptogramins(only_sir_columns = False, *args, **kwargs)) +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs)) +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs)) +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs)) +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs)) +def amr_class(amr_class, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.amr_class(amr_class, *args, **kwargs)) +def amr_selector(filter, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.amr_selector(filter, *args, **kwargs)) +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs)) +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs)) +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs)) +def as_ab(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_ab(x, *args, **kwargs)) +def is_ab(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_ab(x)) +def ab_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_reset_session(*args, **kwargs)) +def as_av(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_av(x, *args, **kwargs)) +def is_av(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_av(x)) +def as_disk(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_disk(x, *args, **kwargs)) +def is_disk(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_disk(x)) +def as_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_mic(x, *args, **kwargs)) +def is_mic(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_mic(x)) +def rescale_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.rescale_mic(x, *args, **kwargs)) +def mic_p50(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mic_p50(x, *args, **kwargs)) +def mic_p90(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mic_p90(x, *args, **kwargs)) +def as_mo(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_mo(x, *args, **kwargs)) +def is_mo(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_mo(x)) +def mo_uncertainties(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_uncertainties(*args, **kwargs)) +def mo_renamed(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_renamed(*args, **kwargs)) +def mo_failures(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_failures(*args, **kwargs)) +def mo_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_reset_session(*args, **kwargs)) +def mo_cleaning_regex(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_cleaning_regex(*args, **kwargs)) +def as_sir(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_sir(x, *args, **kwargs)) +def is_sir(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_sir(x)) +def is_sir_eligible(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_sir_eligible(x, *args, **kwargs)) +def sir_interpretation_history(clean): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.sir_interpretation_history(clean)) +def atc_online_property(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.atc_online_property(atc_code, *args, **kwargs)) +def atc_online_groups(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.atc_online_groups(atc_code, *args, **kwargs)) +def atc_online_ddd(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.atc_online_ddd(atc_code, *args, **kwargs)) +def atc_online_ddd_units(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.atc_online_ddd_units(atc_code, *args, **kwargs)) +def av_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_from_text(text, *args, **kwargs)) +def av_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_name(x, *args, **kwargs)) +def av_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_cid(x, *args, **kwargs)) +def av_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_synonyms(x, *args, **kwargs)) +def av_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_tradenames(x, *args, **kwargs)) +def av_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_group(x, *args, **kwargs)) +def av_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_atc(x, *args, **kwargs)) +def av_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_loinc(x, *args, **kwargs)) +def av_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_ddd(x, *args, **kwargs)) +def av_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_ddd_units(x, *args, **kwargs)) +def av_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_info(x, *args, **kwargs)) +def av_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_url(x, *args, **kwargs)) +def av_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_property(x, *args, **kwargs)) +def availability(tbl, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.availability(tbl, *args, **kwargs)) +def bug_drug_combinations(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.bug_drug_combinations(x, *args, **kwargs)) +def count_resistant(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_resistant(*args, **kwargs)) +def count_susceptible(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_susceptible(*args, **kwargs)) +def count_S(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_S(*args, **kwargs)) +def count_SI(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_SI(*args, **kwargs)) +def count_I(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_I(*args, **kwargs)) +def count_IR(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_IR(*args, **kwargs)) +def count_R(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_R(*args, **kwargs)) +def count_all(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_all(*args, **kwargs)) +def n_sir(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.n_sir(*args, **kwargs)) +def count_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_df(data, *args, **kwargs)) +def custom_eucast_rules(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.custom_eucast_rules(*args, **kwargs)) +def eucast_rules(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.eucast_rules(x, *args, **kwargs)) +def eucast_dosage(ab, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.eucast_dosage(ab, *args, **kwargs)) +def export_ncbi_biosample(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.export_ncbi_biosample(x, *args, **kwargs)) +def first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.first_isolate(x = None, *args, **kwargs)) +def filter_first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.filter_first_isolate(x = None, *args, **kwargs)) +def g_test(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.g_test(x, *args, **kwargs)) +def is_new_episode(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_new_episode(x, *args, **kwargs)) +def ggplot_pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ggplot_pca(x, *args, **kwargs)) +def ggplot_sir(data, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ggplot_sir(data, *args, **kwargs)) +def geom_sir(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.geom_sir(position = None, *args, **kwargs)) +def guess_ab_col(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.guess_ab_col(x = None, *args, **kwargs)) +def italicise_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.italicise_taxonomy(string, *args, **kwargs)) +def italicize_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.italicize_taxonomy(string, *args, **kwargs)) +def inner_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.inner_join_microorganisms(x, *args, **kwargs)) +def left_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.left_join_microorganisms(x, *args, **kwargs)) +def right_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.right_join_microorganisms(x, *args, **kwargs)) +def full_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.full_join_microorganisms(x, *args, **kwargs)) +def semi_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.semi_join_microorganisms(x, *args, **kwargs)) +def anti_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.anti_join_microorganisms(x, *args, **kwargs)) +def key_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.key_antimicrobials(x = None, *args, **kwargs)) +def all_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.all_antimicrobials(x = None, *args, **kwargs)) +def kurtosis(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.kurtosis(x, *args, **kwargs)) +def like(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.like(x, *args, **kwargs)) +def mdro(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mdro(x = None, *args, **kwargs)) +def custom_mdro_guideline(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.custom_mdro_guideline(*args, **kwargs)) +def brmo(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.brmo(x = None, *args, **kwargs)) +def mrgn(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mrgn(x = None, *args, **kwargs)) +def mdr_tb(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mdr_tb(x = None, *args, **kwargs)) +def mdr_cmi2012(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mdr_cmi2012(x = None, *args, **kwargs)) +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs)) +def mean_amr_distance(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mean_amr_distance(x, *args, **kwargs)) +def amr_distance_from_row(amr_distance, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.amr_distance_from_row(amr_distance, *args, **kwargs)) +def mo_matching_score(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_matching_score(x, *args, **kwargs)) +def mo_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_name(x, *args, **kwargs)) +def mo_fullname(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_fullname(x, *args, **kwargs)) +def mo_shortname(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_shortname(x, *args, **kwargs)) +def mo_subspecies(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_subspecies(x, *args, **kwargs)) +def mo_species(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_species(x, *args, **kwargs)) +def mo_genus(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_genus(x, *args, **kwargs)) +def mo_family(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_family(x, *args, **kwargs)) +def mo_order(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_order(x, *args, **kwargs)) +def mo_class(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_class(x, *args, **kwargs)) +def mo_phylum(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_phylum(x, *args, **kwargs)) +def mo_kingdom(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_kingdom(x, *args, **kwargs)) +def mo_domain(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_domain(x, *args, **kwargs)) +def mo_type(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_type(x, *args, **kwargs)) +def mo_status(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_status(x, *args, **kwargs)) +def mo_pathogenicity(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_pathogenicity(x, *args, **kwargs)) +def mo_gramstain(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_gramstain(x, *args, **kwargs)) +def mo_is_gram_negative(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_gram_negative(x, *args, **kwargs)) +def mo_is_gram_positive(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_gram_positive(x, *args, **kwargs)) +def mo_is_yeast(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_yeast(x, *args, **kwargs)) +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs)) +def mo_oxygen_tolerance(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_oxygen_tolerance(x, *args, **kwargs)) +def mo_is_anaerobic(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_anaerobic(x, *args, **kwargs)) +def mo_snomed(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_snomed(x, *args, **kwargs)) +def mo_ref(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_ref(x, *args, **kwargs)) +def mo_authors(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_authors(x, *args, **kwargs)) +def mo_year(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_year(x, *args, **kwargs)) +def mo_lpsn(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_lpsn(x, *args, **kwargs)) +def mo_mycobank(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_mycobank(x, *args, **kwargs)) +def mo_gbif(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_gbif(x, *args, **kwargs)) +def mo_rank(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_rank(x, *args, **kwargs)) +def mo_taxonomy(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_taxonomy(x, *args, **kwargs)) +def mo_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_synonyms(x, *args, **kwargs)) +def mo_current(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_current(x, *args, **kwargs)) +def mo_group_members(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_group_members(x, *args, **kwargs)) +def mo_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_info(x, *args, **kwargs)) +def mo_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_url(x, *args, **kwargs)) +def mo_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_property(x, *args, **kwargs)) +def pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.pca(x, *args, **kwargs)) +def theme_sir(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.theme_sir(*args, **kwargs)) +def labels_sir_count(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.labels_sir_count(position = None, *args, **kwargs)) +def resistance(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.resistance(*args, **kwargs)) +def susceptibility(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.susceptibility(*args, **kwargs)) +def sir_confidence_interval(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.sir_confidence_interval(*args, **kwargs)) +def proportion_R(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_R(*args, **kwargs)) +def proportion_IR(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_IR(*args, **kwargs)) +def proportion_I(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_I(*args, **kwargs)) +def proportion_SI(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_SI(*args, **kwargs)) +def proportion_S(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_S(*args, **kwargs)) +def proportion_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_df(data, *args, **kwargs)) +def sir_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.sir_df(data, *args, **kwargs)) +def random_mic(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.random_mic(size = None, *args, **kwargs)) +def random_disk(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.random_disk(size = None, *args, **kwargs)) +def random_sir(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.random_sir(size = None, *args, **kwargs)) +def resistance_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.resistance_predict(x, *args, **kwargs)) +def sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.sir_predict(x, *args, **kwargs)) +def ggplot_sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ggplot_sir_predict(x, *args, **kwargs)) +def skewness(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.skewness(x, *args, **kwargs)) +def top_n_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.top_n_microorganisms(x, *args, **kwargs)) +def reset_AMR_locale(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.reset_AMR_locale(*args, **kwargs)) +def translate_AMR(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(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-2.1.1.9228-py3-none-any.whl b/dist/amr-2.1.1.9228-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..474149de8656fc8820f5e7eb80c8e0322273e61b GIT binary patch literal 10220 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9228.tar.gz b/dist/amr-2.1.1.9228.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..926384412834d100b57a0e2ccacc5d15ca33a09a GIT binary patch literal 10046 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..165471282 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9228', + 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', +)