From bb950045109ee7ce1fcfebce3e3eebad84b868a9 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 9 Mar 2026 10:59:28 +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 | 227 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 936 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9033-py3-none-any.whl | Bin 0 -> 10576 bytes dist/amr-3.0.1.9033.tar.gz | Bin 0 -> 10445 bytes setup.py | 27 + 12 files changed, 1678 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.9033-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9033.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..1bc390e5e --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9033 +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..185b8bb45 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,227 @@ +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 ionophores +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..3854b7e8a --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,936 @@ +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 ionophores(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.ionophores(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.9033-py3-none-any.whl b/dist/amr-3.0.1.9033-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..b20419e13633bea58fa03d46243bb29f594b91df GIT binary patch literal 10576 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%0AM?obTaw)5>G<{8ENMWc% zQ)_@}iDDekKpNm=8c3UegU{F@#j%w&8<@gGr{Ry#Yv6U0eWk3Y#bGElS|L40kL_fS z5h6j|oGbEYb3`52v9*;$d!j9jj0OiOy9x1}3SM+-r*Z{U>!CyvQxhkktBDZc^v;ri zgh6N4Ocl~0uHkDKN|KBVc#wh``QC?S=+we8Ey9BM)iM^FT2ZF&b2cQiu8V8Os(twA z2WC0VVn+B=@d7$kjl47Ke0&E#r9J|e1uVNFoSJIZm@69~sy)S_e_=qkX7ml$ry7qU znaa3)RITT!gaXq&9vgZ>4IE3EheA>}*%6E%wx-RsDckT+aHlvBMA>cP6F`AO;0o#( z98!`As~L>E&xnk!a7WnmC-*nZW^XMgr)IS_c8NS*72>tMQOq|`(P2niHjrOrDgBt{ z?nA5AH7+P1A^mZjrCBxm)t0kV;sPqUaJNuU2}!$tq8Yg z>doa>fss`iRXB4ZF)VbwpHL$HV^u;(klmePdaF;k9y#UeG4JcPl6Vjp!;3nu_g^;9C<1! z94c$zc1M;jH3#$thp&d1tJ;^?in~(U8-jm)? zQH~7zHV7Z8@*Kv$YkM%k%(a7!67{&g>(BFbdhz()aZz|+Q1-pdkDn~*4!ON`FL}kw zzDZ^$B(E1?N7vEwv+Qd@y`lBOdi(85m8K9}-+kkj_SuvGRAqy?KW{Tf`C&C^~3QSFV;#7^^6T|!Yqb8fD z_VAWJPlk>Ed_D4n{!eA4{4UmE;#h==sW!hzTiqP}-A=O)lb4OV;S;pySp?I&&A`wg zr$vgiSwAfVot|-!zJ|ln3{O(qF-_Df?L#Fvb3MrM2Gt64QxQI051XL{Jg zQW{SJ(j8>+?0CQJO}FaP*z5}_L4`%>Q8>zb?~wl;@kx737a9DC^z{D>vVV&Bw1Lvn zim(G5NJH!>u(O7hv)|D^DEGh^7kMyIw6-7@a+#C?CM2DG(aFaN`?6O`a3MRKlZ@< z8MOaomxr^9v4f?Tr30&nkB9pW>JKQ0|9-=pnRzI4$Ui+>P!JI0|HPy&Evcd|6*xQL z_K6(=Vzzf1ivecP+!Y^`Q<4nU!d$hGpderxql*4@dYLb{r^tJbo;Tw9>n;Lg%SAkT zUYiwjIX;6?t$#>^Hf2ACZ1XMutPH+0ciYu?cH2BxS>}O5OHm;FH1v4!%4Ndr0Me=|dqSk71HJ6>JNC$v*A0l?kD!8k~`>8zO3%O#BAz9UIZoA8V-!zD#VfopE$du(TII zdCGoZ=_njk^~do7yyM4*TY9BO0^KTHJdVr4ovgUJj_7s;2&>>fGYtua1O5N*qx&;S z|Fe~a{_F6!uDZX2|K6|hZzu#rS?JQA*1Ug#|D${3@8G}JcK-q&BK{lvpOxPKME~Ei zC4Zsk@%}$@Cx55=yA=PT8>apTy8jX8-?{!SpTD>aX#Rogzr^%+&c6%k|8Ta3R{Rs^ bzh$MW0Q)aFL%{#pZ~mxJ=1+zR0^)xGr9fX$ literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9033.tar.gz b/dist/amr-3.0.1.9033.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b4496752d7987a750b3fd5d46b6d5034ce8a1340 GIT binary patch literal 10445 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..ff594da21 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9033', + 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', +)