From 79632249016cad999fe33caef699be97bdd1109d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 26 Apr 2025 14:24:50 +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.9254-py3-none-any.whl | Bin 0 -> 10188 bytes dist/amr-2.1.1.9254.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.9254-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9254.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..1289ce788 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9254 +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.9254-py3-none-any.whl b/dist/amr-2.1.1.9254-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..57f4b4edaa7a18737bfc0262c53ba3cd67b468f2 GIT binary patch literal 10188 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9254.tar.gz b/dist/amr-2.1.1.9254.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..233ae3b53e5732405c59b5e06bf0290fca0b9e58 GIT binary patch literal 10022 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