From b15923b501445418856ab29bafb7b8ad4aca5ede Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 9 Feb 2026 12:47:21 +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 | 225 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 928 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9020-py3-none-any.whl | Bin 0 -> 10548 bytes dist/amr-3.0.1.9020.tar.gz | Bin 0 -> 10406 bytes setup.py | 27 + 12 files changed, 1668 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.9020-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9020.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..e1e5ce9b9 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9020 +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..695027456 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,225 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import 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..83384be5d --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,928 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def 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.9020-py3-none-any.whl b/dist/amr-3.0.1.9020-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..454d815947d30f1254f81eb872e5fb17c1a8733d GIT binary patch literal 10548 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 D5BO9r literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9020.tar.gz b/dist/amr-3.0.1.9020.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..05f0b8abf46320590f823f9c4fc2dd2554a5f866 GIT binary patch literal 10406 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 V{omppsu3L7(3sa7VH*+Qe*r61%$WcH literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..78d3e0da6 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9020', + 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', +)