From 34c79c083c92f7b9ae1c3f96dc99d7fc0e85d09c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 19 Mar 2025 15:15:43 +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 | 212 +++++++++ AMR/datasets.py | 82 ++++ AMR/functions.py | 662 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9220-py3-none-any.whl | Bin 0 -> 10250 bytes dist/amr-2.1.1.9220.tar.gz | Bin 0 -> 10107 bytes setup.py | 27 ++ 12 files changed, 1394 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.9220-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9220.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..2f7204c79 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.2 +Name: AMR +Version: 2.1.1.9220 +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..ddc4a41a3 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,212 @@ +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 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..46577a406 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,82 @@ +import os +import sys +from rpy2 import robjects +from rpy2.robjects import pandas2ri +from rpy2.robjects.packages import importr, isinstalled +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix + +# Define R library path within the venv +r_lib_path = os.path.join(venv_path, "R_libs") +# Ensure the R library path exists +os.makedirs(r_lib_path, exist_ok=True) + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn = -1) + +# Override R library paths globally for the session +robjects.r(f'.Library.site <- "{r_lib_path}"') # Replace site-specific library +base._libPaths(r_lib_path) # Override .libPaths() as well + +# Get the effective library path +r_amr_lib_path = base._libPaths()[0] + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_amr_lib_path): + print(f"AMR: Installing latest AMR R package to {r_amr_lib_path}...", flush=True) + utils.install_packages('AMR', repos='https://msberends.r-universe.dev', quiet=True) + +# Python package version of AMR +try: + python_amr_version = metadata.version('AMR') +except metadata.PackageNotFoundError: + python_amr_version = '' + +# R package version of AMR +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_amr_lib_path}"))') + +print(python_amr_version) +print(r_amr_version) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_amr_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..05f53a448 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,662 @@ +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 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.9220-py3-none-any.whl b/dist/amr-2.1.1.9220-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..b23a747e0d7caa773f66b474d0cef5ba92e65533 GIT binary patch literal 10250 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�bh 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..821f7e13b --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9220', + 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', +)