From 977da5c09c285e12088230fdf07c4460a4b02426 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 27 Feb 2026 16:15:53 +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 -> 10433 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..b843ca0bffb59d3744004677a8912ee19f0eb446 GIT binary patch literal 10547 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.6', +)