From c3e1332f439869a580e90f53ac2039254c6c1043 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 1 Sep 2025 14:59:34 +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.9019-py3-none-any.whl | Bin 0 -> 10439 bytes dist/amr-3.0.0.9019.tar.gz | Bin 0 -> 10287 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.9019-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9019.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..e07e115e5 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9019 +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.9019-py3-none-any.whl b/dist/amr-3.0.0.9019-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..19b008adfda9042f368012488a2c13f989110329 GIT binary patch literal 10439 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9019.tar.gz b/dist/amr-3.0.0.9019.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c5a9acc78c1ac463752bb3250fde19a1f5a7b80c GIT binary patch literal 10287 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..adf83e685 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9019', + 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', +)