From 1d6af33921d35ac10b204a47169a792452314bc1 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 18 Jul 2025 13:59:32 +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.9014-py3-none-any.whl | Bin 0 -> 10441 bytes dist/amr-3.0.0.9014.tar.gz | Bin 0 -> 10304 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.9014-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9014.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..b829563d5 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9014 +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.9014-py3-none-any.whl b/dist/amr-3.0.0.9014-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..ed69519314aba38f9176aad0704f9e125eb531ec GIT binary patch literal 10441 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9014.tar.gz b/dist/amr-3.0.0.9014.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..641d10ae7c694eecc9fcdb46467d85c56da590b7 GIT binary patch literal 10304 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..5bc1cd753 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9014', + 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', +)