From 2d74cad495fbea5db8221e7fab675ef2c123d81f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 29 Mar 2025 17:04:59 +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.9231-py3-none-any.whl | Bin 0 -> 10220 bytes dist/amr-2.1.1.9231.tar.gz | Bin 0 -> 10060 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.9231-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9231.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..de35a22f1 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9231 +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.9231-py3-none-any.whl b/dist/amr-2.1.1.9231-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..a53573aabc3c6bc898e731dc4a8e38fc0b63c23b GIT binary patch literal 10220 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9231.tar.gz b/dist/amr-2.1.1.9231.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..2465c6a60901959ef7cc98a25876d8de3fec108f GIT binary patch literal 10060 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