From f86877aed0156dafbd03c4dd0b5d8cf2deeb7ad0 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 6 Mar 2026 11:43:44 +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 | 226 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 932 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9026-py3-none-any.whl | Bin 0 -> 10557 bytes dist/amr-3.0.1.9026.tar.gz | Bin 0 -> 10433 bytes setup.py | 27 + 12 files changed, 1673 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.1.9026-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9026.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..83bff18f9 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9026 +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..abf581284 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,226 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import peptides +from .functions import phenicols +from .functions import phosphonics +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import spiropyrimidinetriones +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 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 interpretive_rules +from .functions import eucast_rules +from .functions import clsi_rules +from .functions import eucast_dosage +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..0c11968a2 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,932 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def peptides(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.peptides(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 phosphonics(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.phosphonics(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 spiropyrimidinetriones(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.spiropyrimidinetriones(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 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 interpretive_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.interpretive_rules(x, *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 clsi_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clsi_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 italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.translate_AMR(x, *args, **kwargs) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.1.9026-py3-none-any.whl b/dist/amr-3.0.1.9026-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..cf98423c3d5ab7d4e81bd9f473a9c7862064ac04 GIT binary patch literal 10557 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 G!u&6E39%&r literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..3e2193bf3 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9026', + 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', +)