From 2b484d64bddfc904928e60e51d94078b1f9f80ef Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 30 Mar 2026 08:08:30 +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 | 228 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 940 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9041-py3-none-any.whl | Bin 0 -> 10603 bytes dist/amr-3.0.1.9041.tar.gz | Bin 0 -> 10466 bytes setup.py | 27 + 12 files changed, 1683 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.9041-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9041.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..89d4e79a0 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9041 +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..42012c791 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,228 @@ +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 amr_course +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 ionophores +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..4f28a517f --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,940 @@ +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 amr_course(github_repo, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_course(github_repo, *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 ionophores(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.ionophores(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.9041-py3-none-any.whl b/dist/amr-3.0.1.9041-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..67ce038ff295289065d5efedce7ac3634ffccd61 GIT binary patch literal 10603 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

=2+^OPcgfq99Rlhv?LB zxk$c~{-8vsDKuCnxI~I`H41VO_F{F@}{SGu`}@rVBP3=YPb$@zv(NC0CyF(G+;+c72#kH$lVjp#2~&%gcSPYa0wKDxi%^7j-esF6s8h5Hdv8xX&ZZCUwP)z4@ksSa%r#c zKSeKj&lwihH;v}2Q_w~cB@#d(F#2w{q-m40fN!vPs|qPDSG#- zml-E^zd~u|D>SoWQ6Mx^q6a1RPZvLYzn?c+YD1l?rX!dPQ=2ZC^ejgx9y} znMpg>%V+-lEsK)V<7G3e318_^v4+g_iEI)(d;W__slrk5gj#=vD-6<}s7u)xtLH(0 z*`GivG3kX(DSTfD^LVc^owMrbo;yo|iTiRr^o;sXv8DJS(r)}zfQ+sxJ5N)^6zS7O zy&Hv#iKC_h-2Ebi?$fHbzmLr}&`(#@ZgHA3uIZE_?45S90`jAWF$DH4 zWz4{2|8h00(jv?r;BcXXh9{=_!Xw^77|o3N+tzsNM-r25E~#2>UUC?^!u}`dUj?s! zMSN6pN0EAeB0b$dgYcgsK20fcaXH9d7Px+90OX8*>C6fut8_brVV)Zu1$hH}E~QZs z@wlkN_G2?aS$*HS@po@IaQ^%o)T0c%f?Q(_yzL_z1nbWEVfur`gH3`zrB1}_yy7?3 z+-1=Pbd@{O7x4eKi-`IG73z;Y5Pt^cKiTEx=wxVT?qP1n=;r0-dWWzF2J+ubP%omW zrl5b?xxhd`i2jL5MO;)-Ma*|bHnD&i1Z1YmGQtfNqOSle@98uYj6m!{9*)8&InERe zRY6cy)m+{2E8`93G^~eX^6yYtnWhe~y+q^wZ#@g`!W&x>9V7a?mmj#bK~K0-TcjQ~ zp96}mQPE*N(Ybg+ZqbxehE&sLl-EO!T{qEfqdWl(=Ebxx@(ruIKA@>!h1Y8Lwn zlSzMhUrD->8^RMpUK^UeGrsix7@u58xJ4~EYt@N%c#f(H6U9yanwD;5errqJ{(5K8 zBDE0^<0oP6Q;Kn}T|6q>?Q}j5@S9H#J?BFhwl|`-qI{)StQlS(k>l_PiF1ki-jDNk zY;ru=zX=vFN~9zU3Wg5;|8BAS^O64NC<^@7^tXn)zk~nY!trk?2uM-j=AW*;e}Vs_ zq2ur1zn6Re0$;)Y8~mTe-~UAa-?Altp)WE2KXNC3r~A7U|DxL_{|CDN5$4~y{w|-t xxI8KTf$P7-^mop`3+exGHU{?o6X(BWr6ddaFFAui|2gmesL}XOh6x1Ze*s@Jd4>Q0 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9041.tar.gz b/dist/amr-3.0.1.9041.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..65dd5f9bc6ea9945fd76774f0e864c828359442c GIT binary patch literal 10466 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 S(roq~20xzaF9^2_5BEPm?6DvK literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..7feb3227f --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9041', + 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', +)