From ba2f4e5ae00df4fe812dd918d69cc69761977a6f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 7 Apr 2025 16:38:07 +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.9234-py3-none-any.whl | Bin 0 -> 10220 bytes dist/amr-2.1.1.9234.tar.gz | Bin 0 -> 10058 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.9234-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9234.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..797390da9 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9234 +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.9234-py3-none-any.whl b/dist/amr-2.1.1.9234-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..bf8a6ec7281e3ab7dc2dcaae29e3579d9c30f1ab GIT binary patch literal 10220 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 pLi#7?KSlK4oJ|1|F2Nmw49)=aJNf=~ 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 d=3.6', +)