From e3614e11eb3ce732ff2be761e4ded32387d4aa88 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 21 Apr 2025 13:38:58 +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.9250-py3-none-any.whl | Bin 0 -> 10186 bytes dist/amr-2.1.1.9250.tar.gz | Bin 0 -> 10022 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.9250-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9250.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..bc8a7d3b8 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9250 +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.9250-py3-none-any.whl b/dist/amr-2.1.1.9250-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..04767e7f317e20159754e8df46594c1c2aa772bd GIT binary patch literal 10186 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 r=$&k+pviSvXjm57tk1PYWxB4^amD||^ql_{fhs