From 051c0f637f3b1bf2f62df0f6ac3743b5ea42fdc8 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 26 Mar 2025 16:21:40 +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.9225-py3-none-any.whl | Bin 0 -> 10220 bytes dist/amr-2.1.1.9225.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.9225-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9225.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..8eaa83a6f --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9225 +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.9225-py3-none-any.whl b/dist/amr-2.1.1.9225-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..59302389ad32115ae2fb946238b325971c098d18 GIT binary patch literal 10220 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9225.tar.gz b/dist/amr-2.1.1.9225.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..96872f36c1f04969be8798dfa9935b4ac456ef07 GIT binary patch literal 10048 zcmch5RZtv2*Cp3Mm*cT4HDeU$^9K47w^9!%Eu?jc|kKYxDkn? z8->$J1++zyp75hn)d7}4T(ztmfc4&|9;q{ETsuD*WW{ySzi5sWT6RW**Ma=-+fpR^ zMsno^s>b}_!;^*caNg%>kbWI@>4-KTEKUuCnTnifyoHSY&V~o?i}0b^wmwakY9_(M z$}4Yr=HQf1Ab)qHCs4r+e5n);?e6{)l>7+Nc$K0|_y&X9-@skltKo{ua1hC>)cOKE z%-O^aR;v$p$UIKZFY)TS9m#^vU$)A@@vM>4;TbTRz8C1tNSI;~T=X|ww*pSu?T}I< zElW|yLtApz7Ob>P-6RofXT5D8U@7e&obGheefp$wk`6XPlcS#D#t;!M*G4Ncr1cPM zYHXW6ivOLdo*u$QuZX9%G)9r_&@PXx@7K#&5?RBI*hl!z(kCBfIA18m%#4DMYBAxo z%85KPA1{{6n;zNV$$9_7PrI^ll|2%)X9NHfkOU{Die-Rjzt{l9US6U6nDfgAw|&E8 z&1oNr!^l%jd>}A#47adbi@t^Zh@=qqTCxAMEGoDk^hYB z(0LMAY85Vt9h6d?KAbO*C?m^h8SEF?eB7$yP~8Ex;}K0C0ivdp*dnpPlG;+^5fk3r z2$zb{GE-KIVwaz}ui#G8Y2TJ+-l$DUecEpQ zD^?*g0(&(sGOI8c&l9(qxJoCJ@(;R0jWX&OK$>hvXn8r zZcyfw6NNnt0n1XN>R)9P1n{>)7QPY7I_UwKzA+U8$(D0f(U9abg^yKYHJwTO@f}{!m7$HNZGT=%$=FIO;-uQ5Yt7;0#GT#i~t)fLvwPjXsPyM1Mwc7;>6s7;1Xfj?12CU&xDG%~Qn(%%J`fQc)MF8_>$i z(H8q7xt+Drp46%-G4@A=>n9yeQY-Bpy{aM{qq8BUa*O(8F_KDqa{a!l0*`sVakIl& zP5!_K=-*Y3`5kiu=f^e(kxu0m8D|s{HGpIcCmOMqJ!bmgKzk_d>MF+E{#!x_!#shT zlf@^4w*fkwb9M-v@m21;-RN#vSnQge_}KfG*9Mhal-Uv%Zm-e=mYBk`@s0`hIt*5 zDF{DRu?3i=ojHJ^4!&if(TCs>&o(;-$Nf(};dD#=3GEbos(gYx!OsNsjMjr7kp;cVI!5yq%af zW72448PMUS_h?Vtp4;3aI({FP+ue;KOnpE4v&FESD9<9a?&Kv(3|>41D!(>i7rcDY zbr<^0p94QhES=vue5^&B0(rqs=S%mkJZ6;RBE6oDz+hQqB)GpqGAX=%!f(l%PX1Hh z)qdNrr-;CjRx{O^6%?&7sajR3xH9>4WQ`h&!j+y-nso*yn`JxFxXf_Br7J;O@i8Ad z%G~zWpkL}7RFE*0uUNQZ??UR10qL^AGgB3B3B1w2ryXu)zium5h4~sG8n?m5VxE}0 zzc6_;y9P0{BD3T?Z2Ct5u#bEq(^f05U21zBUw4Lf0)QN+WyEW;dJIkJ>yIv~8k>ry zAB4x~QHODZJkW9QtF~sC#=SWoY2Z=mh!34~O`NV0;9QUTN>q<;zyL-pH4fWLsLhAs zJ35%;pGIFZNvI7Fv3ADmvHSB(cX79exA^vp{|*X49V+W>dC%bh`SziZb7RD!SWQ%1 zYi}~uwcnY|l4=j#VJM!IEiwHl61$QznmA;f1VPj}ouxJiLl8Hy&PCw;w7V0u8G{jT z9bVTZf>5XB{#JJYvKL7#yJ@n>FuF~nj}7wf*a%|~k0bnoz0*q~D%FmJ{Ej>fg#ha3 z?CR}H9bxRcdb)xrQZ&IES_7gIJ;dtNS`=KyqJa87*vOX<#*pbCi<^nJx00dQ=e z{&MMcG=}!ms1tGjHViJH8s^B*GlCE^EP&ZBoz2l)2?}3^0VbiPcAXbNOKCzuz8J;w zZ@7i)u7xX#_)c0#BL$95mKJ`GRIP@ZNnvujnc_Y?c$vNA9ZCnI;EGYJ_gh~hVp!9i z8^MEEq^~j@0u~ghJ}sm2r_hmHAOb@Lh}T}%R&bw)ruH9tm~^H5d-YN)LLbD4`%?w) z*yPxqjpANoEoI5Ic{qyqGAQ-YpymXcgX&{6f2ILdhT#->?4mmm^gmOls+JP&41xsB zqv(vep*F3d!4C_ipN>|06>^ShQgFty!&~A+%{hnouBlc7kFSL%%Y*-D&gx{fbb4|6 z@gsj_t&Fw*W!T~&6M(_z!Z`|}W*{gnHJl`m^*OI!D9E*`UK>WTB}#C9u91apXCk3g zIf*Sz2oK~1`N-YeA?8hm;GvVc)K0;PcjrTQrD^eRibzWOjrjIZB zLxxjx=HIAx-z$5h(gKErKLp(BRQ*^ntoJNzF+!iZKk?8Vn#}d-bG+&4`YUt(IvM@2 z?zMb~qXp}^f`5b8&aqs>=esr%n-FPl;pm04jZ(`uaK+b*E4Wl4+{9C>k0Qml-s+F+j6>WbsEpEkw6!mTt4UZxo{7l5Xj}6caF&Je4s?E!Gh>@f5GTd03Xt8UGMOto@XDA7S zS(xeJDJ}!G3{Li73CAiTHXF2z+Jp$^;ds+C;}UA&HRs+6t~=qMKP zCL~ODakW>MXUk-xJKli{!SHD9)ij8k+4OxW@O{)y)YQqpvyr#kEkI)k85`Q@r)+;g z3CT;?L|01LZ&{QQ9Fz&A5OhKI%CoAN`T52mKINndB06(6flw06nl(lMrQF;{WkPs% z6>K53AcN4H44`N69|-{{cL_uD=O;DH{)XY((qf$P)VR@>6AgLHWHy4a*|R4t`hm|$ zS|retAYBdvM%&@9O1p;(D{LKjtA-3Zf%W=p1Zy%LBT-Jh0#<|UGb9YnRbA(8sgF5! zfu&Dcbkd*kQ^E@>-V3^`TDbcHt1^i+V=Po<>|ATTv&}lt8tm1!k=gK(^l`Koy{R4E zb+7-RU+bHv<2K_pz5V_Rod{wf!}V4(tnGq_o$r8gcS0}~8IPWpp_@#)woTlZhnkne z{Suxz78XfRC;y^wF))0+yK{pPD;j&XtZFPChaeqDw`(DL3}OXz=!Nu&_Mix@rzGT5 zk%ER!!$NO3 zZT)5KK=_Efmu;>WlZ-Gkl)*t#DSVGE`ijm z$ZeXGO;4I_Zaw&l8u=vStMtQ25os-g9rGhziF6&UPtONg@(Ug;^DAuK7J(F4WHK#T zQqT92d>mg|OkU*Xnsqy7A{Z9=Sf#gH@yGW;6^|;n5*L$7Dm|_-F5G1jcHbVDBVoeZa!2qX~J!n1Ud8%~FI%oTfiU zx2uKjq*TDSz0Byz3PkgU^!9Y|W2l8oK1KMsqO>Lws=a~OQ;jFuPJ;*>m*Mvrg2Pldxa zJds?Cy;f^($GfqUGXociFu>K z!vKeSnZQ`ROLDt;rE0l=*pE0xvjXe~BIop4Yf4Ejfu+08!u{Ov8$Vz2&*_y>IzuyFy023Fc}x9({hh^*eF z=-`q)!~*qQ^7*?jm(z1n1r*fy=#SnubfS@rvm*XU_m<^AS-sZ}nN=h$c?JQC9i!C| z0X0pNkOBzKMzGhvWica7-o>EXO0T`H@6EwDRP5Djywr^ISL98yU>}XPQ2wD*ipZG& z(LTS=ea@pK(m^P18Pg882h$D!c-)zDgu#rMKSImicakZ4+_aTXs=ZWfR=#$$b-9s1 zfT}bibX;^!TM+)MVK4i)cNQ9{L`at$NYxO}O>7T>Ik|z@76-1v1Ems|0c!6`Uc53P ziVMC@Bz;~!m1%d`$;u#41JMFh^BMf|uHsM8m9)`)bMe4j?5JVV{3T<>KZ%XBeCCM3 zEg{eZ0a@(7(e)px=$ceFaMDTU-Y>bGdA;vutl6Zn1XW>M!ZwxoKwD7NP7IyrNx_`z zkjGo*8%f{TUKK|Ip`^Lzyc`rGJ!4_WT)@sd&gsz~6iUZIGbE)i=}tmPGyi%~_nm3; z@1@@}-$YcmIDfMXt#{?_97+#u6oxGP8=@e1CCfu}%2mTBkiru#>~)Vd{_)Kg7FqWi z4sT^|W1U)T-6|g+Ai_qFvhI^1xXxGY?;3!-5=%Aw=uxGVu7G7kAm@XDh|9#6;6W(RoK1cqAO?QlLcP14Fo z*eR>Ko;{iIA3+K-3EoU1Cmvg$nMD1&OOORJ|2taivFtL$qJJUcIdoH~+6#FB$d=2- zR^!6c155o6>;86+d@(mkQ$S0m^R$V0<+iklYC1KQk_Qi`1+h^HUo9H!ZZGyPko;rc z-0+`hD3O0(*(IB+!^Bn=&0Q%f{b)5NI}-uW(_^2VTnvP+N-sx6Gsp`vjpB&p9o8`c zCbf|dXC=v8Af!+Fcxa<9D^6J;iW-Qg~{XhTyASkeXhIPV)!5>7nK1Be(g^#!gIS9<{?gFcZw;R+O-USD)KB{b3v zdBmn(m&~|#d~Y^Af-;*J@qV={*h1WWeWw zFSJQps=s)!D&4q}qVAjrSgYjx<~>o-W64Y2F2V~cCGe+GKk%1T^m_7Z%FC9m;+gU4 z2>)3$YmyRWk=1IwtSJ@zQ@I-SNnINaTkuG!;Y+7S&7ov1)zUti*9i()Du(o_q@H%G zw?QJzMyqA%?DaKtGibW3??q!?QA*tk^!z$25-|KC4H6-fr1yb_Arf$Y{I64?Kn?2u znF`JOe){9!ip-?!M)L6gk`on=kg~iI{oO-j_K@u^GVseq@>}T3>h1rL?OcQh6+eE1 zp}&GI6VDT-w>kr#c@N>9;#{-vfmutw@neu43t9?h8Oj_y`x?&i3tp?QXa+w$MMQeI_w)`!+j-9ApR_a`FlZ!h%KbLA`QHo6vytIfg?)2bScS7IMi9w49uvtmelfT$ zAB>AGMTdgS@Mko^=)8(H>Y(wL{VM|BBS+kyTGS`5K?sC<7<}?n9)QAa0zrjY|7?-CP6SAo(f1NW1Uo3Ffa;=|-2+ zVa>Y~a7R{ft~GK$eG;CD$81br%uG+fZ)b2HkJ{UmA)R4kYCh#>1u($mvE3fY7=1AG zS*3czeRwIqE@L@&y0B>V8wOY}-KI(KA_R(gwvS40YuD>cbXlHgZN-Pw@EmxG!9}wQ z5FYxlKYeU)+pe7iLl@gsfL9XhrP4f+ytWhZc41(5Qxwivaz#wSnLHZ&9I$Ql#q=`z7=?CA z*!)`fUU@>@EO5o!5&$yls~iu%#`G|;6=ve)lRZ2a8YbHCu9jti-LVVD$)FAb7JAcO z20S^PNZf3hfos9OAxz7o#$QjjOD5szAmoPO=)bK3E1y9DUaK)GqxEWa*mDEifBo~< zJeHj_^47>=Loa9!EVK!PxnYub$6av8{kR%}1=YvZ$EM%>L@k#XLpRa4 z8OyQtrK4r!fkR~Y@(&e3I|3cJ%@oO_&MJWpCk0P^oT8YK+DEeBcYWQ(ZKdE*G6&Ib zE}eC{-m#kyw?o>$=4K}%EL)h{*obiz&o%ZXRK=YS032*8VKV-8Rut<=JJ(65#Jmbh z<{s-$!)i0q#V$%TO$2^&%GFdD7h>=;)#XScwQvs82Z#68TYDqDJt66I7wEKyoDKl( zE{6g3;_F9Jh9^SLX^uBl)KMVW;B3V_Qzg7Zc2=&)-)N8>!jo_|5*Y7-X~D3Hb*rSr zBrU)OB4dn|XG6>2QtO|#)#LjOv4$Z489(DINK3A5J;nP?UT9FH_wc$+%L?sIt+VR} zK|sGDikV-;-CxN;98r3X&jj^^LEeuyfIjVI_j2jZP^@1;C!VhsbR?|w)Kmp;D1JLA zlcX(?`n)uMMG!6n4R+Ac68VOuQ;BYvsC&VGDm2g{DR?pLkG!rEj z*#LYTMt!w5@L@+D@tpFUm*E9Ti}3m#QReOqt1adHuqM zhS`+}oSS2^4TaCsbOx`|Tv2hh^XClQS4$ZVBZ=L{{q;D46(>SW@FBS7_ZIku#j&Ha zk7rKL^%$9fJ`YdT!*qCCve!p+Om3jv{_TsP$N`Dp!h^)L$Kqjw<|wF+y@c1C?T1z9 zvUETC^H4cDiI7ZLbgF1D8dZ~Tz@}&WqS8@GfDq1S+0y|x$skrguF0=xQDi)`h&D~W zhlK}Wl0tS!^av#10~Eb@G<}f+(}{4*ZZsY59TAEd7(T^4ckw6f2n@vEF+cO}{(2)@j7(4CjzQy8 zP$=GxMv-#|v1N?xlNK(~SGw98DXq(0t+Rewe8R}&VCu2m!Md8opN_iEh~$3F=GhA| zCJPZdlxnytngy-Q? z-miCiv5}(3%_3ZiQtcZYJGb6u{1Fpf!vubcARr@tYXRhay#$>_adIk^^V?WBxzTt_bY z(Ro$P;D^WE?N_weNP%DVr1Z@4B^J4>v>(LMl}l2V0?L)lr^2H*gK!qGkI%W1aiU!8 zHa1qhq1mBtgAcpg=uxeto=u7*j_%R+%vi?A%@$KWxrpre(TtYSAjd0EYbs?`NI0AJ z_i2=L%|_d9j}eWM=Vadur`TnC@EwX4Zu;_^ISM@{a$Qo9fSJrShx_V>f?ckPQoP;y z!mGy0gfkd@r9{EmmsP?m;Ro_*AJI-Tk6RHZ1w~J6)Nr5Dg_ZfGF8DuN>JqB0mQ0_Q z1H8jnEE56>?Lvzi$2fWkIqz7ND1q$I8?-`c7N=wnAE6_FI$BOwre&@j&z2BikZ5%9 zsVhZV;o(hvAYYhsNzQ9sr?=BQFS5)}3{a?^dP$c)$fRFbLHuo8pXqWKT&&~$%GWW$ zHjC!zbE&n&hY_gn4bqZ887N7?PIP$&<(f~eE|I>qlzG`o}!830o4vGXKFv?5(4k;ie@aI%@t1gCvxh7PYW-Y$a~#{N8$? z@xvy!ee9)W;h4_pdNcsJp5!XNg3n6IBqc=OG+~?X>tYfmDkg$&iF79)HqGb)=IY&k zOgN&_qEj>ZU5m~so3rA9cci(=`Y@${@6nwv@80jAFBg-0R#g5m_t8j>Kk76~xNZm@ zn|wD4_viYqN9^51%jp8Z{$JyD3^=qD4WI`gjfV zScu-}$o&2K=A-i9vNyKJyXfN&Kj+a2BQtjs=}X8ZcXf9$Q6wGS9w=lzpia-!jPA?jC2Aa&skabw1RD$Wg>w#j-&0qhnii`54{B zA3c>E0g4fF=AGV>8?K%m8-aE^HY;z`z}`~M0u39sbS#I1)9~Qer+DwnyIX$NS3jqY zy0}9Az17b)sb|2@6Wil3747Z8JSob=kua7(K?+>-y*^j?4gw=rw}vtS=J{%40kEWM zcNr;pM}&NuIqdi*SIL%iI=G#aerHxmSeJ`}@LpkeGnAac?eXd$i=I%@h;!y;LvEjl z_L4B^;c;urYT)wO|9I6Q2lZe8l10tUU}NX(jXFHAKW6H}D74tROP^Kc=9zHoIX~L; z!vhjljD<{{x`T_;Brw2}JTl7LhxP!R_%<4j4q+i_!h5cAr1{%3a}XTJT4SzZA|;>V zC?@$~8Kozod{Tmbd|~N=MpbqGp|=HjmsPMIK7~Dwu)IzxK6bqg2x{Qv>0Gj@Z42W) zzDK`&0On5hH=)8X=Gi<`^m=RAa1z5^fB~lPBj0Oo5Ot!33gG|YcW20hyVo*cD2_JW_?`mtD*Ez7 zQ^sx6a7;A&&Y$W~ZPy^_B>@HJZY~r8Af#w9*edXv*`PYJJT5n2uShFS7G!;fpobWP z#1x0b$g(HYnF~LN*GOeZ`rcZLmyxe(;%>Qo0r|&vO`*;A2^?H#)VQ3~O}zd!;G8x) zazR|h7CZgK8#{B4zbE$hoI-bWt8WJsG#(Ic<(hr>#O?9-DZ#;s=aOOW>H5**Z;1q= zJTD0qjQlIprGnI_T5jm?)4^D@31wGEd?=MlGr`|Aj&2FRLoqSV_`vrt=z~J{AArt^ z8F&auTq+h7+{7#f!b@9wchHgeK9TpLE7-a(X8(fJ=~xt1yf(k%XnTX{H>Iy-h}C{< zj*}*1UitnqcXMcB-{KAnrp4RO&ML zs4{8N0Pwm9Z@9!HYZ@A*Rs0_8o{8Y!|8%^Pd1H|q@8lFX2FX@d84ZQO{U%$tYd4PY zsaz!d+I~tnPPtAkA+65XMwM!X7HVQL2z8mgoQWk^?Xb#tqcCk09W9=lR*S)_r$Ck0 zTPH8~HP>6ZE}+i9yWI-P&2Z?&i%*Xf1&+`ZNF%bLUJU*!I(HCTI&IQ(w5q^iYPRpy zB`CHjp@zICzRdK_N2inFAKp745NPT_S@xd{tTaM9$ z5~HY07_Rt#1cSkf7TPa1#Blu~kj}A#7@X1ssfznMlpDrx4CmR1f{VY!(SG?ooxE9p zpgFK6x!EGqzHkV!Bj1m^ph2S`vnkrr%>1|9C(ksuuZhYgBTwhmQco{wRq(J`-|J^6 z?@Q%>-?Q(yG+r-*Ecmssy=;abJk+v8u)rDn%XJ|saNHV&P2~0n%`i){?xh5QO=Jd7 zbaK&?etx|-3m5T7R}*6te5FI@$Fo<|ntTBPEX%|uX*z0}Jci0mK&-oa`;Y52QuIJz z{jiI$$oqA-_^%=3MivN`f4!!|%k0{4)79HfYDTi}%$}?^%t~WvY#4EtQI-aaF)55Q zUA^^MucdGBA4B|qF_B>2?={>}EMQK-M)lG<@b@lKss8#gMcCeGfc*m<23F{LTxC