From 327f5e26ce5adffd93135c30be2a1265ebd6063c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 20 Apr 2025 13:28:56 +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 | 213 +++++++++ AMR/datasets.py | 77 ++++ AMR/functions.py | 665 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9248-py3-none-any.whl | Bin 0 -> 10186 bytes dist/amr-2.1.1.9248.tar.gz | Bin 0 -> 10029 bytes setup.py | 27 ++ 12 files changed, 1393 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-2.1.1.9248-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9248.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..ea92f5b1a --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9248 +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..0dd6e1f18 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,213 @@ +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 antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import eucast_rules +from .functions import eucast_dosage +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import custom_mdro_guideline +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..8b1dbb67d --- /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 import 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 = metadata.version('AMR') +# except metadata.PackageNotFoundError: +# python_amr_version = '' +# +# # 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 +pandas2ri.activate() + +# example_isolates +example_isolates = pandas2ri.rpy2py(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 = pandas2ri.rpy2py(robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]')) +antimicrobials = pandas2ri.rpy2py(robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]')) +clinical_breakpoints = pandas2ri.rpy2py(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..e0146c94a --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,665 @@ +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects import pandas2ri +import pandas as pd +import numpy as np + +# Activate automatic conversion between R data frames and pandas data frames +pandas2ri.activate() + +# 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): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + elif isinstance(r_output, DataFrame): + return pandas2ri.rpy2py(r_output) # Return as pandas DataFrame + + # 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 ab_class(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_class(*args, **kwargs)) +def ab_selector(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_selector(*args, **kwargs)) +def ab_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_from_text(text, *args, **kwargs)) +def ab_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_name(x, *args, **kwargs)) +def ab_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_cid(x, *args, **kwargs)) +def ab_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_synonyms(x, *args, **kwargs)) +def ab_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_tradenames(x, *args, **kwargs)) +def ab_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_group(x, *args, **kwargs)) +def ab_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_atc(x, *args, **kwargs)) +def ab_atc_group1(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_atc_group1(x, *args, **kwargs)) +def ab_atc_group2(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_atc_group2(x, *args, **kwargs)) +def ab_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_loinc(x, *args, **kwargs)) +def ab_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_ddd(x, *args, **kwargs)) +def ab_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_ddd_units(x, *args, **kwargs)) +def ab_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_info(x, *args, **kwargs)) +def ab_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_url(x, *args, **kwargs)) +def ab_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_property(x, *args, **kwargs)) +def add_custom_antimicrobials(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.add_custom_antimicrobials(x)) +def clear_custom_antimicrobials(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.clear_custom_antimicrobials(*args, **kwargs)) +def add_custom_microorganisms(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.add_custom_microorganisms(x)) +def clear_custom_microorganisms(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.clear_custom_microorganisms(*args, **kwargs)) +def age(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.age(x, *args, **kwargs)) +def age_groups(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.age_groups(x, *args, **kwargs)) +def antibiogram(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.antibiogram(x, *args, **kwargs)) +def wisca(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.wisca(x, *args, **kwargs)) +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs)) +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs)) +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs)) +def antifungals(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.antifungals(only_sir_columns = False, *args, **kwargs)) +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs)) +def betalactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.betalactams(only_sir_columns = False, *args, **kwargs)) +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs)) +def carbapenems(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.carbapenems(only_sir_columns = False, *args, **kwargs)) +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs)) +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs)) +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs)) +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs)) +def lincosamides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.lincosamides(only_sir_columns = False, *args, **kwargs)) +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs)) +def macrolides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.macrolides(only_sir_columns = False, *args, **kwargs)) +def monobactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.monobactams(only_sir_columns = False, *args, **kwargs)) +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs)) +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs)) +def penicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.penicillins(only_sir_columns = False, *args, **kwargs)) +def phenicols(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.phenicols(only_sir_columns = False, *args, **kwargs)) +def polymyxins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.polymyxins(only_sir_columns = False, *args, **kwargs)) +def quinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.quinolones(only_sir_columns = False, *args, **kwargs)) +def rifamycins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.rifamycins(only_sir_columns = False, *args, **kwargs)) +def streptogramins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.streptogramins(only_sir_columns = False, *args, **kwargs)) +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs)) +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs)) +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs)) +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs)) +def amr_class(amr_class, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.amr_class(amr_class, *args, **kwargs)) +def amr_selector(filter, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.amr_selector(filter, *args, **kwargs)) +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs)) +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs)) +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs)) +def as_ab(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_ab(x, *args, **kwargs)) +def is_ab(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_ab(x)) +def ab_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_reset_session(*args, **kwargs)) +def as_av(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_av(x, *args, **kwargs)) +def is_av(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_av(x)) +def as_disk(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_disk(x, *args, **kwargs)) +def is_disk(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_disk(x)) +def as_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_mic(x, *args, **kwargs)) +def is_mic(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_mic(x)) +def rescale_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.rescale_mic(x, *args, **kwargs)) +def mic_p50(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mic_p50(x, *args, **kwargs)) +def mic_p90(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mic_p90(x, *args, **kwargs)) +def as_mo(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_mo(x, *args, **kwargs)) +def is_mo(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_mo(x)) +def mo_uncertainties(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_uncertainties(*args, **kwargs)) +def mo_renamed(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_renamed(*args, **kwargs)) +def mo_failures(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_failures(*args, **kwargs)) +def mo_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_reset_session(*args, **kwargs)) +def mo_cleaning_regex(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_cleaning_regex(*args, **kwargs)) +def as_sir(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_sir(x, *args, **kwargs)) +def is_sir(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_sir(x)) +def is_sir_eligible(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_sir_eligible(x, *args, **kwargs)) +def sir_interpretation_history(clean): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_interpretation_history(clean)) +def atc_online_property(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_property(atc_code, *args, **kwargs)) +def atc_online_groups(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_groups(atc_code, *args, **kwargs)) +def atc_online_ddd(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_ddd(atc_code, *args, **kwargs)) +def atc_online_ddd_units(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_ddd_units(atc_code, *args, **kwargs)) +def av_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_from_text(text, *args, **kwargs)) +def av_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_name(x, *args, **kwargs)) +def av_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_cid(x, *args, **kwargs)) +def av_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_synonyms(x, *args, **kwargs)) +def av_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_tradenames(x, *args, **kwargs)) +def av_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_group(x, *args, **kwargs)) +def av_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_atc(x, *args, **kwargs)) +def av_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_loinc(x, *args, **kwargs)) +def av_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_ddd(x, *args, **kwargs)) +def av_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_ddd_units(x, *args, **kwargs)) +def av_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_info(x, *args, **kwargs)) +def av_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_url(x, *args, **kwargs)) +def av_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_property(x, *args, **kwargs)) +def availability(tbl, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.availability(tbl, *args, **kwargs)) +def bug_drug_combinations(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.bug_drug_combinations(x, *args, **kwargs)) +def count_resistant(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_resistant(*args, **kwargs)) +def count_susceptible(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_susceptible(*args, **kwargs)) +def count_S(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_S(*args, **kwargs)) +def count_SI(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_SI(*args, **kwargs)) +def count_I(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_I(*args, **kwargs)) +def count_IR(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_IR(*args, **kwargs)) +def count_R(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_R(*args, **kwargs)) +def count_all(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_all(*args, **kwargs)) +def n_sir(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.n_sir(*args, **kwargs)) +def count_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_df(data, *args, **kwargs)) +def custom_eucast_rules(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.custom_eucast_rules(*args, **kwargs)) +def eucast_rules(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.eucast_rules(x, *args, **kwargs)) +def eucast_dosage(ab, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.eucast_dosage(ab, *args, **kwargs)) +def export_ncbi_biosample(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.export_ncbi_biosample(x, *args, **kwargs)) +def first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.first_isolate(x = None, *args, **kwargs)) +def filter_first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.filter_first_isolate(x = None, *args, **kwargs)) +def g_test(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.g_test(x, *args, **kwargs)) +def is_new_episode(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_new_episode(x, *args, **kwargs)) +def ggplot_pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ggplot_pca(x, *args, **kwargs)) +def ggplot_sir(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ggplot_sir(data, *args, **kwargs)) +def geom_sir(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.geom_sir(position = None, *args, **kwargs)) +def guess_ab_col(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.guess_ab_col(x = None, *args, **kwargs)) +def italicise_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.italicise_taxonomy(string, *args, **kwargs)) +def italicize_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.italicize_taxonomy(string, *args, **kwargs)) +def inner_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.inner_join_microorganisms(x, *args, **kwargs)) +def left_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.left_join_microorganisms(x, *args, **kwargs)) +def right_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.right_join_microorganisms(x, *args, **kwargs)) +def full_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.full_join_microorganisms(x, *args, **kwargs)) +def semi_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.semi_join_microorganisms(x, *args, **kwargs)) +def anti_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.anti_join_microorganisms(x, *args, **kwargs)) +def key_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.key_antimicrobials(x = None, *args, **kwargs)) +def all_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.all_antimicrobials(x = None, *args, **kwargs)) +def kurtosis(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.kurtosis(x, *args, **kwargs)) +def like(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.like(x, *args, **kwargs)) +def mdro(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mdro(x = None, *args, **kwargs)) +def custom_mdro_guideline(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.custom_mdro_guideline(*args, **kwargs)) +def brmo(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.brmo(x = None, *args, **kwargs)) +def mrgn(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mrgn(x = None, *args, **kwargs)) +def mdr_tb(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mdr_tb(x = None, *args, **kwargs)) +def mdr_cmi2012(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mdr_cmi2012(x = None, *args, **kwargs)) +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs)) +def mean_amr_distance(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mean_amr_distance(x, *args, **kwargs)) +def amr_distance_from_row(amr_distance, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.amr_distance_from_row(amr_distance, *args, **kwargs)) +def mo_matching_score(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_matching_score(x, *args, **kwargs)) +def mo_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_name(x, *args, **kwargs)) +def mo_fullname(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_fullname(x, *args, **kwargs)) +def mo_shortname(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_shortname(x, *args, **kwargs)) +def mo_subspecies(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_subspecies(x, *args, **kwargs)) +def mo_species(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_species(x, *args, **kwargs)) +def mo_genus(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_genus(x, *args, **kwargs)) +def mo_family(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_family(x, *args, **kwargs)) +def mo_order(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_order(x, *args, **kwargs)) +def mo_class(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_class(x, *args, **kwargs)) +def mo_phylum(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_phylum(x, *args, **kwargs)) +def mo_kingdom(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_kingdom(x, *args, **kwargs)) +def mo_domain(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_domain(x, *args, **kwargs)) +def mo_type(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_type(x, *args, **kwargs)) +def mo_status(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_status(x, *args, **kwargs)) +def mo_pathogenicity(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_pathogenicity(x, *args, **kwargs)) +def mo_gramstain(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_gramstain(x, *args, **kwargs)) +def mo_is_gram_negative(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_gram_negative(x, *args, **kwargs)) +def mo_is_gram_positive(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_gram_positive(x, *args, **kwargs)) +def mo_is_yeast(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_yeast(x, *args, **kwargs)) +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs)) +def mo_oxygen_tolerance(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_oxygen_tolerance(x, *args, **kwargs)) +def mo_is_anaerobic(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_anaerobic(x, *args, **kwargs)) +def mo_snomed(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_snomed(x, *args, **kwargs)) +def mo_ref(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_ref(x, *args, **kwargs)) +def mo_authors(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_authors(x, *args, **kwargs)) +def mo_year(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_year(x, *args, **kwargs)) +def mo_lpsn(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_lpsn(x, *args, **kwargs)) +def mo_mycobank(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_mycobank(x, *args, **kwargs)) +def mo_gbif(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_gbif(x, *args, **kwargs)) +def mo_rank(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_rank(x, *args, **kwargs)) +def mo_taxonomy(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_taxonomy(x, *args, **kwargs)) +def mo_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_synonyms(x, *args, **kwargs)) +def mo_current(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_current(x, *args, **kwargs)) +def mo_group_members(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_group_members(x, *args, **kwargs)) +def mo_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_info(x, *args, **kwargs)) +def mo_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_url(x, *args, **kwargs)) +def mo_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_property(x, *args, **kwargs)) +def pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.pca(x, *args, **kwargs)) +def theme_sir(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.theme_sir(*args, **kwargs)) +def labels_sir_count(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.labels_sir_count(position = None, *args, **kwargs)) +def resistance(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.resistance(*args, **kwargs)) +def susceptibility(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.susceptibility(*args, **kwargs)) +def sir_confidence_interval(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_confidence_interval(*args, **kwargs)) +def proportion_R(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_R(*args, **kwargs)) +def proportion_IR(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_IR(*args, **kwargs)) +def proportion_I(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_I(*args, **kwargs)) +def proportion_SI(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_SI(*args, **kwargs)) +def proportion_S(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_S(*args, **kwargs)) +def proportion_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_df(data, *args, **kwargs)) +def sir_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_df(data, *args, **kwargs)) +def random_mic(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.random_mic(size = None, *args, **kwargs)) +def random_disk(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.random_disk(size = None, *args, **kwargs)) +def random_sir(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.random_sir(size = None, *args, **kwargs)) +def resistance_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.resistance_predict(x, *args, **kwargs)) +def sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_predict(x, *args, **kwargs)) +def ggplot_sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ggplot_sir_predict(x, *args, **kwargs)) +def skewness(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.skewness(x, *args, **kwargs)) +def top_n_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.top_n_microorganisms(x, *args, **kwargs)) +def reset_AMR_locale(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.reset_AMR_locale(*args, **kwargs)) +def translate_AMR(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(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-2.1.1.9248-py3-none-any.whl b/dist/amr-2.1.1.9248-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..538d45ac082816b150a8e0ec8e148e628d9e04e6 GIT binary patch literal 10186 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9248.tar.gz b/dist/amr-2.1.1.9248.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..e4bd449fff671507b4e91bc785ab9b1804c72cd5 GIT binary patch literal 10029 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..664bbbcc9 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9248', + 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', +)