From 659c059cc11f05be840357c8ad8bf61684769caf Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 12 Feb 2026 19:35:55 +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 | 225 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 928 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9021-py3-none-any.whl | Bin 0 -> 10547 bytes dist/amr-3.0.1.9021.tar.gz | Bin 0 -> 10423 bytes setup.py | 27 + 12 files changed, 1668 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.9021-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9021.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..d79bf8460 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9021 +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..695027456 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,225 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import 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..83384be5d --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,928 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def 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.9021-py3-none-any.whl b/dist/amr-3.0.1.9021-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..31a578277d346df91491cd9533a4531f04cddc0c GIT binary patch literal 10547 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
  • H}z`P9Jls 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 CnNCpv literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9021.tar.gz b/dist/amr-3.0.1.9021.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..9fd6184df4771f572a3028c8955e1a5c9a4355d1 GIT binary patch literal 10423 zcmchbQ*b3r{H9~uHYc`DY&#Q8Y#S3}V%yeCY}+%*MNf|}32f1Q@s8m7j$P^a|i0j<+E8)kUymIhb4ujNbML?wHs7 z1y)=FcR6+Hl%10Xee8~bEx3OH!O#uhG2%D!Ine%=#k<_O@WBgM;t>qEA*nS_i3;aN z;`wviOEGss>gu0+rgO4NQ(_vcdZa6}<2xAIp>v{ziHZM!jP;k<>?ybT+GT0p=X#?R}*BnkAZtz zj9Mmnh+xPt((n09$wKG^ytIRXi4F^cq(pmyIl>ZnT1n|1=8wZ|wUIh%si=fjG7HwNYg=X%G!kT+E5#wf&?h(9hb&NgTFD#w#p1s>p^0Ge zzNzP{pNfQp+DO5o?&{XHH!Mfs>(k+;zT%{nTZa8bk$$0crA*ODv#oNLL4lx4IVX&d zLe(0vm4ITFRV0{Fv=IwI*bZ;gyl1j-=8&`uRo6gn3YXLM-@F<{@Wh0aO~c3j{oxf@~#t~2|sq-EtWBm8ya8BJm+NzVDaw=VPNJTQmehR}KZY@@+ zgGYR3p(88@n{BcwcFGOKI*h?7#Z&Wd!KlX2nJVU?sv=5@Azj5{MHzm#dhZw2i6MS&AQVsWElNiPwi(5oUY|sK5zbGFG!;R}Vy)k4muD zGO~O=`n3+lr@bN`FF1=#Ex& zid8j<$ScE`^`gQ4?IV=JILJPs6{VGsVyBok+wHBSq`bKD2+60VjL}^VxudS zpGq9)#?=i$o4QbJfs!0Xt_oJOs3}yfq>vtG_9;E1=+d7fq^{kr6fg%rEi&mYQG8#0KiO-k`fGeI! z(K`4$h%>etOlZfXF)7@H7Bma)vlDZljjDp2_M|R><6bm^X_N9~ooLVQ;jb>ns5L65 z3B6+L;_*YK4KGe?Dz#ye4(_Rn$ zyk~0#t6qXNLEweY{`ile)vX%%HSjX=^IPfV$G?kT>Jsc1#pL&ctc|nUJb(MmgfLkx z4D8RPsQ9_ERI?9^DylLG^xC!yC=XD~maZ+%MB+v2Hr5lz!8Rym-SDjo`y4_FWdEuo zG_D|If;wH>ty3hqtJeiT>9RanUgPyS(CFpzLu+?X9hrf|4cbc!qb*i8k>@)+UGCLp z9vEZf0m1bfbY1*gD=s3l|8Vv6$p*5`Z$h7E{hfMvT^EIqryB+E=U%RTgLjaR>kFC* zE^aH9BvRpoGK=#QF;7z_Ro47uilE6t{Qx{vER#12kVG-1)M2;eK}p7DP9XYHZpJo| zhtDgRvms%=Ak@I9T!h1EA{6gW@dY}-`NvLx>`2=nVgy{5-14%?jlEg{o@@qb+se%S zMe!5mrwG8VacbHl1A_1(Bw<` zg7QjO7g<}KxG0-M3@$CzX^P8E-1uu5dee&E3xmJxj|pR>runpMO1PtqXwdK|#hNJY z7bs`K%q&0PRnR&=_R1(7mG3g}_6s@yR+Y@5?P+ipQ;XPTCv9%)X^YluUqA#AgE+=x zEnH8wqJ>gHsdJ=1-+e_ThuZm`wDWZ~GDGSoV|3-Zn660PfQh{Aa^D2rFLlXzq^X&n z72Z{sXiQ<@`Ol&tCrXF(0tn&XS#be23(7xYP~-BBpN7$@f#j-#+lJ!84g{(EcO*8P zlIv=51A8pxPHX0;Bo8FN{RtbqcRRXW6dl{V(@LNE-7i;Gm8NhllXL8X>%I7T=^gb{ zn33;xcPUFbkJrEg;zu)oJIb@}+pm*`==z-N*N;fnXgzz^y=B+PeYb-t+E~2hp_!1@ zy~lHAMIe?KTlNPJbI)UgWPJGOI~Eb)hK^Ew(q$IEQR)ZTEx@rD(e*Jkt!@^|64yZN zm|r@ZLM|f-@lI9AUTaW29b@o7)TeKel`uDU&hZH)SMIBNaII;lQIN>9In-L4mALm64S#0RB@Y97o|DkO;D5CVIKG=8Qk$mZxEbuj{ z)+}v_VgL%C#a^q1{YLJqLvEmoFDa~OW19ITZL?joF}_op^$OW!&_TjLrJfOHO&o`t zlG{i8VwyuMl{bRHi5grk6a5sWb1Q`S8Jx7B?o>1gQKc4NHjw1dNTCnSOgb{S$VR+2 zp!{&DKcmInEQrdr32%>xo9(v4=b_344Vq}wgrkHY_3P(`}Phd z-Pm{7sp&20vS{?w@918*L(`Q{aM{Jf%g4wV$hG-ezg9h9KY_^*bp{iKa9~Hdq9qkk zl7+fCUbOQpn|sUGllr#rfANcQ%sYqB?0wnhlv(B)p8q|I)^_QBc^osWgo2 zW+9mk;jdfLVg)Ta`o_AO2YbjE)^8snBAu9$jDy5Sn~7 z+ohTj9kbmR75g|PtO^@Bgl-4!l@!3dR2SWpZ*tOxdd~G=}{VD}?4CZ}OF5x8$z~UJ^_f0vddfHcj=@=5QFk$*MFf z!q3Oa-jsj_L{Qm#+w1((Bw9v}$ZAREFIBq+*Eb8w$o5v7Guy-6b(#r$n@-XCL|% zAGjMN0GR~lpW(XyfMmo>qqFknyJ)bA~LdGLB$6y1~Eu1T*J?> z`r}+O7oQFH%ZDA2^-mpn+NClO3_z25jv zd-TpGwt3j?ArU;Hw2gnvI=&HxM|1REzqjcaGCfaCWA$FZ?)&bPA5O_L|2*FH$Jezb za)fysnI>|1F9|C6V{o+@r#Gzqq27;@@(H; zcp0+F*Ig-%`|spwBu@A485UMgA{5@fAIv?G=m&f_*2eNv=e=TXTd!`aw<%fI{U}+_ zTYmQroY}tpY-(sT#Pqe3Q@0-`S9b=2JSt`p*RiR?w?~*hobLXrdEF$}dB^k|%R#VA z*WdiViQ1sE%SR{vQyUXha zP|54w(ozaQe@*eK2_15r41dvVvDD{k=egB{6d-DbLTqOtysWhOU1qiwxcv@cNtn|N zhjx6a;MUcQvI492#ij6f7^sEP$&0Lw8G6QEzK+r!R^$+-s{vQpg+Z!Ff(P0C5Y;@;VSwK&^#eZOY z*kJNMp!yGR{|83?0o;GU8PJ2<=)l?RfLst|)rP{nK)L4+Nyg^E6&!>zldZ=ppKzU0 zBuWIm@Be%}>eO;80!j^9`x;gm6UL6VsvgskMFEdaC8cd>s2KXuC9sFAM`6r8#*BO* zjA1+p_4{EtYYIS<_f1Pf%H4x_%uR`(>(~+SCLQWLG3vtql1fnd-#?8@ z%R%wRsT#3DL4}0t=0Vya8)tdNVz(S_k(KWO4gGZPo4M5~7qTeP)1lA!ECB&MRS2$F zPzC%=+jWckW$W>8jKCsFRx;TRdfm*-#@-!QGsY7iq+S%Wukqm^D`0uM;A4oTW(Iy3 zPZYmn|BWNtTz~+Sc+9L;$+)~$LUtn_MkG8^4l((SaBz5K_9SORF7>_(?mR|2>Hd~e zw1>8&Zr*G`@2@r;ZXP@fg4=jC*P{>RQrU>pJ~(u?x*(g$Fypw2rVnLy2fP+#tGS0@ z2uy1wsgX7mrn2u+SAb>rrOShG1w=R*cbjzo4^}qg{_R9Iz@8p>x_Ki%mCHiS(l2;_ zZdL35wlyIh0Mba+6OYz$k^l_ta}x_mFzEKZ9K{!W3}@Zi(UaXf(rSUu>{ zxIIwj@VzM*zi77vUf--UCAc1Lcr<~olV;-I+i6`MB{j$JWXJxVtgy2jI_e*1p?=ev z_0nuFmdBnV`|`u5gG86oPtN-^bf?-^p1>ALaYD5TT}m)es^Qm*9`uA9naG!2t=;2M z&9sQzh@BUmtxY0sxUzNbBrC@X!kS-wRIJ4>M#D*!k>N=%?xp9Z?^Nd{9j z5cOh1(#mEpxD#dx2tb$FFqza*z3R}RQAbcQbA&7|&gU9~Q0_`^vZb~bM5OcMG_xL@ zEiO)fL$`Ih^R?e=}EN6%a|WefLCJ*i~cfbFY;dTE&*OT0on3 zhcpAq&jsK&i%K{do?i&}!*JC8+pxc03e;RQv!Ws&gensJ@BCR2$A4K;_ncs!Ag5#e z-<+3o_x5aPfu=?SP&R>Y4UiJ-5*PRyA^j`(y;?iZ!+|WgFXsWXim-vA7jrNkHlfk= zish!_2oYRhtmTm?#EgHoWcw#~o3y53I!Pm!yoJS2GF@6#8~)!D8Z4~IoA7_(d041Z z4s=uDs$Pi1sCeymqW0h?Mr63O^0qpP+ga1iE0YnB$2A}Qzl~i_=IreyxD%bK8h<-& zi=>B}+&PSfyjAg~b&8rbyy0N%Dn(N}pIur!_3APs>(s^bI$wvr`i*xG!v&&^baM)zsC;6BEWtSVO!F~$&OdsfP;JfSX0>hrb*CWX|@T84a zF&KXM)~Bl+JiadvPG0hxxCQ?>1ApbF>Y(wt!$!S<8Q^jR61Ey)M;6#ppwt37F;bR1 zFZgM6p+meT^C&NQDf(2yHUdKEkt-`6^N)epvtxTo=_$+Y%D$m2Yh}4!*)L-;f zS6REbE^(tv${!7?0#Yq12S*r+l{bB$MPCu*-t?;k@@oH0;ur= zX2vdsfcp&uIn_X2&;UN!>B5hUevV#)cAxi7Tp8>CT*kVs)5XjArBq=D9iqX^GAm^N zhmztGixXIds7sE=Z7YVmS?sqmfJ5WuC0<^^ob-4vY(voo2yZy&bi*4gCKEYxdY@{rb*N~)X3R6GVCKXMfXOu zBzR#`&ZWaD*#iXz!dgR{7^82b)O41xa@J)87?8r#YQMO^c(q(ZOd!E>6UrFLwXT;} zZhjv`)iQ@<%jjKV=ELnWzs#_!^G4PdE0=Qb2{t1b%es7A1}wp^o)Yl>MsFEfFC)}w zR5sZECPa+&xz_IDS)A(yL5wC#>L6}YeWxjZZYfy^V}#-_?W=gaU&y0LBH`DdgtJgW zzT#(Sqw2RgD|Q!Ph%3&SslhO%=o6OURt)cun=?*`z`%~c6V_3K$bi`BsH?d-)L=z~ zV4%$<&K-wvS3*l+$lQE_OKpqq1iV`O zV$9OJj{S~XU=l<|YHxui0cAcIIyRU>C~;B&k(a@vAis58Bg=+mYI^^*dV98xg{1q1 zLN>U07xH6DuIF`w(?zLIIhsw=Ol#BIllqX~Id*%XVIVL}WY|*BriKtP^J1(0U8#t0 zjJto4$irl-yO;u&J*Bb8@$}jTxCIIQ`O@J=gc9D4Oi1{(|g&U87hhk_(?KBNmfdf2qU&MO@MqMks-A3|^QHlk?v9a4aa zLD{=N)2Li(MoebQ(7V3R?>0cZBO#wf!hz;J7uwRTzI7i1_rjos%L=lWMG!H_bLddL z3!{4&;|Rau)w7KHK-Zu+MlS87xw^8RC+~-2Vpfi^MzM_8hKfr{3~bB@0GbIFbqB%#7 zX}`LUWagm$@7QE{w$A9r9%AQfOS_F;FMDsR&3xPYq*=&hiioHKgLm7c^fSWnWfz0i zcrA2T!rdJsqTt2z{_ktV4LDO>%^SnswW0<`Bwrq<|GHOwS_V^6V@zO{fH;(D=6o-R zE?`QnlwqX%g#91s1Wev;NO2O$H1M!!CQ;D0NjbWXFVf1eXtQzCvf|5v;g~tL>Fk#t zOc+MIaN0~Fys0Sw3OMI}s0vF>=e-fC*3X0#%Ij1NDckK^g$_p7Ojk_U#Sko)4J}Yh z3#Y>8wGa=D(wr%2CQg3dBM{U-a0j{sBoTTuOC5C~6l4d@)~@|1Cq}=_z}wmyLZC>I z6aw`o2fx-XnFD)l!G*$sH5~4g*k4emrBY!`3WrX<{K3VhZ@4u|1exv#YfpA~1-ECDR`)>mWjb5^z^aRZ>Lo?#W{0>K@ z>dO;RrNf^?QjZObsZwm#$AIu!3;)VaVgq?`S`t9O;|w$qVG^i{Fu$7!?z!|Ft2FPS zyH3#>cwzD6nz{QK3lhvWMv6Em<_ju}a?Rl7{+6Tf6Sw4=ih1mhghkxj!-v*LOdz6Rh;U{;b>@*kt=!b?NsNINM=CcxMYqbjT;zj(beh$ zLwtW3GAsqN-jb9?9@q!)X~zXZF^-KBS6f%*6ZtjHu2> z)$cdK39&ufR90@z`lOWQCFuTc5IR#$Xp4RKlfC~&6h>=?`Fo;q z#K`;ofT8}t14@41)En^EMO5HN+H8x^QE|_OP54lcRi}|0Zw$#(3>8RNiTEh`dR2!y z-n(2{P-g(m8s+tXFt_x|C8Zb#&liAzWC!U-g1Cs+9 zWYs}9ftWQD_EVLJpN9D*WlC@#R|k^}>BziEUAbyuh(q<9)IM|{*SevkR1PFyV+&30u1;e{v5pFQOQ=MK1;PPHYmQ&@_Y zU~b~pJYs!le6shAoUc#PKpT%^gqwiqniKR%KNx!!n_?$rNi%M*g;GLKS?o504c&w3 zg^}r8Cr!b-cCa6^a+&}oWz|C#&~tU-A(-1)UZ^d}O~1G8gxhRj!$@lzT?l?WTeSbU zo36G_0^P6Onh?oakGV&QBOV4*!0Es3Xr$|xZ09D(lzw9K5~IR>s0RUigdj!^z4cf_ zZ!$ATBdILY{bgBC66R+;HVT!VV2X`JK&QV@hUgnjYXRIePjHRxCUg{aMt%O@;4qV3 zNv5|QDaav56d`W!`}&-dRR;&62e+7$f?O46)6=UUd`0(x!Rr=lfBPKE0v1ZqbZtl)7v{ zI&2s46eB>eZ&Y9SfL=z(t-rpLs1_#1lMVYGBlf)V0@s54lo&#v+_YSrTkh=XZ&|yX zIk9>AFxkR)V%n-#Ta3_#cU+h>XCuYs&aI(t2?^^jlY6Qx^-1=Kl(Dkz< zQ2$p}SPXeCjM}*>ew8lhWB&BihhOFGk)8>neoH~HHJHU=_v7ucl27-%Mf6nl4)1dk znHjpGb6Ysqsf~Ss5B?H1-BVsL2KX!o@?6+|WGZvle<|E<&^IL_Ic)u$&+!d8Up0t- zf%N@&-4k%1F9mU{d*pue?m!grq|deD*Ac&{(e^g6IX1BL_7jyW<&ROzAqdB%KVr8y z%scba*`)9n+aATYRT+BrZAOU{eAV#|d(!|cUwR0(RRj+BdBq;+@)f^O#ZzuS_pA)Z zp^cLe{Qg@Jc3;w{iR2H$v>i}edR=UNfQRntx%&yX|73QrBSXgBeJ@k_SBt#G08|50 zbJ$)nRFQYS^Y?guzn`!6jYVjEF0-PPv?^;{D^#%*>&g&3yZ5hKIq&n?wU&Q@}H_Jx;2np@Uy@r-#y!I|jb+jvLHsRfxL;DJd^CWJPtLvT@f97<;&5#xP z9V(5;N`Ya`Rl^xAFQ`SBfHP9_x(BG#rK(9uy5C^`4sr3830EAzW*sT4MunU zSzLD%!~?E=HJ%3BeQpD4v(N_k8Wo#wPp0BzDdD}aBR z+IAdz+H%`*tl1ur6{P3wvoM&*)daUfw>&S2?E&E4eQ)qMlGK+Zfq3YWWNungeOf!e zQS$keo%JAwHzO&qjYLfxkwgCA`caU#<`Ou8wjp;P6Go*Fu)6aeH(gLGDpI;}J{j96 q5rej>M