From d123b82c5cced6713f3e2c73a99ea35a1fc091f6 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 28 Mar 2025 15:52:55 +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.9230-py3-none-any.whl | Bin 0 -> 10219 bytes dist/amr-2.1.1.9230.tar.gz | Bin 0 -> 10052 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.9230-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9230.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..c5b7279fd --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9230 +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.9230-py3-none-any.whl b/dist/amr-2.1.1.9230-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..b81aee45da411f4f727308550471e979afe372a0 GIT binary patch literal 10219 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9230.tar.gz b/dist/amr-2.1.1.9230.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b380a0c491f6f03693bcc5f9100c0b92d9f8efc1 GIT binary patch literal 10052 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..772cb5844 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9230', + 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', +)