From 17492edb9693737ecc29184d65eb5ebbd775d7eb Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 1 May 2025 09:50:44 +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 | 82 ++++ AMR/functions.py | 665 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9267-py3-none-any.whl | Bin 0 -> 10201 bytes dist/amr-2.1.1.9267.tar.gz | Bin 0 -> 10052 bytes setup.py | 27 ++ 12 files changed, 1398 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.9267-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9267.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..da2673892 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9267 +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..d31c57747 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,82 @@ +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 = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# 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]) + +print(python_amr_version, flush=True) +print(r_amr_version, flush=True) + +print(r_amr_version != python_amr_version, flush=True) + +# # 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..0c707e39d --- /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): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_class(*args, **kwargs)) +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_selector(*args, **kwargs)) +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_from_text(text, *args, **kwargs)) +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_name(x, *args, **kwargs)) +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_cid(x, *args, **kwargs)) +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_synonyms(x, *args, **kwargs)) +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_tradenames(x, *args, **kwargs)) +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_group(x, *args, **kwargs)) +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_atc(x, *args, **kwargs)) +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_atc_group1(x, *args, **kwargs)) +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_atc_group2(x, *args, **kwargs)) +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_loinc(x, *args, **kwargs)) +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_ddd(x, *args, **kwargs)) +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_ddd_units(x, *args, **kwargs)) +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_info(x, *args, **kwargs)) +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_url(x, *args, **kwargs)) +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_property(x, *args, **kwargs)) +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.add_custom_antimicrobials(x)) +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.clear_custom_antimicrobials(*args, **kwargs)) +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.add_custom_microorganisms(x)) +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.clear_custom_microorganisms(*args, **kwargs)) +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.age(x, *args, **kwargs)) +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.age_groups(x, *args, **kwargs)) +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antibiogram(x, *args, **kwargs)) +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.wisca(x, *args, **kwargs)) +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs)) +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs)) +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs)) +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antifungals(only_sir_columns = False, *args, **kwargs)) +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs)) +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.betalactams(only_sir_columns = False, *args, **kwargs)) +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs)) +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.carbapenems(only_sir_columns = False, *args, **kwargs)) +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs)) +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs)) +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs)) +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs)) +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.lincosamides(only_sir_columns = False, *args, **kwargs)) +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs)) +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.macrolides(only_sir_columns = False, *args, **kwargs)) +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.monobactams(only_sir_columns = False, *args, **kwargs)) +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs)) +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs)) +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.penicillins(only_sir_columns = False, *args, **kwargs)) +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.phenicols(only_sir_columns = False, *args, **kwargs)) +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.polymyxins(only_sir_columns = False, *args, **kwargs)) +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.quinolones(only_sir_columns = False, *args, **kwargs)) +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.rifamycins(only_sir_columns = False, *args, **kwargs)) +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.streptogramins(only_sir_columns = False, *args, **kwargs)) +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs)) +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs)) +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs)) +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs)) +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_class(amr_class, *args, **kwargs)) +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_selector(filter, *args, **kwargs)) +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs)) +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs)) +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs)) +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_ab(x, *args, **kwargs)) +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_ab(x)) +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_reset_session(*args, **kwargs)) +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_av(x, *args, **kwargs)) +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_av(x)) +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_disk(x, *args, **kwargs)) +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_disk(x)) +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_mic(x, *args, **kwargs)) +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_mic(x)) +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.rescale_mic(x, *args, **kwargs)) +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mic_p50(x, *args, **kwargs)) +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mic_p90(x, *args, **kwargs)) +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_mo(x, *args, **kwargs)) +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_mo(x)) +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_uncertainties(*args, **kwargs)) +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_renamed(*args, **kwargs)) +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_failures(*args, **kwargs)) +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_reset_session(*args, **kwargs)) +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_cleaning_regex(*args, **kwargs)) +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_sir(x, *args, **kwargs)) +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_sir(x)) +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_sir_eligible(x, *args, **kwargs)) +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_interpretation_history(clean)) +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_property(atc_code, *args, **kwargs)) +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_groups(atc_code, *args, **kwargs)) +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_ddd(atc_code, *args, **kwargs)) +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_ddd_units(atc_code, *args, **kwargs)) +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_from_text(text, *args, **kwargs)) +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_name(x, *args, **kwargs)) +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_cid(x, *args, **kwargs)) +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_synonyms(x, *args, **kwargs)) +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_tradenames(x, *args, **kwargs)) +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_group(x, *args, **kwargs)) +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_atc(x, *args, **kwargs)) +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_loinc(x, *args, **kwargs)) +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_ddd(x, *args, **kwargs)) +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_ddd_units(x, *args, **kwargs)) +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_info(x, *args, **kwargs)) +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_url(x, *args, **kwargs)) +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_property(x, *args, **kwargs)) +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.availability(tbl, *args, **kwargs)) +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.bug_drug_combinations(x, *args, **kwargs)) +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_resistant(*args, **kwargs)) +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_susceptible(*args, **kwargs)) +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_S(*args, **kwargs)) +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_SI(*args, **kwargs)) +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_I(*args, **kwargs)) +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_IR(*args, **kwargs)) +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_R(*args, **kwargs)) +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_all(*args, **kwargs)) +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.n_sir(*args, **kwargs)) +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_df(data, *args, **kwargs)) +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.custom_eucast_rules(*args, **kwargs)) +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_rules(x, *args, **kwargs)) +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_dosage(ab, *args, **kwargs)) +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.export_ncbi_biosample(x, *args, **kwargs)) +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.first_isolate(x = None, *args, **kwargs)) +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.filter_first_isolate(x = None, *args, **kwargs)) +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.g_test(x, *args, **kwargs)) +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_new_episode(x, *args, **kwargs)) +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_pca(x, *args, **kwargs)) +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_sir(data, *args, **kwargs)) +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.geom_sir(position = None, *args, **kwargs)) +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.guess_ab_col(x = None, *args, **kwargs)) +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.italicise_taxonomy(string, *args, **kwargs)) +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.italicize_taxonomy(string, *args, **kwargs)) +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.inner_join_microorganisms(x, *args, **kwargs)) +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.left_join_microorganisms(x, *args, **kwargs)) +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.right_join_microorganisms(x, *args, **kwargs)) +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.full_join_microorganisms(x, *args, **kwargs)) +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.semi_join_microorganisms(x, *args, **kwargs)) +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.anti_join_microorganisms(x, *args, **kwargs)) +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.key_antimicrobials(x = None, *args, **kwargs)) +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.all_antimicrobials(x = None, *args, **kwargs)) +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.kurtosis(x, *args, **kwargs)) +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.like(x, *args, **kwargs)) +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdro(x = None, *args, **kwargs)) +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.custom_mdro_guideline(*args, **kwargs)) +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.brmo(x = None, *args, **kwargs)) +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mrgn(x = None, *args, **kwargs)) +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdr_tb(x = None, *args, **kwargs)) +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdr_cmi2012(x = None, *args, **kwargs)) +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs)) +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mean_amr_distance(x, *args, **kwargs)) +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_distance_from_row(amr_distance, *args, **kwargs)) +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_matching_score(x, *args, **kwargs)) +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_name(x, *args, **kwargs)) +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_fullname(x, *args, **kwargs)) +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_shortname(x, *args, **kwargs)) +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_subspecies(x, *args, **kwargs)) +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_species(x, *args, **kwargs)) +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_genus(x, *args, **kwargs)) +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_family(x, *args, **kwargs)) +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_order(x, *args, **kwargs)) +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_class(x, *args, **kwargs)) +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_phylum(x, *args, **kwargs)) +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_kingdom(x, *args, **kwargs)) +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_domain(x, *args, **kwargs)) +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_type(x, *args, **kwargs)) +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_status(x, *args, **kwargs)) +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_pathogenicity(x, *args, **kwargs)) +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_gramstain(x, *args, **kwargs)) +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_gram_negative(x, *args, **kwargs)) +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_gram_positive(x, *args, **kwargs)) +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_yeast(x, *args, **kwargs)) +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs)) +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_oxygen_tolerance(x, *args, **kwargs)) +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_anaerobic(x, *args, **kwargs)) +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_snomed(x, *args, **kwargs)) +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_ref(x, *args, **kwargs)) +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_authors(x, *args, **kwargs)) +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_year(x, *args, **kwargs)) +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_lpsn(x, *args, **kwargs)) +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_mycobank(x, *args, **kwargs)) +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_gbif(x, *args, **kwargs)) +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_rank(x, *args, **kwargs)) +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_taxonomy(x, *args, **kwargs)) +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_synonyms(x, *args, **kwargs)) +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_current(x, *args, **kwargs)) +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_group_members(x, *args, **kwargs)) +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_info(x, *args, **kwargs)) +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_url(x, *args, **kwargs)) +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_property(x, *args, **kwargs)) +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.pca(x, *args, **kwargs)) +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.theme_sir(*args, **kwargs)) +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.labels_sir_count(position = None, *args, **kwargs)) +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.resistance(*args, **kwargs)) +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.susceptibility(*args, **kwargs)) +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_confidence_interval(*args, **kwargs)) +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_R(*args, **kwargs)) +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_IR(*args, **kwargs)) +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_I(*args, **kwargs)) +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_SI(*args, **kwargs)) +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_S(*args, **kwargs)) +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_df(data, *args, **kwargs)) +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_df(data, *args, **kwargs)) +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.random_mic(size = None, *args, **kwargs)) +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.random_disk(size = None, *args, **kwargs)) +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.random_sir(size = None, *args, **kwargs)) +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.resistance_predict(x, *args, **kwargs)) +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_predict(x, *args, **kwargs)) +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_sir_predict(x, *args, **kwargs)) +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.skewness(x, *args, **kwargs)) +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.top_n_microorganisms(x, *args, **kwargs)) +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.reset_AMR_locale(*args, **kwargs)) +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + 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.9267-py3-none-any.whl b/dist/amr-2.1.1.9267-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..c8ac4cbbedb7a466d73468aa6479f34f4269930c GIT binary patch literal 10201 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 OX?K5=I7ju@+y4Mag6|*z literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9267.tar.gz b/dist/amr-2.1.1.9267.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..1da68ede2ecd3214e6fcbf72087667dbade7581b GIT binary patch literal 10052 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..b0b8c809a --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9267', + 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', +)