From 3503bca551d5ae9a4ee4ac5faf6c491075a3702a Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 6 Mar 2026 17:57:20 +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 | 226 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 932 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9028-py3-none-any.whl | Bin 0 -> 10558 bytes dist/amr-3.0.1.9028.tar.gz | Bin 0 -> 10425 bytes setup.py | 27 + 12 files changed, 1673 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.9028-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9028.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..e39c510b5 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9028 +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..abf581284 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,226 @@ +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 peptides +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..0c11968a2 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,932 @@ +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 peptides(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.peptides(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.9028-py3-none-any.whl b/dist/amr-3.0.1.9028-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..3d855ac9ffed7f3cd3aee0baee5702e378c4c748 GIT binary patch literal 10558 zcma*N1#BJ7wl!#`n31x8eww+O zZk1Z<)>^%#?zOA-uB9vo355v;1_lR49ShK_U;WLJ2Mq=$Knezi^7pQYf+~xlp_RRr ztDzyYqgRr)ockIV>e?$NuSnK@e-vZ=7&*Zqm?!D7m^%y3A0eh_*yaQjHSS#HiWjJC#<_| zCe#U$_eCX#KDl>vps!bu0rn;i@`rEl#N7m7JZo6RP*jz4-UMMi5_s)SZHL2e>AmE0 zwOV0UPsyjOFAf<^$EZ@fI&->U8hXf)ql7R-M!O>0m*WMgQSYgdKk|W&c?-%giKY{m zHOC-Z67JpumV9zje16OEFq<_MyI6R#vO2QKATW{Qp_1b5rA2X{FiRfYVeL!dbgU$C zBR^|47UY@!{k&3_ol1`r`C7*O(}eso=Z9qXSYjdu=@wBK+p;#W!||fhO#VCitSmq( z&5{ibOO=qV9wmSECC*D3Uo=EQwB9T%i*C2Z|IKBtuJM3#;nX%Z+RAHPr52f%p?IGN zN{SgH(hCTgM7*{-r=1a;c$34ejl=$-9P=VD!f#Pq_!;oFHxP3Vd9&z>{j8g&NG>!w z6s0SQ@W~9<_{BgmR6w76AkQ4};wt?ef9*iA0LfNbm@oceKn)YUTKE&Dh#WbwqFWo!*C$di z1ySy;Jw%};bjoGGs=hW;uRjv)47Ogaht4Hb zL|0^u$wu<$9JAHJIBumQv_>U2t{J#hT&AVZN69aLoN+f7@>8>MZdle8;*44Hk&3T8 z!Nqkx*T~>ICd*{|_cDt8xGl2u02 z3nL1W;SH9)YV>M&e&cKC@!AahCH{;&A4h)*f8TO);-o&myP^?$ig(|_HMd(EJ;uo+&XzH6lCvIe_dE6mxKBQZCU5k$d?FI=v z^6c4{Dm1mt8X)e5LuERd={#5_Lf)v4buu_x!X`H^JH}7e1iA;9d)BCs_sF*&5XS;L zuP8s(hri)UrQE;?UULg@Zq;!=!U@if#cq|~`9t{^o}Xdha`_>9>8rw97SxS(L~1MR z1};q{h%V32auk!LkvpGRpIdy~U2FU3{1`WEJJ%@9qgp+?$7Mp=}qPaF)pGRpNJ9~hAErS}s;3Eiy1kQjN1W^K??**@?<0jgGy0}}FVZNc33E!C= z)rF&{jTP!`({NAD4IW)`!sSZAV3-KI2Y#(b;l1hzPy^-{V9l^K-zQrKfz+u8qvgb~ z>>|W}K$h#H!aVojz�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 PyT4lG{M%mw1N*-Kll6dy literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9028.tar.gz b/dist/amr-3.0.1.9028.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..106d865a77d2b3f5abd0dcd6f44c18738cc21bc2 GIT binary patch literal 10425 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..740aea38e --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9028', + 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', +)