From 37d7682dff800e0d77cee6f131d1ae1e0441d48e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 26 Apr 2025 14:36: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.9255-py3-none-any.whl | Bin 0 -> 10187 bytes dist/amr-2.1.1.9255.tar.gz | Bin 0 -> 10025 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.9255-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9255.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..76ed8277d --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9255 +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.9255-py3-none-any.whl b/dist/amr-2.1.1.9255-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..4884e5315d1f2f816148b030e8929a58da92d3ef GIT binary patch literal 10187 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9255.tar.gz b/dist/amr-2.1.1.9255.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..cebd0c717e1f0c721c3ede2e57d2edf351bfeb90 GIT binary patch literal 10025 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