From 1bb895b73ca605b81f92252639843f082675a57d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 31 Mar 2025 12:58:17 +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.9233-py3-none-any.whl | Bin 0 -> 10221 bytes dist/amr-2.1.1.9233.tar.gz | Bin 0 -> 10067 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.9233-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9233.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..f1561d85b --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9233 +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.9233-py3-none-any.whl b/dist/amr-2.1.1.9233-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..42d7eb9dcb2e7fa56a1b9c86feaffb492fa4e941 GIT binary patch literal 10221 zcmaKS1#BJ5mhCY!Gcz;eG21ccn3>bmx+wddN>fZ9+1fI2Y%fb!?9sDd(!fq|91m8*dP zv!iFS)?~&SH)7`l-8JM}LL=YpvI$C85z3F)0#ZCK$?ufKO*gkhvY9oB(0M*uwK)C4 z07&yzm6-94+)p}o`Pv&-3C1-Shvun!qmB_9>h!`2!of_Z&e5LD0psKWwq>0VFwOel zeA5BhcjhCewRFy92KjUNy8E~r)P&JD&6f9KIlAAp0yv|}T`S?KmqQx$F3ZlgiH%!X zR=I7ODViiXXR>xPFgvOhTZlP)cp;w4z6u5wRCC5;@ECI07;;q*mXxI}onqOHu_@Jj zK?_7`ZBmtZ3&VTr0h>ykoJR80+zrzZH`x7!DlksRH-{$W$r{7vnAM<1If8&=L1j{s zk39@HGzst$ZKbNrcqAg90#w$|-IIt8 zu$iE8Ok*=F$#g#N+wtAPP#4d!7$QPNfM#_>+J|&D&K%WsgfUJ@CtbEjtoFE-*(GQc zuiE&EkMa(^u-(4~7xDcF-AsjQY%!H~4KL!m8|7GuY*IA^Blkl78r`RgK4X=T!Nuu# zq?R${Q>`Jy6WgI^5@u$IFrb3j0nQTWrTF!0a#O36W)guj;Nv*$W9AHaW3j%$ro$pd zYRR>O3sfw41F1Li>umj87`J+bG>1%0Qo~(e4TG~cgs4`#PsNPKa2X1&on~YoDeO*H zS;m7BPk}Eh570-XnqVJunHUXHr__S!CQllffb6lk$6^|4{FFo+nnTttG6A1%?XWc; z<GkRj=IZLS$#%xB zb{@pD!Kr|K0;JPLd>!LdV>`F|F{<|t<^l>OG{8J)&Lc3ucVS>QUpY}K#{MQx?jR87 z+{*%-;7^iJEN%83kT+U51(lu-RscjMC?XcDX*wgHgMfPHepm(zfY!d>CiAFuf%^P$Gy5URY}!&`+k%92OsYi!xZT-X`L?n$O+eVP$~8pJxQL+5(8;XdoS; zPS0XEGVy_CXXHdKYlh`&99nRFvxlq|Gh>v>=$dDdtRoI3B0pfXnV(e~X9%ZrMU%#u z`XFosCY}%V6YZFfrK8*n7ZFD*B<+{5%=67aIcYk}n0}j(jT0AZ#fO*PAyIlRH48$75V-6*w;(+n2X#ST0e+!Ob8NV02r25P*gOneEnC4r zMMKkrO+hl9_|4rbl2l|dZzr!1+HHRXhVRi*?#AGaXYQm9Ssel^$@<`<>lH($igPP( zz{3Y&Veyg{9(Jdx`=s??nf~`%7SO*f!`~UR)5ahGfbVdBFT-WV{ z0Hv%oK8sLQiDE465_!^$WWJn~jPWc2DS!Tp`;1R?+%ixpzkfMfTr7%SCip^*pJLOl z+NZ1eb>Udr=(EQ)Dt`yJ3IcW&ZCD*eQsd{Nh5=M$H_jMVOVq9<;qbD-4{V#=_06$i z_LQ!O_P`b9!=~^EgX_yznS_my>igY3wL;&m

gYqAx?khs>~JT*v1Nbvs4qT)a4D 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9233.tar.gz b/dist/amr-2.1.1.9233.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..26583911f7676d13ee70ab6dfa3a98658cae1775 GIT binary patch literal 10067 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..0dbba6f99 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9233', + 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', +)