From c8ab144524ba57a0b361bccdf4d087d8a4c63f5c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 4 Sep 2025 12:05:12 +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.9023-py3-none-any.whl | Bin 0 -> 10340 bytes dist/amr-3.0.0.9023.tar.gz | Bin 0 -> 10211 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.9023-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9023.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..67c9d1567 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9023 +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.9023-py3-none-any.whl b/dist/amr-3.0.0.9023-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..2467fa6e0cb6eaf769813788fe3479ecc7c08d66 GIT binary patch literal 10340 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 Ab^rhX literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9023.tar.gz b/dist/amr-3.0.0.9023.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..43c4691e58ebbc1aef8e060db56df0b2fa859789 GIT binary patch literal 10211 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 E2Nb$4n*aa+ literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..e4a15e07f --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9023', + 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', +)