From 50ef0445453e0130f6b74cc22db0c2a9c3fa65ad Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 19 Jul 2025 12:10:12 +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.9015-py3-none-any.whl | Bin 0 -> 10443 bytes dist/amr-3.0.0.9015.tar.gz | Bin 0 -> 10293 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.9015-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9015.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..263b47af0 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9015 +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.9015-py3-none-any.whl b/dist/amr-3.0.0.9015-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..9891f2a8caf1fd68366e75c05346da27f85da30c GIT binary patch literal 10443 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 BQwIP5 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9015.tar.gz b/dist/amr-3.0.0.9015.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c83a8cc5dc34c787bffa3696fcd35596e0692268 GIT binary patch literal 10293 zcmchdRZtwTxBqdM;_k)0#eJc;wYa-`vEqxnyA{{sQruk&l)~b+xGnCmm*4y!{`c{| z+&js`cRq8HOp-}*&Y4ifprBC1_}aihO&wj?KXY)s7eOv=UJiFtSC}*ZXIC)aU+1?) zb(5b$mfrC-ox2Su4;l<^@-Jrw2A;|5(-sOra&lHvt5>x8<0Z#kBi`K*`5vbW1_f$4 z!OxUaSeY@*1*k8iHas1G`ne;|j!lEvP6!FF?!|&^yU)1hZ7YZ@KH66aa*y=duf2O- zh1|BoRRpU6UC8jpq{L%vB==ktr^Hr48tvX_o6o_ZRE?Ldsk^zQ0)Ar@AocXQn31m& zKM!cW1d33CjT0NipzHZc3g$iH=a`J6-Iq2f?yvpzAZTWeA>nfg;(lpc^R62(*nq_;S;C>=GJw4E5d;EHVEZ z8P0|lwfA830moC8V$({U^~Qm;p`M<>jg9W2%LHJ^>i#RT0{saQ)tc~kRU`(P#h-#Z zcS0^7ux~ny=2t(@xr1 zWsyFknfx7Au=oOq$b&mIwv7%AyqzR_eohjPdE-xGbZqRt(|c^9$r8B z1UYXe*hW(x4hDnxboN9tYR#vwo&?j=*P;e%do~d?cZ$lmR+&wIz5W3giFbIbla9EnP#}0R_k+h~)2&no5Pl!mU-^g5^ z{e+KZhLge*V&1+nU_@eMlcl7x|9RFW9W$CEbvt4xOlj!rhr%8bUYJZJVr#Y{zOUcP zQBmv34F^%W!jV#$R6^e8mdh2T^ckAHVuT|8u{yo7?3K$-PS9mKJaw>ud5@{XNlvh~ zEO)hm$O{@@SmiiVLx{w|A$CodHPkocD+|0oOvgdTy<)bSg&3)PG#Gc8Y2ABfV z_c~-{2v*%@(tcANY)#+sfYT5*@%M@m?XZ;B} z2PiJ5ex0hc3>lk5x1Al8hzQTJZ%6ks=|BJIrx;6J1vpP#UK|MK{#wZuh?E_UXrdsE z-&6+TLh345nME|;aQo){Z*>UKHf~+#!^G4Ju4Y_&uftXl`ySH)|iL|8+xf871cRkL8-lq$I_AsJ67L)@7i z_a8r{&lhDe#8cShWtv0EXiBz9Tq0GXYMv3mvRdw@vaQT8Kh4U&fh}-MT!yZ{7#aa2 zDr9pU5}g{)1O>+*@&qI&q7&_qdEZ&S{K8fpmOP*Q(nm}rHPrPN_M+762MhUwMg)Z^2`#NpUQ#ll;f@x({8Q6A{ zJw=qSCKfdacXiD;erQ;i!M>eI)$Fsf*mQz~nG}f_Ws!)PpA{Da|3!Q=RP8Wp_EAxg z^K|iQu!d;$UGrQy5RM_KsquL*OCeg0k&-fCRu&V~w|~qSnZ*pME-t{dXta4QthP_y zQ@xj29Q>>p&Xp)`$nR{1x6no?P_zSMuqek8v8Am=R3X@HDck}&c$fi?U&5vMKv{g}{;bpB%_?6fys z5fYDfTqNnNhW^_U?m|2Drqz{XWw>O^PHM7TNAKa{sdNH{6Q;bW42aNk(8*9sR9`wz z+|i-%>b8Kfj-y|Bl(+GCPwP1R(4P7X`1g*u8>$F_{(bJfd8_;VYP`IWi@X9|AiIAm zu6Z>c9rb~NqzslnRY6+AIFWA;YEZR=Cl9h#lTZyNJ zw3=-{X5r8xHUhgpgr4opNe!I$@nre%TZVEUlRZy~%kLTZsUB-SFIfLusTi-*VKBjDzzepBbJ&)p z%)gfY)Ajh@0q7MhPTf0r)blpx$2*{{FOL zMtG~8Y-IM&tUD~GmVub00nNz5#F!C1w%MeS$saxEtMYuK&){$!HxAW;GPwyt7l13@ zR=hz=;Mi@E$KA^F#n2ngVqEyfvfgqzJ6r}f){lRA5ZGmAK~+krZ(E&IbVkPC=umE{ zq)~yMLO;8u*4}W8%KwJbU)>#+pp@xSSxCU``))6bIrSYCpdq1(pb44ON^bO;$4G~* z8I|QEj}4=}*kzc@hgA?DR^f}!fYI%;0)K9&hkEjT61H`P+uABfV*~BcwYnuy`<+R1 z_N9H!M-C$Tm)hNHjO3*|KWUknPUs7p@RF=U03qd`>jQ5NB zzK|`LUzi9k3bxL^5Zs1K@_eL7OlcvMdtlX7GKIIL(wl~lt^%8FsCB*Ff25K zr#onWtsiE&8O6J(O8<&YHNq1wf}A}?Z6A%J(`7lO?928uBoC0q3HO#q$p6c+V)`!K z^&?am6#w&f$lx1cWhK&skMF$O-}JqqMrsHI;>O~p@-~C>3FyPZHk{k*AA!$z>+ie3 zcQDIQ8ME9YOby)ihYwzAS+gh9`L@&}{87diTgQ4f-j~R^_79X~dp&oDkDM6gM0H1# zRP#re&8vJSre2qlpSHzyr#SYa4s2h#T!_WwsBs}cG>=y zUpR?>IRDV9xrzxOkZiPcvC7?$+dK!~H8+WGKa1FI-&Jxr332?gm%+?8$$8+E!MU== z@k{zkt8PYQnF06?0mI{#PxkWjjAhQCy04V+Mkxq*^ORr&ojVb?KM{Z2xsT9;Nv?(7 zM09Uk*uPpYzyaVV4`sjka)iRfB@L#QOfSME1c zSyOef>lU~IGu^9Qd3<19K}L{9PrjocuK^}EyO{xLzc&)@kg{=J)_dI)xM0B(4x4Zn z@#_AYK2a{%-a(#zu_>Y5An$g*K*2NbhTHdn(Ec5YkncwBMB9E+7Y>=4-L~IBj6}3$ zOvBA#@23(q`QD*BP4r1VUo5htqN3|7qO@Bh4ii*3mOO7#qTKyQ{ybt!Gok8 z0`!u-jxGMks$-&W4e!x8JAOd(8l#lN$dJdyO2OpMYp%q^ify0xl9y%C!h)oCj+LJN z%0`6VlK2zU;09aFj&c}Xhi3qGQ9|V2j)5>FNA;fkDBxq;4kUu@t>KEbW)RDo_jpiM z!7Np+B0=KMxZm{bMRdSf<#_aP&Q;p^50|8kQ4`|Hi3a81i|9 zT48SoF?1UxVJf&6tO3tBn1ov;Vm|I}F+c2;ACeYb`F!L`G;xjy>qBlS<>p#@bnX2% zNS5yp2>bxo21^*)(^4Y^({QenR)qxIW?(nDa@@!dZg-FAX!WcOC`kuY(eJT`#Oo1BMaaip_}1v1qCB{Vs)ESU^-lyr zhCyH0AV-9v(gl-SD3?U}49o*T5ZEBpNKYYWi zaE3^-fxRrr-=5F6`xWaQ=rTezo_3AKIhIQN)dE&uY@aRA6_xWHW?2^)d6y9U8@~>& z>hat*UtJhR_oWx$6sVd-_&+U#p^>LWf`U^k;f#>vr(|sq6#|L2E520gO@bs=_KWem zYALt|2hw&_rxiYH5Uf>8FRRBCGV~!NYkfh`kgS~8b^sp)p=e4Np<0l+S>g|SCU1E$ zG>MDK-iIKzK5%pLqz)fnxy5@O{k~h(E>r%tp4_w_$Nz~ zA7`qW)8w`cf%VgdNvpSUO#Cmd`FknmJx@Bq(}Vt(R{*--4(&wEz|iHtW=bsA=@WI?72M&;0#p$F%o% zm7oE(P4tpL(9RHIT2?pFgrgG(E8%PA>T}`Rev2Pg_yEQx*&*Ld{^;pV;eN?WAa0s> zH?j(;%Zj_;oS{#V@b@sGyeXq5w)~405o&?EpyWsp5UU(lO<__d=q=0 zueTI09pCDqM*xw$j*6)C)9C$B`}F1FvNoFAt9E_###C8^_wQ?Af{lJY82WvBs1BRp zvlOP09U$s1(kVZo>}vI2FH&nf(Ef4xq6beSNSsw{P{nfdj+2h?Ml8>zc!;u^g}Ufg zL*)r|Q98vZY?C83zFvLX+(?kR;Uk-7QmCbyyiNeEyiPPdjUcC5l4o@=t;2ZegL<>2 zUQ<2q_xU!`INhKxOX<0H>O7We4L0}I0ZSEV)4K4o^^1AAp}*ifQB%>@7>~EaY$J2> zDXJ#=uCo(_A$XX=sshJ+Gjoo>rwjmZV5mrm^~;r4;`7XO#aBj>S2;jCqjFfXR!TL&GOo|g$81d;CMDmp+js1xQ0!JQq024;3sk(_ zDPf1;F*;VNHy@T3!@N4)TP`-n&??C0hTYUAa-BY=2e{XW2 zcm5&YzEbBM{CNk*{{gt~KagC!d%9@Rc(781@S zHQWLRX~{PEwL8QO@7xi|p0Z7v!_xJyU}e8-s0(gHhayh_ONn!+FVnpY0~_}X9LM>^ zMOmf&RQ1u+fU37Y?*=a~5 z2y>oFZSayN9ZpZ7$MRX~V_#$C1o{f;m*5uThZZ7bf8K%56LT6xvgR_F=%s{-fyhXo znZ&kyVVDJxjpBmV$+H5hGQ-+l$?lg}OR7i*aAWTxSJF+x97yMcXKr&fg#}BMgG@Kc z_2`Xzt0qB^doX$e;OE=E?zz^D7oxx_VlK5FT8`|m#ujwGIii&qdrRF_)ZD)45Is#x zMDU#>0aEslSjmh4U{@GPy4e)dIyuUIEnRkjdb36XJh%oXGc zFk+ZSKykQ6Y6MvQc@Cd1@RM^%1%iL%2NmPKy^A|+!dith&Ir2Hd|MuM#o*n*Arazu z-osnuXl}KHU#<)3>zA!vd5UMu;jvd24i0GyQO`U0H&n&v_~^VfH@hwbJ=OMb3gpss zzO>89WL~Xjw;H^`cBj$b9(WU_=)k1C-KdzHUyDK6fw)&i6Dl^S_?P!CU*jZ~EL}n$ z2JJZ`@y#TnWv2il=>AqZc3lkBh#&U>>`0zpdQF_F(e4!32#lMA(!13xPql(^%4nDsEGYW8ukoD}^qXX-Z=!W7M z+G)q$A35vNNSO(yJ3FqOB!z8I@F+>F##nL|zX5`)Cb~x0_&Rh zE2Q--;ukTc=GP(n;um*~dzm!NZ>Z!A3;azQBqi^(L;5Elwx=z`51L6Ekc|-UC8oyI zB8^FYnf;X<_Sy`1%w;{2npJ4W9d-6uy5}uJ0%tT-1AGFt`?#Zt7S{7t z7eprjFCT{uM+!uR@eojoa%QbcLb>}gN76LNL+FnoB;W1~<0;D&TbkQ_piLd`N`OD- zEosXW_;F{bT%2DHO_tnu?qaRo^3z&eUoj=eQ90D8gP9{p3yxwRQN#vZ4%IM3lZk#c zV7@r$EYe1MaayWNg#-R(^(pOxgd1j2!zpt`c~pL4lj}#>H$KjONb9j|mOA-S7V9{N zuT3xeLXJV8`wLlX9FH`frBNeB(ds_vx?gEB5?@fE7?!00>1$*hsX(K1sis*m2@Ak^ ztzJK)vSD5>Tzae0=S^c6GM>GI8}CM_{GJ%iU7^fVD-O&H#M8?U;3wv|$G0~AT=M&oVw%}oSvqnkID#Ash;5+%b)+=Y_Naq)r3iwCjJLc| z*}X!kpMcb}P`zvWSL`R~4rG(!XK%pezEmu9+(x4iiadDv;3Wl37=cE9&xT=51R zrj4E~lofA)QC$t=UX!Ns2Ch=Uq^QmhTe871^J(Ci>-Al#$3z6%w|E zs4$+EB>3YAj}(DdYBJLM*FLa3p6}3;G;_c~_^rOkiW~Ka&~J{QUr9+cpkvzu+~3`6 z-6fxBV}Pz(3@jxRW^0mgdM7n!WoP7^x~S+hDa?5|{S*HzIgjLVl_oJaGV_K(k{ifE z?BC#8g~#|Ch5pueDtgP@WT-FSsgmA|jtv4K)aUiE@<2wy=VovMx#t3P;sk;fNx@ zRq%tPBVI2tBpob^6ysZ2Ir64A7skSmmEEEJ71|Y%EKx+yWSAA~3;7+|ND_B}pklPh z%hMX?`V}9AnM`vFbpQg{U}z8LX$N~jK5Fc1(0o@ zg>RXj8pJ@rCk`Dd;BbbMk#Zp0&}ikVZbur>qGyN<#{n3*W1m&X!xMbQFuJlJaTUv+SFo|Pqb+SAkBL+cG@8MYUjR8@if<-n*e_dSU0PjT_bS~B0i`LBk{nkEnI@>g1OPS}C#P{& zhf$eCEBy%hu~B>wRe$kVwE#(EMIYr5WBRb=;3XmMhU+ZWib0;@tiBVIO00QrxGpC+ zwYtO4#a6#rFyj)1OKLAOXdeL44`7%jH_zU*!xZ9ztaBy85s&N4mfie7Y5vg{B<{28 z^T;%=fEU{%n^5p7X(l}@Cc$kkZCi0HifqLklF*BAh(0UI`K=zIua`mmkJ(qQ5_EF{ z{ESKU!KE9N+hTHQ7X;P%n<%2G8#o`mui57!|k(eBt+NSXrI34ez63T@v4I#9ZYKkO6L4||l*?IyB)lm4i1bF`NNLa;Vn zEoQh>Wci0uv5Fe6)*yi+*vBzZ`Mqo3;k&ngz-Y01L>vAa9TH8%7n_tD4AU#Aj+6F< zC(5U{Ug#ziyFFZv5>A9CSRQm)AXhI?fKM!@LnEG=mTIJU(Q$c7K9EpOC*MgRsZL2r z?`SUga4ybE`L)3Bvm$u#)ZR613sAbclYJlilEn7f>w|axGr9G7M!3Mk(H@$3D&Fh! zbTh5k1@G1mW-f#k@OtYU+-vP@4M`R&LZ^(Nhb7G+IW7hUt zC%npiY`%gRgE!(^_&&25GL7EM-SHd_$KdO3+8F5h(un2tF>F$E-+~TeQQ0JCUj$R zj*ktdwAh6E?EdG6U9+@7c&_(zdhJA9rMM@(pptCnne)Tu0OSL1u=Z>)`;w)SUJqUrryV!cx?& zXiIOK;#N>)pb7^?f5}sMW&^D{etRL1U7zI*N+YZ`C#F&b^ep+d&JDq5pDe}jJV+Fp z=Lt~DBV{V2ch=s!CJm*cqjx`tR*=nYidv8aI@=mHv^XZK{T)>825Fa+oF+htZ0~*7 z-)vkGOEI{QF6)Jfubb~JmJ}ny2jSH^_%wah`Z81Ul{yAfngd4@Xe_;4|5C&;%1?|( zmSc1lzwMedjrIPBgftSf;lzAWiKoBo0FNSj(=+19kz#j(zlT3xqL#$Qcbel $R- z?DJ0EN_J@N)@$Q0Lrhn=RQ+aJb#dm>2#<7N#WA??Q>-20I|k*$)%11=3J_vMv993~ zCr8)c>Vb(w>x7DJ6oDOyBqf9AepG^9(;h|?}+&Z~G#>tszCBgCC!7hO|x zBA|tqrm3I2-xj5Yh7;>E+=bGhg_Vjw^(3{;Y6>f17`1Neu-Ve4UJYX#`R^8?)Q24` zr2GT!)Rb`yYpzlFO_8jT!ZM4WOhdGapDoWNsgjK+J39lyQeBzsl(;33X4CS5wdI}t zu!k__=OiCJ=2`k~sCBzpwWyhDZP@x?P(SerGz$8BGPPycRgptgV;G6oCbieyl~VKX zW|aRx6Oe;cFrfd^Cs^F~T&dbVm;Q$KfOD{qKUH;)Fx5u?`?5IIu|GquIq}dRue{WX zt4Mw5-00yO78$6phqQj+Q-1>AZh<{y%jb1x*k7wj ziv*J%Jc~2WBo&$E6<=QJwCjviIXAj|(Avf8$g#`5yIYAwkj8$3MX@U=#pckgq<`uL z&)NI~PFWZC7lYGc+j6u}Ntb?eRSrk$$t{FIY92##z^ zv?1M=Wv#^asN}9^eCjUXKFaBA^!bYIZg&BXXPlupr8;X1gyYdBYoR}a_7)Okn+17v zmB9T*f7=TRE5)8(Q(U#^#x$A-kx>lV`#(hs6N8QF-cLsf37g*XRsvUuBySetOSI(u z(gRX6`dva0qskSi@TAn)-OsW{n`mr({1Ob_D2Q0F`W-IT=HOjQ)wY>S&E%0$#|6yVCn=vJoDrNaX(WvRVMJ=MPaZ=zP zqovs<(-E-Nk$%^ma8CD6Wl;}x>DOirZe#-SMbv`D{6F6s?w%P(8Nu5EN1*&_m@XgI zqknKM&0#-IK=~UcHKVWcz~t5oRU;D;uIbnFWryyt!X7~z&WdWq`EQ{;vMY7Pc@@Sq zhO-0Emvj)?{1#K)ZT{jEy1~qb%@Fq3$;`n_Th1LZ{xFl{c0NGolk*MT!qd+3)93LL z*kW7*i>8mG$(Esp_QS1=s-mF4$|TNFDE#J_c6a};6*jK?kOS)`u4e6_Ey(twmg3`a zu?rcz@rgCxlpF_eE*+xY_evTbfwf`S(i;RU>x~R?wMI&G@gg6dX`Z1l47+_&pNO)Gn6{WTb}s@1{Kb2VqWS2t5Q ze?f13*HWl6F>_y=YLtYkb&uLIu!80jMC$k8to=y#{Y~u}WCoz{+b#l1%KU7$u9qeR zwB*3p4IEr|^FCTjkxi~VB-5>?r8gknLc!VJ`;EOX#RN8F?p)J+m%94BJJU_13USU= zP_bF*V+C%)FI!KRGD>Suh6z*sl8TBqM)bO&`Vi>ibMNh&^V}PxieKDF%s*fu>bxkS z4cZAJyL%>k?tKp)dp4l2A3%H8j59`}5CJPzi*KhtUI>IX){pRGuWf{;1HdBTth>vQ zH3J2_7I9J=%_ucNx>c!GXo%Xb@R?Y8^{kiwr#e~Y|g(_iG^SKxKp+U9*>Kpjn`(3f^ef427Hb|>lM~-V6eC(_Lm*gpM zYf*;+syhl?yv)D7r9XozW5M$6$3(;)AADY114=x?^f4D{)l>h(3DrziGt)7bywk~8alFXr~|#p%An`n&-nV>pj4 zj7C-c25uIB$*ywy>Gmq>Krx5kUUoSUi4n`VCjSfYeG0|+c&iO^{V*c)+mWCyhF0;ycAxUm(9R(z|mAh zbGQJ^p+|&{MNR(c@BD$!+sjna^EDKa4M2rEGRmkV!Y6AqQNiEa4*67VN&5uI(y334 z{f{IkqWVBTnRZYLk$D*Y*>w|7;J(C+<