From 48a002d8b502a38bfdd7c31b3e702fc98e931e50 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 27 Apr 2025 07:59:06 +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.9257-py3-none-any.whl | Bin 0 -> 10188 bytes dist/amr-2.1.1.9257.tar.gz | Bin 0 -> 10026 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.9257-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9257.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..d430e625a --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9257 +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.9257-py3-none-any.whl b/dist/amr-2.1.1.9257-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..bacc48cb61d64cc157d7cdc3085a739536b26342 GIT binary patch literal 10188 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..38d903162 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9257', + 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', +)