From 3204908b4c25941777bee5c6863682c8f82e342a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 8 Feb 2026 22:19:55 +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 | 225 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 928 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9019-py3-none-any.whl | Bin 0 -> 10551 bytes dist/amr-3.0.1.9019.tar.gz | Bin 0 -> 10410 bytes setup.py | 27 + 12 files changed, 1668 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-3.0.1.9019-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9019.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..ea89b33d1 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9019 +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..695027456 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,225 @@ +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 all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +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 phosphonics +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import spiropyrimidinetriones +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import custom_mdro_guideline +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 interpretive_rules +from .functions import eucast_rules +from .functions import clsi_rules +from .functions import eucast_dosage +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 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..bf9cdc0f8 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', 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 +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = 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 = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = 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..83384be5d --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,928 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# 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, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # 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 r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phosphonics(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phosphonics(only_sir_columns = False, *args, **kwargs) +@r_to_python +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.polymyxins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.quinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rifamycins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.streptogramins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs) +@r_to_python +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs) +@r_to_python +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_class(amr_class, *args, **kwargs) +@r_to_python +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(filter, *args, **kwargs) +@r_to_python +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs) +@r_to_python +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs) +@r_to_python +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs) +@r_to_python +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(x, *args, **kwargs) +@r_to_python +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_ab(x) +@r_to_python +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_reset_session(*args, **kwargs) +@r_to_python +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_av(x, *args, **kwargs) +@r_to_python +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_av(x) +@r_to_python +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_disk(x, *args, **kwargs) +@r_to_python +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_disk(x) +@r_to_python +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mic(x, *args, **kwargs) +@r_to_python +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mic(x) +@r_to_python +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(x, *args, **kwargs) +@r_to_python +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p50(x, *args, **kwargs) +@r_to_python +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p90(x, *args, **kwargs) +@r_to_python +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(x, *args, **kwargs) +@r_to_python +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mo(x) +@r_to_python +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_uncertainties(*args, **kwargs) +@r_to_python +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_renamed(*args, **kwargs) +@r_to_python +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_failures(*args, **kwargs) +@r_to_python +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_reset_session(*args, **kwargs) +@r_to_python +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_cleaning_regex(*args, **kwargs) +@r_to_python +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_sir(x, *args, **kwargs) +@r_to_python +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir(x) +@r_to_python +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir_eligible(x, *args, **kwargs) +@r_to_python +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_interpretation_history(clean) +@r_to_python +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_property(atc_code, *args, **kwargs) +@r_to_python +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_groups(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd_units(atc_code, *args, **kwargs) +@r_to_python +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_from_text(text, *args, **kwargs) +@r_to_python +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_name(x, *args, **kwargs) +@r_to_python +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_cid(x, *args, **kwargs) +@r_to_python +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_synonyms(x, *args, **kwargs) +@r_to_python +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_tradenames(x, *args, **kwargs) +@r_to_python +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_group(x, *args, **kwargs) +@r_to_python +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_atc(x, *args, **kwargs) +@r_to_python +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_loinc(x, *args, **kwargs) +@r_to_python +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd(x, *args, **kwargs) +@r_to_python +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd_units(x, *args, **kwargs) +@r_to_python +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_info(x, *args, **kwargs) +@r_to_python +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_url(x, *args, **kwargs) +@r_to_python +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_property(x, *args, **kwargs) +@r_to_python +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.availability(tbl, *args, **kwargs) +@r_to_python +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.bug_drug_combinations(x, *args, **kwargs) +@r_to_python +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_resistant(*args, **kwargs) +@r_to_python +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_susceptible(*args, **kwargs) +@r_to_python +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_S(*args, **kwargs) +@r_to_python +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_SI(*args, **kwargs) +@r_to_python +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_I(*args, **kwargs) +@r_to_python +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_IR(*args, **kwargs) +@r_to_python +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_R(*args, **kwargs) +@r_to_python +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_all(*args, **kwargs) +@r_to_python +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.n_sir(*args, **kwargs) +@r_to_python +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(data, *args, **kwargs) +@r_to_python +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_eucast_rules(*args, **kwargs) +@r_to_python +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_mdro_guideline(*args, **kwargs) +@r_to_python +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def interpretive_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.interpretive_rules(x, *args, **kwargs) +@r_to_python +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def clsi_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clsi_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return 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-3.0.1.9019-py3-none-any.whl b/dist/amr-3.0.1.9019-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..766962724f9c9c179836b608e0781d8379c61593 GIT binary patch literal 10551 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 F{x8RSOez2X literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9019.tar.gz b/dist/amr-3.0.1.9019.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0f028d695ca9252144d0bad3c866462ea459f730 GIT binary patch literal 10410 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..6233604cd --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9019', + 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', +)