From 1a6836db4be593a2083614a4aeb20c55667a62b7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 22 Dec 2025 18:05:27 +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 | 221 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 912 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9008-py3-none-any.whl | Bin 0 -> 10462 bytes dist/amr-3.0.1.9008.tar.gz | Bin 0 -> 10323 bytes setup.py | 27 + 12 files changed, 1648 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.1.9008-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9008.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..802acff91 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9008 +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..775bbd109 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,221 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import 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..9b8203a42 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,912 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def 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.1.9008-py3-none-any.whl b/dist/amr-3.0.1.9008-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..8c70be2278a113ceac4137730b6922162ab36791 GIT binary patch literal 10462 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 XbtTw;Nf`qE&wcYpiF5xFG{k=aMAtX+ literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9008.tar.gz b/dist/amr-3.0.1.9008.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..9b1fa2f59a563570d361e17c5439550f61d1abc4 GIT binary patch literal 10323 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 Z#u|8{@PC)!zGW~(4>3Oi#5N?v{{S9daWen_ literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..699f8707c --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9008', + packages=find_packages(), + install_requires=[ + 'rpy2', + 'numpy', + 'pandas', + ], + author='Matthijs Berends', + author_email='m.s.berends@umcg.nl', + description='A Python wrapper for the AMR R package', + long_description=open('README.md').read(), + long_description_content_type='text/markdown', + url='https://github.com/msberends/AMR', + project_urls={ + 'Bug Tracker': 'https://github.com/msberends/AMR/issues', + }, + license='GPL 2', + classifiers=[ + 'Programming Language :: Python :: 3', + 'Operating System :: OS Independent', + ], + python_requires='>=3.6', +)