From 720f2732d18efe5b6f4c74b813180a0820da3ab5 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 18 Mar 2025 15:52:02 +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.9217-py3-none-any.whl | Bin 0 -> 10250 bytes dist/amr-2.1.1.9217.tar.gz | Bin 0 -> 10074 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.9217-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9217.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..b1428646c --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.2 +Name: AMR +Version: 2.1.1.9217 +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.9217-py3-none-any.whl b/dist/amr-2.1.1.9217-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..d12c5475b3842b00486ec438699cc3d85078653e GIT binary patch literal 10250 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..4fe44b74c --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9217', + 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', +)