From 6c841e5f25b301dfebe44bb181766735bdd449f3 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 18 Apr 2025 14:05:32 +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.9242-py3-none-any.whl | Bin 0 -> 10188 bytes dist/amr-2.1.1.9242.tar.gz | Bin 0 -> 10024 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.9242-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9242.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..589094b85 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9242 +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..8b1dbb67d --- /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='beta.amr-for-r.org', 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='beta.amr-for-r.org', 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..e0146c94a --- /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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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://amr-for-r.org/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.9242-py3-none-any.whl b/dist/amr-2.1.1.9242-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..ec8e3e1bdee793b7948446ddf13d5ebf0e6be933 GIT binary patch literal 10188 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 sQ=Hpx2F!sQ6OW