From bce4300dec0984b18033052bb57f2b24c07ef615 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 12 Sep 2025 14:54:20 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 +++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 213 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 880 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.0.9031-py3-none-any.whl | Bin 0 -> 10341 bytes dist/amr-3.0.0.9031.tar.gz | Bin 0 -> 10197 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.9031-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9031.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..9a961b558 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9031 +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.9031-py3-none-any.whl b/dist/amr-3.0.0.9031-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f95325c18ad186814227244f08d3d87294982255 GIT binary patch literal 10341 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 Cau>G% literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9031.tar.gz b/dist/amr-3.0.0.9031.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..8d13621072f23c0edc1c7bee66bc752547b38f7c GIT binary patch literal 10197 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 G5BFbSEFsST literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..7506e998d --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9031', + 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', +)