From 817e33b9b52289e0de44c0be81f64f2ffcaed48b Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 20 Mar 2025 21:03:31 +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 | 212 +++++++++ AMR/datasets.py | 80 ++++ AMR/functions.py | 662 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9222-py3-none-any.whl | Bin 0 -> 10206 bytes dist/amr-2.1.1.9222.tar.gz | Bin 0 -> 10037 bytes setup.py | 27 ++ 12 files changed, 1392 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.9222-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9222.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..e58607afd --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9222 +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..ddc4a41a3 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,212 @@ +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 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..d8379b1a7 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,80 @@ +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]) + +print(python_amr_version) +print(r_amr_version) + +# 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..05f53a448 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,662 @@ +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 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.9222-py3-none-any.whl b/dist/amr-2.1.1.9222-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..06910a1daaf5fc283ac77db5c1b950b3f2810a0a GIT binary patch literal 10206 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 Xrc@Q6|I#uT?4Nf3M~aKoe_j0-0i?9k literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9222.tar.gz b/dist/amr-2.1.1.9222.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3bd7320ccaa81c7aef30492b7af240844edd61b8 GIT binary patch literal 10037 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 a^qgNNRR1sL+eiZxDOOARGt4$D%>M$RZk@OQ literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..410c81a26 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9222', + 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', +)