From 5cc2d0ad401e9beed88fbd03a60780e991d1419f Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 27 Apr 2025 15:55: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.9258-py3-none-any.whl | Bin 0 -> 10187 bytes dist/amr-2.1.1.9258.tar.gz | Bin 0 -> 10034 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.9258-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9258.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..65fa833f7 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9258 +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.9258-py3-none-any.whl b/dist/amr-2.1.1.9258-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..36ade724b248ef57b75e969708ba2b6cf3793178 GIT binary patch literal 10187 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