From 59a84da1912c68f433a6eb5cd2646f0c5d98bf25 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 4 Apr 2026 09:56:07 +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.9044-py3-none-any.whl | Bin 0 -> 10601 bytes dist/amr-3.0.1.9044.tar.gz | Bin 0 -> 10482 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.9044-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9044.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..22c60b970 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9044 +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.9044-py3-none-any.whl b/dist/amr-3.0.1.9044-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..61149f8e01ae43612eda8a8632c38cdd6f885ac5 GIT binary patch literal 10601 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%0Af@=z44uq-n!3s5qz#rf z1qDAPbUJ|hwGwpDV3-rBUy7-JER)O#<|`v(9e>@SGiH>?;GjP@X77>savH#dnHVSn z&3{zrImOanvJHKr5SNOMDr^)~gHpLzHK*4~qPOy1HV2>f#T;CbI6p}uZPZ#kAMb41 zypa3hhR9FNe|7dkxXGns_;Tfy&`G?^oB~3)Oije~%=91kEg%fgbYso6b;Vw2;3Opv zy4(}mLSd>!#1mra+4gF$jZptD!T8IEsM=OhHb7%_7c@c9~?+LFm7&d#kq7~kwja!V*KJM`=#m z)v9_6R{a1vd)xMhwc5iT?y{+C^CWx!%K6SIZooFruwLG(-?r0scXT1J;Fz=1r!>3T zJYSP4qIni<(S9H$|*ITcI_TDsqR^5`lG%}#=q{eOtPu;-~>7%=|?(%ZA~w*5u84rddlIl5o@ zwvG6@O1}-0kR1Lu5&ee$&4a3I;*zn|-Lhf#JN^Gh@g6oelr3Hd7(Ad?Y0`HvG-YuWFxJ(&G74N?Ank zu*FXO14z=T+0QW>B0XZ07%zLdkCR3@UUiTY6F>MqYd+`vDqhFpqL@Kw^RL8o*rQpO zvrUy*bel;!@c`&%A5)MZH7LqKrQ@BbNYBom+Y4Om;Pg4G)aK5fmRo|HN~?PUeBJNk zocLSi(FgO>rmHq;t=gbWkdd$7Vn3Ll58f$Fb3vA%%+G#c*y3a=x+y9X{