From d501fa79eb8ce03f80e6ebae8e82043f2a21c1cf Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 3 Sep 2025 10:14:11 +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 | 219 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 904 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.0.9021-py3-none-any.whl | Bin 0 -> 10441 bytes dist/amr-3.0.0.9021.tar.gz | Bin 0 -> 10290 bytes setup.py | 27 + 12 files changed, 1638 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.0.9021-py3-none-any.whl create mode 100644 dist/amr-3.0.0.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..118e2e531 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.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..dba238d35 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,219 @@ +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_mic +from .functions import all_mic_predictors +from .functions import all_sir +from .functions import all_sir_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 polymyxins +from .functions import quinolones +from .functions import rifamycins +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 eucast_rules +from .functions import eucast_dosage +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 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..0916f6cb0 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,904 @@ +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_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_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 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 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 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 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 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 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 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.0.9021-py3-none-any.whl b/dist/amr-3.0.0.9021-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f34aaeaa3d9aa7f47f53d15432c2d17ec42a648e GIT binary patch literal 10441 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