From ea39e6d434ebf845f9a4f652d4e4e566ef25cfd8 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 13 Apr 2025 08:03:27 +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.9237-py3-none-any.whl | Bin 0 -> 10188 bytes dist/amr-2.1.1.9237.tar.gz | Bin 0 -> 10035 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.9237-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9237.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..8e3bb14a8 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9237 +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.9237-py3-none-any.whl b/dist/amr-2.1.1.9237-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..ebdc6379710c77eb97ecfffa63075d7ed636538c GIT binary patch literal 10188 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�u|eQK8%`#FAfeN9aczFRsfaN52Iau;H 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9237.tar.gz b/dist/amr-2.1.1.9237.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..49a2e0a21cf9f310730b3d38b01783e4e6532522 GIT binary patch literal 10035 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..3e99eb679 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9237', + 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', +)