From cc38240e09a22c23389781a0b95f7d948bf55649 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 30 Apr 2025 15:35:20 +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.9266-py3-none-any.whl | Bin 0 -> 10186 bytes dist/amr-2.1.1.9266.tar.gz | Bin 0 -> 10035 bytes setup.py | 27 ++ 12 files changed, 1393 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-2.1.1.9266-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9266.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..b4eeec344 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9266 +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.9266-py3-none-any.whl b/dist/amr-2.1.1.9266-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..2bcd722ff47cd18fffcba9284d6455f74462682f GIT binary patch literal 10186 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9266.tar.gz b/dist/amr-2.1.1.9266.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..7bab06315dc8879d54614278316684d0ac886b41 GIT binary patch literal 10035 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..a0c6a5729 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9266', + 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', +)