From 8d84f41a46e0e6346b110f3936bd1ef7e64577d5 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 18 Apr 2025 15:15:55 +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.9243-py3-none-any.whl | Bin 0 -> 10187 bytes dist/amr-2.1.1.9243.tar.gz | Bin 0 -> 10030 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.9243-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9243.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..74b6a98c6 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9243 +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.9243-py3-none-any.whl b/dist/amr-2.1.1.9243-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..3d539a754478ec81f1afa2b5c1ab34186f6e765b GIT binary patch literal 10187 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 uwf3L5{!K~$C3JF literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9243.tar.gz b/dist/amr-2.1.1.9243.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..245da9f155cdbeea4cdc6982535c92f56f341a4d GIT binary patch literal 10030 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 WRPg_?Q~{fB`;LSkJK#3q;r