From 403caa1edc79ddcf3dbfbeb707cb1504a6036f14 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 29 Apr 2025 14:53:14 +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.9263-py3-none-any.whl | Bin 0 -> 10185 bytes dist/amr-2.1.1.9263.tar.gz | Bin 0 -> 10033 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.9263-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9263.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..07a010ebd --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9263 +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.9263-py3-none-any.whl b/dist/amr-2.1.1.9263-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..990d4c610157abc09395e98d1892b50b1845a903 GIT binary patch literal 10185 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

&Wl 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9263.tar.gz b/dist/amr-2.1.1.9263.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..62d452ccf8db75f891bd12da49d359038fb0133c GIT binary patch literal 10033 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 JY6}|bzW@nt#)SX? literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..b121c48d3 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9263', + 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', +)