From 5860c5ceaea959d5534af5d6fd2fcb913e46caa0 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 10 Sep 2025 13:08:48 +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.9028-py3-none-any.whl | Bin 0 -> 10341 bytes dist/amr-3.0.0.9028.tar.gz | Bin 0 -> 10200 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.9028-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9028.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..7fd81375d --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9028 +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.9028-py3-none-any.whl b/dist/amr-3.0.0.9028-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..a4b5587ae92f16ae76290b266bde303c02847365 GIT binary patch literal 10341 zcmaKS18`eAV{ zCu>NhY_K70o}lmw$(_MGMdRYkkZ5 zr8($seDJKBgDu=gq$1jT3Ny76$OlM0w94OD-Vs{rCK!*`!093Z4f*$QIIA9zhuq&> zmNN+xyGus%eS&2z?UD`MGVK_qHwxCE-5pp>z~*U6=BugF^w8&B`U+b@J;U~T%r>gl zViwWn_#I;`6)#&jw>&0q_h3#7LGB?UTISg;w*8i>{Fllc(h3Z88r7;OM}*tAMIhLA zmlY9zI5WwthQ zNs>TARw$;SZ?g+)?Cn%{Q=aeYL&^uM6C;;@ishTugwZUj+t$NnD-p5Gv*3|eb$J8@ zh}EDMor1wBb4E70*RexV3Y0q4^P+hv#Jtdsdr=q^zQFxq40C?Qy-)Q*`(xRiCG3+B zpQvjX^H~Ma94jCj!lR8;Twx4jQ0VEvR7+&Ax*#V( z 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9028.tar.gz b/dist/amr-3.0.0.9028.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..f277847192bfe296bf74285238e58e8fb99b8bb5 GIT binary patch literal 10200 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 S0WvrTg`wL+ae>)}h50{Dd@&gS literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..f26d4a1ad --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9028', + 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', +)