From 48f96041415b41046de6a90cbf401068c6476d22 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 20 Mar 2026 16:02:18 +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 | 228 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 940 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9036-py3-none-any.whl | Bin 0 -> 10602 bytes dist/amr-3.0.1.9036.tar.gz | Bin 0 -> 10497 bytes setup.py | 27 + 12 files changed, 1683 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.9036-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9036.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..887b13010 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9036 +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..42012c791 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,228 @@ +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 amr_course +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..4f28a517f --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,940 @@ +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 amr_course(github_repo, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_course(github_repo, *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.9036-py3-none-any.whl b/dist/amr-3.0.1.9036-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..ec4d9f6c4d2e9183d30b83d2b886972133cc661a GIT binary patch literal 10602 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..890542ae9 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9036', + 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', +)