From d449de877c9b06b3f1f2014365788fbe4cc47ea5 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 20 Apr 2025 15:52:16 +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.9249-py3-none-any.whl | Bin 0 -> 10189 bytes dist/amr-2.1.1.9249.tar.gz | Bin 0 -> 10057 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.9249-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9249.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..b31ddca2b --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9249 +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.9249-py3-none-any.whl b/dist/amr-2.1.1.9249-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..636afc84d7ec2292415375e11affeedc48b50542 GIT binary patch literal 10189 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9249.tar.gz b/dist/amr-2.1.1.9249.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..f2a1a6e14b2acb8f5aad79ab13d912be1eca42d9 GIT binary patch literal 10057 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..871234c3b --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9249', + 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', +)