From bd433e0d8c2a79476314374cb410637548b8372a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 26 Apr 2025 19:32:31 +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.9256-py3-none-any.whl | Bin 0 -> 10188 bytes dist/amr-2.1.1.9256.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.9256-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9256.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..7e47a8b8e --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9256 +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.9256-py3-none-any.whl b/dist/amr-2.1.1.9256-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..b8f78ce51e7cc4f84c8294ea57646c43ff738eb6 GIT binary patch literal 10188 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9256.tar.gz b/dist/amr-2.1.1.9256.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..4e3e88afb58cf5d8bbe0002be9b851b7818d8648 GIT binary patch literal 10022 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