From 6fc1f3fdee6865335a379e4eecc3aa4d619b92a7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 3 Sep 2025 13:40:52 +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.9022-py3-none-any.whl | Bin 0 -> 10340 bytes dist/amr-3.0.0.9022.tar.gz | Bin 0 -> 10205 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.9022-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9022.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..2c9a69ef8 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9022 +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.9022-py3-none-any.whl b/dist/amr-3.0.0.9022-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..ba7678e9df7ad5c5c992ffbf274233309cea73cb GIT binary patch literal 10340 zcmaKS1yCK!x;3(Kg1fsr1b5xIyE_|#ySux)Yj6mX;1V2yy9IYAxIE5#|EqKFssG*S z>FS!9TC2KhYJJ^be@jUg5`X~)1_ld;X-lqq;(PX67YYnag9r=^`QxpKyb80SA;=Eo zVraaV0E{O|F&~2G*Kl0Bh^=Jt zQD2>ZMV}lG(}f?AZF8u#=a6jFkFMfu{UqvsN-y27FC4EZE%jrp`^(Tw(SXLnYb1gt zFSuQP7`KIN(&Wyv;X=Pq1sjJ{Q;%#1mS3wy%LtxMpDmzf7|Ld9=rWA3XWV*=Tf)5~ zwz{lVtC!>Eu%?Bb<7`w;TX@&K#xJ)J4~rqLVWV1RxUDw==BoqeE1WWlObothR?`lN z|Jaa#<@~*%g8GNpV)q@ITaiJY4dbE8)#JP z$V`@I6{Q(m`UuKD>w3-(J$i(+V_4>L`?hh&r67>@#*V#~$xS2c?2iB#yO5ro$FkEDj9ba4XI#<-Ey(fbS@X-DCm?~fRh#}C!S$<${ElfykDgk! zi#nE_0c{N?R4H}B5(;;MLNk|4E-|<98phit$ZYCjC0`f7EkHV z$!87piZZAXOQEqeht<3x!3}?!_(=Hi1R{dhzTm$em2ls4%v)Y&9*n6%md!s~UWQ`% zL2u68us_hRPj1YN%80G;8KBC+%u2P)Jd0UYOT^}?(tX%@M&908 zwxKRq-S}E)*8$36SnyW)j`NTTsx(=v1E=1+M$QOk+kGfvX@zRNDrIfmHc2DIRkxlV zrch~sq{V)j>8}=(-gU8Fl^Vy;m_TwJHDGW7Ga-`xBFwj?K1Y0dsm>xs`OtD7j4U#FLt?gAGaZ3Uw%yFZRX~Y16|Base&tNV~C;?$qrwvLuf! zm8_Ywh_3#~Pp^}c2}ftKayj1w%(-f&>xEtsl>RLa2L`ZY?m~irA;SM1hs}&#jGfJ0 zoIm1ljfQOeM;z`t(Pa50g0_u0LlpazK$YDmOpIW!1JGgs=-}1hs#3_R7~n_0UJ$Cx zjcH5~Su>DWbI03Tbm1~qrOu@R(Hri}e!VIyE31fIDyHUE`#Q9YS=Tp}q_sVt6G+&P zFdId#L+Y#wG|c43%dLhvK|m;~%#nO?`I){(U!y-I2dY@2o#ElV*hL%g810g#O4=}z z#?mb}#{z}meHIWNX_AJXr3^%8=S&a(gS{?%?66K=tL)=ck~K{T(-mj&eY2q6;`<1%vIfu*V4H!F%b54VMzcWPyR#S? z_K7^!d`%iORD~r`q1{^3!+BvR+=(qYq_GA_x1b z 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 B3I_lH literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9022.tar.gz b/dist/amr-3.0.0.9022.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c8b0232c8525bc7a741117d7595ddca225827633 GIT binary patch literal 10205 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..d7b30ffc0 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9022', + 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', +)