From 1ff8d718ecb3f97a2c5b7d8a1c6b3a6e1e05c034 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 27 Apr 2025 18:28:03 +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.9259-py3-none-any.whl | Bin 0 -> 10185 bytes dist/amr-2.1.1.9259.tar.gz | Bin 0 -> 10042 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.9259-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9259.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..8db9b1dec --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9259 +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.9259-py3-none-any.whl b/dist/amr-2.1.1.9259-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..c08fa8265e158ed8d3bbdb9078555a6fe68f9a38 GIT binary patch literal 10185 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 GBmFOMNZ$7V literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..13473e883 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9259', + packages=find_packages(), + install_requires=[ + 'rpy2', + 'numpy', + 'pandas', + ], + author='Matthijs Berends', + author_email='m.s.berends@umcg.nl', + description='A Python wrapper for the AMR R package', + long_description=open('README.md').read(), + long_description_content_type='text/markdown', + url='https://github.com/msberends/AMR', + project_urls={ + 'Bug Tracker': 'https://github.com/msberends/AMR/issues', + }, + license='GPL 2', + classifiers=[ + 'Programming Language :: Python :: 3', + 'Operating System :: OS Independent', + ], + python_requires='>=3.6', +)