From 1931e05d9446a6b5bd1c445fa3b2db1d1fd1a197 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 31 Mar 2025 08:55:30 +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.9232-py3-none-any.whl | Bin 0 -> 10220 bytes dist/amr-2.1.1.9232.tar.gz | Bin 0 -> 10048 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.9232-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9232.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..13fa3f2e1 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9232 +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.9232-py3-none-any.whl b/dist/amr-2.1.1.9232-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..a1096c2424127555cc7f3faf8739a841c9ce77e2 GIT binary patch literal 10220 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9232.tar.gz b/dist/amr-2.1.1.9232.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..293f6a79b8990dd8b93a0de03dc4de62cd471091 GIT binary patch literal 10048 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 V#s7uw0mPx?=k&p9aNF>3{|i_W0%HIG literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..d6ecf4841 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9232', + 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', +)