From 224211527912665fa7111716425d82c035d974e3 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sat, 13 Sep 2025 12:03:41 +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.9032-py3-none-any.whl | Bin 0 -> 10341 bytes dist/amr-3.0.0.9032.tar.gz | Bin 0 -> 10188 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.9032-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9032.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..990b6a0f1 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9032 +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.9032-py3-none-any.whl b/dist/amr-3.0.0.9032-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..534e049730b9b65353cf5a129e31e71e2ec10d20 GIT binary patch literal 10341 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

eX9(!EaVlkjHzt^rbqy=*Bx-4yh1oc))ZX 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9032.tar.gz b/dist/amr-3.0.0.9032.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..e8778dd2a1808c4d499f81bb256a8777b1b62597 GIT binary patch literal 10188 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..e34610c2c --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9032', + 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', +)