From 59d3079459a4afc1ac171cab2cf5fad6f3731aec Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 10 Sep 2025 14:20:13 +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 | 880 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.0.9029-py3-none-any.whl | Bin 0 -> 10339 bytes dist/amr-3.0.0.9029.tar.gz | Bin 0 -> 10201 bytes setup.py | 27 + 12 files changed, 1608 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.9029-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9029.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..c98dc18eb --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9029 +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..bf9cdc0f8 --- /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.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, 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 +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = 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 = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = 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..9196b3660 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,880 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# 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, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # 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 r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +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 amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +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 amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +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 amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +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 amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +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 amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +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 amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.polymyxins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.quinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.rifamycins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.streptogramins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.amr_class(amr_class, *args, **kwargs) +@r_to_python +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(filter, *args, **kwargs) +@r_to_python +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 amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs) +@r_to_python +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(x, *args, **kwargs) +@r_to_python +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_ab(x) +@r_to_python +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_reset_session(*args, **kwargs) +@r_to_python +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_av(x, *args, **kwargs) +@r_to_python +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_av(x) +@r_to_python +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_disk(x, *args, **kwargs) +@r_to_python +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_disk(x) +@r_to_python +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mic(x, *args, **kwargs) +@r_to_python +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mic(x) +@r_to_python +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(x, *args, **kwargs) +@r_to_python +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p50(x, *args, **kwargs) +@r_to_python +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p90(x, *args, **kwargs) +@r_to_python +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(x, *args, **kwargs) +@r_to_python +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mo(x) +@r_to_python +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_uncertainties(*args, **kwargs) +@r_to_python +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_renamed(*args, **kwargs) +@r_to_python +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_failures(*args, **kwargs) +@r_to_python +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_reset_session(*args, **kwargs) +@r_to_python +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_cleaning_regex(*args, **kwargs) +@r_to_python +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_sir(x, *args, **kwargs) +@r_to_python +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir(x) +@r_to_python +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 amr_r.is_sir_eligible(x, *args, **kwargs) +@r_to_python +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_interpretation_history(clean) +@r_to_python +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 amr_r.atc_online_property(atc_code, *args, **kwargs) +@r_to_python +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 amr_r.atc_online_groups(atc_code, *args, **kwargs) +@r_to_python +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 amr_r.atc_online_ddd(atc_code, *args, **kwargs) +@r_to_python +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 amr_r.atc_online_ddd_units(atc_code, *args, **kwargs) +@r_to_python +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 amr_r.av_from_text(text, *args, **kwargs) +@r_to_python +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_name(x, *args, **kwargs) +@r_to_python +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_cid(x, *args, **kwargs) +@r_to_python +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_synonyms(x, *args, **kwargs) +@r_to_python +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_tradenames(x, *args, **kwargs) +@r_to_python +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_group(x, *args, **kwargs) +@r_to_python +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_atc(x, *args, **kwargs) +@r_to_python +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_loinc(x, *args, **kwargs) +@r_to_python +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd(x, *args, **kwargs) +@r_to_python +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 amr_r.av_ddd_units(x, *args, **kwargs) +@r_to_python +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_info(x, *args, **kwargs) +@r_to_python +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_url(x, *args, **kwargs) +@r_to_python +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_property(x, *args, **kwargs) +@r_to_python +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.availability(tbl, *args, **kwargs) +@r_to_python +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 amr_r.bug_drug_combinations(x, *args, **kwargs) +@r_to_python +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_resistant(*args, **kwargs) +@r_to_python +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_susceptible(*args, **kwargs) +@r_to_python +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_S(*args, **kwargs) +@r_to_python +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_SI(*args, **kwargs) +@r_to_python +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_I(*args, **kwargs) +@r_to_python +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_IR(*args, **kwargs) +@r_to_python +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_R(*args, **kwargs) +@r_to_python +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_all(*args, **kwargs) +@r_to_python +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.n_sir(*args, **kwargs) +@r_to_python +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(data, *args, **kwargs) +@r_to_python +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_eucast_rules(*args, **kwargs) +@r_to_python +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_mdro_guideline(*args, **kwargs) +@r_to_python +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +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 amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +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 amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +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 amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +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 amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +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 amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +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 amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +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 amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +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 amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +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 amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +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 amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +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 amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +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 amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +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 amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +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 amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +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 amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +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 amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +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 amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +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 amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +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 amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +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 amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return 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.9029-py3-none-any.whl b/dist/amr-3.0.0.9029-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..dc7502ba5f2377713391c738781e7d13c1dc89a7 GIT binary patch literal 10339 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 z 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..3f14cda57 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9029', + 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', +)