From 90f38eca1c3f7d4653ea6bf8d2bb2ae3b0af3e4e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 20 Mar 2025 22:30:16 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 +++++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 212 +++++++++ AMR/datasets.py | 77 ++++ AMR/functions.py | 662 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9224-py3-none-any.whl | Bin 0 -> 10207 bytes dist/amr-2.1.1.9224.tar.gz | Bin 0 -> 10046 bytes setup.py | 27 ++ 12 files changed, 1389 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.9224-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9224.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..d0b47083b --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9224 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..ddc4a41a3 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,212 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import streptogramins +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import eucast_rules +from .functions import eucast_dosage +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import custom_mdro_guideline +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..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..05f53a448 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,662 @@ +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects import pandas2ri +import pandas as pd +import numpy as np + +# Activate automatic conversion between R data frames and pandas data frames +pandas2ri.activate() + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, pd.DataFrame): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + elif isinstance(r_output, DataFrame): + return pandas2ri.rpy2py(r_output) # Return as pandas DataFrame + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output +def ab_class(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_class(*args, **kwargs)) +def ab_selector(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_selector(*args, **kwargs)) +def ab_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_from_text(text, *args, **kwargs)) +def ab_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_name(x, *args, **kwargs)) +def ab_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_cid(x, *args, **kwargs)) +def ab_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_synonyms(x, *args, **kwargs)) +def ab_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_tradenames(x, *args, **kwargs)) +def ab_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_group(x, *args, **kwargs)) +def ab_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_atc(x, *args, **kwargs)) +def ab_atc_group1(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_atc_group1(x, *args, **kwargs)) +def ab_atc_group2(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_atc_group2(x, *args, **kwargs)) +def ab_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_loinc(x, *args, **kwargs)) +def ab_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_ddd(x, *args, **kwargs)) +def ab_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_ddd_units(x, *args, **kwargs)) +def ab_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_info(x, *args, **kwargs)) +def ab_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_url(x, *args, **kwargs)) +def ab_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_property(x, *args, **kwargs)) +def add_custom_antimicrobials(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.add_custom_antimicrobials(x)) +def clear_custom_antimicrobials(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.clear_custom_antimicrobials(*args, **kwargs)) +def add_custom_microorganisms(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.add_custom_microorganisms(x)) +def clear_custom_microorganisms(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.clear_custom_microorganisms(*args, **kwargs)) +def age(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.age(x, *args, **kwargs)) +def age_groups(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.age_groups(x, *args, **kwargs)) +def antibiogram(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.antibiogram(x, *args, **kwargs)) +def wisca(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.wisca(x, *args, **kwargs)) +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs)) +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs)) +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs)) +def antifungals(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.antifungals(only_sir_columns = False, *args, **kwargs)) +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs)) +def betalactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.betalactams(only_sir_columns = False, *args, **kwargs)) +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs)) +def carbapenems(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.carbapenems(only_sir_columns = False, *args, **kwargs)) +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs)) +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs)) +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs)) +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs)) +def lincosamides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.lincosamides(only_sir_columns = False, *args, **kwargs)) +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs)) +def macrolides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.macrolides(only_sir_columns = False, *args, **kwargs)) +def monobactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.monobactams(only_sir_columns = False, *args, **kwargs)) +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs)) +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs)) +def penicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.penicillins(only_sir_columns = False, *args, **kwargs)) +def phenicols(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.phenicols(only_sir_columns = False, *args, **kwargs)) +def polymyxins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.polymyxins(only_sir_columns = False, *args, **kwargs)) +def quinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.quinolones(only_sir_columns = False, *args, **kwargs)) +def rifamycins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.rifamycins(only_sir_columns = False, *args, **kwargs)) +def streptogramins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.streptogramins(only_sir_columns = False, *args, **kwargs)) +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs)) +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs)) +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs)) +def amr_class(amr_class, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.amr_class(amr_class, *args, **kwargs)) +def amr_selector(filter, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.amr_selector(filter, *args, **kwargs)) +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs)) +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs)) +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs)) +def as_ab(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_ab(x, *args, **kwargs)) +def is_ab(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_ab(x)) +def ab_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ab_reset_session(*args, **kwargs)) +def as_av(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_av(x, *args, **kwargs)) +def is_av(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_av(x)) +def as_disk(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_disk(x, *args, **kwargs)) +def is_disk(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_disk(x)) +def as_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_mic(x, *args, **kwargs)) +def is_mic(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_mic(x)) +def rescale_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.rescale_mic(x, *args, **kwargs)) +def mic_p50(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mic_p50(x, *args, **kwargs)) +def mic_p90(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mic_p90(x, *args, **kwargs)) +def as_mo(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_mo(x, *args, **kwargs)) +def is_mo(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_mo(x)) +def mo_uncertainties(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_uncertainties(*args, **kwargs)) +def mo_renamed(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_renamed(*args, **kwargs)) +def mo_failures(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_failures(*args, **kwargs)) +def mo_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_reset_session(*args, **kwargs)) +def mo_cleaning_regex(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_cleaning_regex(*args, **kwargs)) +def as_sir(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.as_sir(x, *args, **kwargs)) +def is_sir(x): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_sir(x)) +def is_sir_eligible(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_sir_eligible(x, *args, **kwargs)) +def sir_interpretation_history(clean): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.sir_interpretation_history(clean)) +def atc_online_property(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.atc_online_property(atc_code, *args, **kwargs)) +def atc_online_groups(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.atc_online_groups(atc_code, *args, **kwargs)) +def atc_online_ddd(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.atc_online_ddd(atc_code, *args, **kwargs)) +def atc_online_ddd_units(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.atc_online_ddd_units(atc_code, *args, **kwargs)) +def av_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_from_text(text, *args, **kwargs)) +def av_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_name(x, *args, **kwargs)) +def av_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_cid(x, *args, **kwargs)) +def av_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_synonyms(x, *args, **kwargs)) +def av_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_tradenames(x, *args, **kwargs)) +def av_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_group(x, *args, **kwargs)) +def av_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_atc(x, *args, **kwargs)) +def av_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_loinc(x, *args, **kwargs)) +def av_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_ddd(x, *args, **kwargs)) +def av_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_ddd_units(x, *args, **kwargs)) +def av_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_info(x, *args, **kwargs)) +def av_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_url(x, *args, **kwargs)) +def av_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.av_property(x, *args, **kwargs)) +def availability(tbl, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.availability(tbl, *args, **kwargs)) +def bug_drug_combinations(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.bug_drug_combinations(x, *args, **kwargs)) +def count_resistant(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_resistant(*args, **kwargs)) +def count_susceptible(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_susceptible(*args, **kwargs)) +def count_S(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_S(*args, **kwargs)) +def count_SI(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_SI(*args, **kwargs)) +def count_I(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_I(*args, **kwargs)) +def count_IR(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_IR(*args, **kwargs)) +def count_R(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_R(*args, **kwargs)) +def count_all(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_all(*args, **kwargs)) +def n_sir(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.n_sir(*args, **kwargs)) +def count_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.count_df(data, *args, **kwargs)) +def custom_eucast_rules(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.custom_eucast_rules(*args, **kwargs)) +def eucast_rules(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.eucast_rules(x, *args, **kwargs)) +def eucast_dosage(ab, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.eucast_dosage(ab, *args, **kwargs)) +def export_ncbi_biosample(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.export_ncbi_biosample(x, *args, **kwargs)) +def first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.first_isolate(x = None, *args, **kwargs)) +def filter_first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.filter_first_isolate(x = None, *args, **kwargs)) +def g_test(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.g_test(x, *args, **kwargs)) +def is_new_episode(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.is_new_episode(x, *args, **kwargs)) +def ggplot_pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ggplot_pca(x, *args, **kwargs)) +def ggplot_sir(data, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ggplot_sir(data, *args, **kwargs)) +def geom_sir(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.geom_sir(position = None, *args, **kwargs)) +def guess_ab_col(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.guess_ab_col(x = None, *args, **kwargs)) +def italicise_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.italicise_taxonomy(string, *args, **kwargs)) +def italicize_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.italicize_taxonomy(string, *args, **kwargs)) +def inner_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.inner_join_microorganisms(x, *args, **kwargs)) +def left_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.left_join_microorganisms(x, *args, **kwargs)) +def right_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.right_join_microorganisms(x, *args, **kwargs)) +def full_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.full_join_microorganisms(x, *args, **kwargs)) +def semi_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.semi_join_microorganisms(x, *args, **kwargs)) +def anti_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.anti_join_microorganisms(x, *args, **kwargs)) +def key_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.key_antimicrobials(x = None, *args, **kwargs)) +def all_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.all_antimicrobials(x = None, *args, **kwargs)) +def kurtosis(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.kurtosis(x, *args, **kwargs)) +def like(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.like(x, *args, **kwargs)) +def mdro(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mdro(x = None, *args, **kwargs)) +def custom_mdro_guideline(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.custom_mdro_guideline(*args, **kwargs)) +def brmo(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.brmo(x = None, *args, **kwargs)) +def mrgn(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mrgn(x = None, *args, **kwargs)) +def mdr_tb(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mdr_tb(x = None, *args, **kwargs)) +def mdr_cmi2012(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mdr_cmi2012(x = None, *args, **kwargs)) +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs)) +def mean_amr_distance(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mean_amr_distance(x, *args, **kwargs)) +def amr_distance_from_row(amr_distance, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.amr_distance_from_row(amr_distance, *args, **kwargs)) +def mo_matching_score(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_matching_score(x, *args, **kwargs)) +def mo_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_name(x, *args, **kwargs)) +def mo_fullname(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_fullname(x, *args, **kwargs)) +def mo_shortname(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_shortname(x, *args, **kwargs)) +def mo_subspecies(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_subspecies(x, *args, **kwargs)) +def mo_species(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_species(x, *args, **kwargs)) +def mo_genus(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_genus(x, *args, **kwargs)) +def mo_family(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_family(x, *args, **kwargs)) +def mo_order(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_order(x, *args, **kwargs)) +def mo_class(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_class(x, *args, **kwargs)) +def mo_phylum(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_phylum(x, *args, **kwargs)) +def mo_kingdom(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_kingdom(x, *args, **kwargs)) +def mo_domain(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_domain(x, *args, **kwargs)) +def mo_type(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_type(x, *args, **kwargs)) +def mo_status(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_status(x, *args, **kwargs)) +def mo_pathogenicity(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_pathogenicity(x, *args, **kwargs)) +def mo_gramstain(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_gramstain(x, *args, **kwargs)) +def mo_is_gram_negative(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_gram_negative(x, *args, **kwargs)) +def mo_is_gram_positive(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_gram_positive(x, *args, **kwargs)) +def mo_is_yeast(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_yeast(x, *args, **kwargs)) +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs)) +def mo_oxygen_tolerance(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_oxygen_tolerance(x, *args, **kwargs)) +def mo_is_anaerobic(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_is_anaerobic(x, *args, **kwargs)) +def mo_snomed(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_snomed(x, *args, **kwargs)) +def mo_ref(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_ref(x, *args, **kwargs)) +def mo_authors(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_authors(x, *args, **kwargs)) +def mo_year(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_year(x, *args, **kwargs)) +def mo_lpsn(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_lpsn(x, *args, **kwargs)) +def mo_mycobank(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_mycobank(x, *args, **kwargs)) +def mo_gbif(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_gbif(x, *args, **kwargs)) +def mo_rank(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_rank(x, *args, **kwargs)) +def mo_taxonomy(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_taxonomy(x, *args, **kwargs)) +def mo_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_synonyms(x, *args, **kwargs)) +def mo_current(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_current(x, *args, **kwargs)) +def mo_group_members(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_group_members(x, *args, **kwargs)) +def mo_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_info(x, *args, **kwargs)) +def mo_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_url(x, *args, **kwargs)) +def mo_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.mo_property(x, *args, **kwargs)) +def pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.pca(x, *args, **kwargs)) +def theme_sir(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.theme_sir(*args, **kwargs)) +def labels_sir_count(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.labels_sir_count(position = None, *args, **kwargs)) +def resistance(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.resistance(*args, **kwargs)) +def susceptibility(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.susceptibility(*args, **kwargs)) +def sir_confidence_interval(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.sir_confidence_interval(*args, **kwargs)) +def proportion_R(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_R(*args, **kwargs)) +def proportion_IR(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_IR(*args, **kwargs)) +def proportion_I(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_I(*args, **kwargs)) +def proportion_SI(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_SI(*args, **kwargs)) +def proportion_S(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_S(*args, **kwargs)) +def proportion_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.proportion_df(data, *args, **kwargs)) +def sir_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.sir_df(data, *args, **kwargs)) +def random_mic(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.random_mic(size = None, *args, **kwargs)) +def random_disk(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.random_disk(size = None, *args, **kwargs)) +def random_sir(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.random_sir(size = None, *args, **kwargs)) +def resistance_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.resistance_predict(x, *args, **kwargs)) +def sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.sir_predict(x, *args, **kwargs)) +def ggplot_sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.ggplot_sir_predict(x, *args, **kwargs)) +def skewness(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.skewness(x, *args, **kwargs)) +def top_n_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.top_n_microorganisms(x, *args, **kwargs)) +def reset_AMR_locale(*args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.reset_AMR_locale(*args, **kwargs)) +def translate_AMR(x, *args, **kwargs): + """See our website of the R package for the manual: https://msberends.github.io/AMR/index.html""" + return convert_to_python(amr_r.translate_AMR(x, *args, **kwargs)) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-2.1.1.9224-py3-none-any.whl b/dist/amr-2.1.1.9224-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..5e0bbca65374bcec56b2404a2d16905ea3e74214 GIT binary patch literal 10207 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 YKblfifc{I%V6cD6-5)6~QvY@LUnN(!fdBvi literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9224.tar.gz b/dist/amr-2.1.1.9224.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..3131ac6151ef8e9d2ebf4b994fe5907cf28470ae GIT binary patch literal 10046 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