From 9f575a377ae7ddbac47f437bd0161f81e912296b Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 2 Jun 2025 10:11:40 +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-3.0.0-py3-none-any.whl | Bin 0 -> 10130 bytes dist/amr-3.0.0.tar.gz | Bin 0 -> 10013 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-3.0.0-py3-none-any.whl create mode 100644 dist/amr-3.0.0.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..28cd961fd --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0 +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..3f906f72f --- /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 custom_mdro_guideline +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 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..63c92aabf --- /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 = 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]) + +# 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..1e662c39c --- /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 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 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 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-3.0.0-py3-none-any.whl b/dist/amr-3.0.0-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..fc090e582ab25306824469f1c137769292bd2599 GIT binary patch literal 10130 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.tar.gz b/dist/amr-3.0.0.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..d684820c012602b85ddbc1c4ab4be82fc4f14688 GIT binary patch literal 10013 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..ebcb85a08 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0', + 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', +)