From b254cc0ba654abaa52cf55683a80450e29c4c2ac Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 28 Mar 2025 10:41:00 +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.9229-py3-none-any.whl | Bin 0 -> 10221 bytes dist/amr-2.1.1.9229.tar.gz | Bin 0 -> 10075 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.9229-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9229.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..07dcc8471 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9229 +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.9229-py3-none-any.whl b/dist/amr-2.1.1.9229-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..adc11944b3ca02402866c73619416fc31047f5e6 GIT binary patch literal 10221 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9229.tar.gz b/dist/amr-2.1.1.9229.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..4c2ca1b26f8d12398ab17b75fe04866aeac848b5 GIT binary patch literal 10075 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 CKokoA literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..630277249 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9229', + 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', +)