From 2f4cd4d45821325aae1f227e2bac9de682f5d025 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 19 Apr 2025 14:24:00 +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.9246-py3-none-any.whl | Bin 0 -> 10187 bytes dist/amr-2.1.1.9246.tar.gz | Bin 0 -> 10027 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.9246-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9246.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..46fc9cf21 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9246 +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.9246-py3-none-any.whl b/dist/amr-2.1.1.9246-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..3ad7ae558552307ac7d42db1792bebabbd9f9037 GIT binary patch literal 10187 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9246.tar.gz b/dist/amr-2.1.1.9246.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..66504339a8593df177c125255382de7069d8366d GIT binary patch literal 10027 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