From 6ed143808ab976c212f6be377dee500d01cebb04 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 17 Jul 2025 20:59:11 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 +++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 219 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 904 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.0.9012-py3-none-any.whl | Bin 0 -> 10440 bytes dist/amr-3.0.0.9012.tar.gz | Bin 0 -> 10301 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.9012-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9012.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..49298c37a --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9012 +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.9012-py3-none-any.whl b/dist/amr-3.0.0.9012-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..cd73adc80cc7c9bdf5bc016f861225599daa2617 GIT binary patch literal 10440 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 IwqarZ3o2nnQ2+n{ literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..c96e99711 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9012', + 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', +)