From f2d4cfff865131fa79e599bd775c96c4fe92f5ee Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 27 Mar 2025 14:38:44 +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.9227-py3-none-any.whl | Bin 0 -> 10222 bytes dist/amr-2.1.1.9227.tar.gz | Bin 0 -> 10055 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.9227-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9227.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..9ee9e547b --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9227 +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..348bbc339 --- /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='https://msberends.r-universe.dev', 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='https://msberends.r-universe.dev', 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..fd4987d69 --- /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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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://msberends.github.io/AMR/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.9227-py3-none-any.whl b/dist/amr-2.1.1.9227-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..3b1fa4ba315cd19e998e852a55083755e0ae87d9 GIT binary patch literal 10222 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9227.tar.gz b/dist/amr-2.1.1.9227.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..d6f5483bf8cff38b20997cf26423390943dbffaf GIT binary patch literal 10055 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..2b01f4764 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9227', + 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', +)