From 345c7fd648e8e712e8e01c6bdabe2045b2abff17 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 22 Mar 2026 21:21:38 +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.9038-py3-none-any.whl | Bin 0 -> 10603 bytes dist/amr-3.0.1.9038.tar.gz | Bin 0 -> 10464 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.9038-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9038.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..9fab856f8 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9038 +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.9038-py3-none-any.whl b/dist/amr-3.0.1.9038-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..a84fbf25a416659eca698dd44a7ed49c43294a9b GIT binary patch literal 10603 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 Dm(!se literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9038.tar.gz b/dist/amr-3.0.1.9038.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..dab735c23117068c42f1cc174e3a103b97bf294f GIT binary patch literal 10464 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