From fd1a085d9847693dc671b09d45b0cc3609f09510 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 17 Mar 2025 07:57:10 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 211 +++++++++ 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 | 183 ++++++++ dist/amr-2.1.1.9216-py3-none-any.whl | Bin 0 -> 10254 bytes dist/amr-2.1.1.9216.tar.gz | Bin 0 -> 10085 bytes setup.py | 27 ++ 12 files changed, 1392 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.9216-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9216.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..c3234fcaf --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,211 @@ +Metadata-Version: 2.2 +Name: AMR +Version: 2.1.1.9216 +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 Index](https://pypi.org/project/AMR/). + +This Python package is a wrapper round 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 [`venv`](https://docs.python.org/3/library/venv.html). You can set up such a virtual environment by running: + +```python +# for linux and macOS: +python -m venv /path/to/new/virtual/environment +# for 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 the which the virtual environment 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..6b436fdfb --- /dev/null +++ b/README.md @@ -0,0 +1,183 @@ + +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 Index](https://pypi.org/project/AMR/). + +This Python package is a wrapper round 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 [`venv`](https://docs.python.org/3/library/venv.html). You can set up such a virtual environment by running: + +```python +# for linux and macOS: +python -m venv /path/to/new/virtual/environment +# for 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 the which the virtual environment 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.9216-py3-none-any.whl b/dist/amr-2.1.1.9216-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f7238ae74610d3d882fb3a92fde6363926a35df3 GIT binary patch literal 10254 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 RAjm)C{*Mm9{*p7$e*yd@$~FK1 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9216.tar.gz b/dist/amr-2.1.1.9216.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..7f8914085397301e88227ceb3295eba249f85bf6 GIT binary patch literal 10085 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..e00b0982d --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9216', + 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', +)