From 5aa12967446cc6a1d8c2b445a6ed8ead5aea4058 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 21 Dec 2025 11:30:24 +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 | 221 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 912 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9006-py3-none-any.whl | Bin 0 -> 10463 bytes dist/amr-3.0.1.9006.tar.gz | Bin 0 -> 10302 bytes setup.py | 27 + 12 files changed, 1648 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.1.9006-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9006.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..b64711004 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9006 +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..775bbd109 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,221 @@ +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 all_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +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..9b8203a42 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,912 @@ +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 all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.step_sir_numeric(recipe, *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.1.9006-py3-none-any.whl b/dist/amr-3.0.1.9006-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..189b1ca8f2eec2df033b10af28ba71c63b6468bc GIT binary patch literal 10463 zcmaKS1CS=mwsqUKZQHhO+qP|+Gp%Xcw!5dTY4^1KwXHYz-T%dT_r(8BRb*sTMXeRP zqH68TmARE;~p-RRDQN;D1`l zW=Q5A>+kIr9vgWI4-MR@XYFayZnAV)%1lC&YRMAGEHdi;F3k&$xQ<;b@O)m4-$cf% z^brM-qoP%0(pK`T<_%$1Qiu^|oS14oGeYWCqxEkc!7~Xi$00wb zAHjDW=7RO=3}|h2olMcu-N9%0A1taW4naYlc%^2R(6^HvZ7Iyk(sH!f@a9D$5^7S; z!&3rsfc40!&;=wKI+Pr8-g`Oh$h&<(N_t&eg?-=em(EP|b-Xkyz~+a|-J!oH55r6Z z27+Y}0rqEf4k9w%N_^UwET4sX50Yu#GbXZM&@X!<2@j~ZzueGXbh+`x0+N$|=!(GX zV1%uMGg1y^FeIDIvp}%EoAg0?x9Vnvk%a6lC`!{!#i5Oo zYro9BeRu_Rp;_X$`}3*GCBYI8#@{^@+07&9?9CTlr185*Utg^FvMue6{(ewGcO%{~ zr0r4>ik{C=Al@s3(m}a#D!-Yk5S|6Hx@`jHw0s`$Fe=PCr=SvjBKTRAB~@5Jov!1X zg&fVYQUD&aVPVSKQHn-74&_l6qI(1v`Urm0T#enJlAB$f+n|HJRjuR9T<^9(w6Xbh ztIht!kaNB(hBBVxj6jsdPgNkErhU#0rAWSIA`5BKe35kfN&#sCr+4U;_Ynq;s-Nad zI~<3o1<##_#ZJTlXY?CKra)yxBbB=lLL`No)lK-i#k=|Rfwx&$cqcf=== zx$VrvL49O%9mDk;nYoQ)c(XF5qlI`tW4Z90Sh5nuPMv&peI^-Q-JI8h&a~5E{_XXjnEP&QnnZ^wAbBpP#Vng?+uCvEDf&c~b+Y0I9@(|U!C%lZT zBdcB~7kB*5!C6vBHpX0{PASUscm(GZ&>nTHZs!u==o3CJR8u#X9&C$Hs1~QS;a%F z1GQ(Z+Qp(-F%u>+D=r9IDjIGqCRe~(oSCC+_6-sA5w>*Gpl9pVm99(ZIXQu-Q$#~pfpyKcDvUAU$Dvo1Ns$Tg5u?=02E8xZZj0Y$n40FpIA3} zXXvx50z$;sxl=gpx-atK5|e-388^ujXKV99t}gGuT3v)K68r3t;C{@|ka+PNH@n@^ zf3jBRhl$_^tkQoZ?BF1#>;q6BAUK%661JJKo3X38o9my1U85nJxWR$cd#=eeBaE_# zzCaNFnnaO1C`1VBr~{@&2d0BlgRM#?t73o~`*DS@vh-79j=+YF$c8J?(V`cdzAAkw zLkhLw(QM{JSy@>{^jb0fd$qq)>rb2d=HiUbHvpcv;{>Bo^cJYj27kjsexlq)gbN6W zqRJAHo!fBcCT)%WoSb#}D)j<4&(#6Sh}UGVG)2m`ku-*GnK_1a7!EtX&_uH|#3Fex zDl123XbdEcHN5KynA@#dRipYB`Oo$%*NwLhh}9N86FAp)4dU%9=DsWiogqpc^Lo)schz>bE zQuKQA9O_5t-U?ZUOArFgcq9%xYk@?QRLuhS_5GYz-$sTjgLzw!x4;;t4`Pe|trpby zabV#|Ke$u!L5HinZA1Ui_nfd#-G2#|+gpF~Ql3gv$_49NX&o%4AmaQ91Er6O(W{C5 z2t$v#Z^O8NHe|r#=|s^O`IJa+Z&p+8v5HqB3f(0Ep}&vC`tWSQpX#BT(0ioW{i142 zj&DnGkMx_sePRcSOXM(I*wI!K<@1o{v^CrdN*;mOPzP;wu?$xHvwe znx;`^$B$HCyL+pka9_cW#h+ulVXM3}G4h9>2sdj`|#Q#n$Dz#!(8x1ZFXWZ-%U$AbTv5Ck|z z4&C5@fLt1ZfRO&*49>#c!PL##(cxbiVfnkh<0c12#MK9F*dxil-5$sG

1SoJlND zhZS;r|29n8@O*u#6utCX-uo+mn#E}9NmAND5f3U@tE8yR?9arZE7JMq^>(|BiUn)> z%XBP;ERR56Q@0yR#_!Wv(+Pow_VEtApRc9nhx}C?(+J6th7ho?K!PpY;qOD)UyqvG zW`x;a{_pqF9gCPMO^cC+*`|c>wp<=}DpimU)pKWFffce8kv|hmg~o!=cN!Hs-_aiB zOFJP%aBe7Uvn#X01rsY+^{yutG{$WGodTs>G&OfD^CPMp#+nQRx_$y0MM?AgU;vrSDf6E19nsxn^>afO2m`OZ%r`1H9=qAE#Alfj_F(k@5LD=5>3t8_$?~~;@ zPy?h1{(zOUC=8E3?JzA0-XNpSFz1X?U#R8bDc+)A$!sU1(>fb9{D7z+WHQbEZ9Oe% zPJ^>7$5R6u8GcMEZ`YyyplU+NSOK{SJ~g7rCXnv7dot$3RXp_dIv&n2Iqa4b!(ir0 z{|?(Gml-agl4j%O%!?{2l%dVhyZO255hCyC%4ur{L;%*dtLT$WIub!_}qcSZPNXes?nwF$s2ogPQA{Nl>q%e{*&8@%;JUOi)pXd{#*0=TN=Mb<*y1{t zzd8C9G9(4wu7zVoUf>cHXN)3 z-!iW+3nn-olESKqvWt)uRu1|7>ZD&XXb;Ds!dmFh11hlMCGTL`O1G6oCg-4J#An^A zbCM-P1V_T?P%X=1zeTC2JT1wPFMyzBws7F}ecLEQ2!@283!T!xyU&4|Pex0mNnnOZ zQ`rRy`h}Ux8GxighZ*wX9@UHA6(>R}8q2I&9P(i|klh~SUKihz4MZGB%bPZbn-+A7 z3WiG1Vw4DfpG3{KgJQOaWsaIQPMNFYGic{!D|5VaiwCC|7 zee-FgWvS6NZCcmJ2isiD9)LOGTIeyS@j|{3i`0jQlbvi-YGlO3b^6UvBD(zW zGC|s2*WPO5W~6|6`i1wLLE=enwfIq2T|eQ`yI%V8iw(2bpTJJ#t#1?H(mWd~Z}WAU z@~6kQ-I-Lt{pdsB8Bn2J08PUzNN|4w{hra5@LX<3eXP|`{~GN-@50DvYV@eG?F`co zZ{!3EDzL8Ii-fwkaVATB%xH{H>!@YjOvd1iOje{`6`&;ROV%0ZQmp}PdEd$!*LPW$%g=ELpAc}kCyq&drGt+2Y8rEPknu?=n z_qrl{rx=~_0FM>`hq)Y1r_>vUuA9vssp?(Ux01;P4fD%|r?L&bQ4m8>SQZ6lqYySi zCuq$g{J{ICd@VKRB<5b}eQadxyZ|gZ_N+}N?BQ&QQ4l~;!g*z(6e>~tb{*2mEjo zObTI5EA+rAZ`c%ClynODuwwr$nakUZ2;WgI`J`=63#)sj6rm^x1p4yCIUAwdE36+X z4P~jsl{^j~kB)s~c}X=nQQ=D-W5rbAhaIMhI;R$W*xSi%y`|Vz!up0MXE`AeCn_-O z#eywLq&pvAY16@?-6hvGKWOX`a6Lr2wv*F2U=dD722?9#a)%-=Zua5}D(w((0h}3? zjofyo=1+ctKJ#$d8a^0!fb9J0R&6J#UiVR9$2c+QxCSGEUVwC5iU{6#-o>Pq2sveN zXtjS%1WF(Xq;#Mvt;jnxUi14wZ9y>+c$h5}uJhY|m#&G(g4%$#?&nh7t<8uTKwrZ8 z%fdw_epp3;?2AjaqtBWg;mV%UD1=gY*MKd7IfA}JLeOERu9ndrn$!oU+_-l0rHQk3 zDMF%FK3JqhX$=}*cwlyDz!a)s%tW?&5^4KA#6d@29&?O(k!yY1t7_g-YRdm0yOd36UrIzzLx6v}i|2{}~ z_-9z$keo!X%SJ_1I~zo+F3&Tb&i$5$r6Dy-KqPHfC;dC@nVB%aY)LL`$k$uZw;sz$ z-$m5I!2(BvsxHf9v(7e&D}xId+7UPXQNY!T3Tg<9Z`Uq52vSPPW@UgQ22D9 zNEy32TuI4cO@{_Q5eY_sbG;8=J^30ZyMMsfKfFLiT9m5YzA*KO7|k!vV^dHfls_W0 zO)|_+m(1y!yKn|ep>z?W5ISz&?bi{!BaA|6xD3ng2P;Y07b#V{q7+Wq*AUq=9eCm5 z7xXt~!DLY2R7H?}Rvd*rJM%2CHPjIphRXp=e@Kq#P3)kTuyV%3eV(s%7ZR%R-jyGm zK?D24>le^?n@=Vc%NlB%R}v>Z1OoLBv$BeZBGo9XO!huy@#lopW(IC1CJqKOYgadVYX=KQMtN~HVKHGf;TD~9hYhKW z&$_a5ccv(FsbWAQ*pw0eaVM&wQQ6{_Gf0BaApYUPkOg|SnfR0Yc=uGzsP zN?M}&MfFZKl9pE|1QW2IjDj)WLit)*nhxnl|5|x47WiS6mpt4}e?52Zxj-U>}nu zW8u!~PnU3jG(T`Yp{E8^2L%jI)xyG@U1kKtdZPv;#jN+`-aRQ$3pcpqso%zS-e$^g zbgUSYonfll5Y^K_T0X4NMeEf36!o<}*EQReTi#oiPSeP5D%+rA8<`C3K}-o=^f(Rb zNC;#cC)=4Xj{F@?V9wGz)tUNI+-U1B(f7)b`UbVuoyvuT0i7^Nm@_|9*s)Qnq7cPf zgG^1w&Vpz5o9C_kMC1$xnlw2mLSu-CaOtQ(@gE67HkE>o ztc#nC+GIx@)Lq~?P&&trM$FW}^kcVRFe-HGfmCNi(xLd|S+i5nCZB_DaG#TBL1GBC zc1buzkz2#rdoS11qBI-a)Eb>&A+y}9c+7-XD|>0$^5p&V%He!UN=kmdb6QNYT^JLn z6leqlb&~}1ho%o9y)?*$3&(~5F{htHNQz$zAwl(-hXW0Wu_j86f`!;N#xpO|FRZH( zHPYN6;~2zPo}!>IWO($H`2qJB5H*EI6Tz=^DlN%){$y80rpJ&n5u}`68;O@&fD1rH zu2n-L8D9gy19H--{SU1v5v5J%dvV9LL%iIe=e0|X=iFAWXjo;efN@8lv=QNoaCX;X z$hFakBTC~(mzUL%j~J8Kl^?gnRL6T#@2p7!2iJ*7F{a|ZJKaL9wMV?sRds7sZg6a!a=bLH znfN6T2{TAxMN;8H@0N-=1&S-Hyl#2jixSY42C{b|@MflUH9N@yZQKXt!^h;zmPm4Y zD--2ojH`9_eNn0El+b^UyU7HE&SC{Ht;C&|bR?MDfv%5h@j0^jAiQq32%!r91|#y>SxK4y$80 z5TzuaI8v8K`?ls<)6`?KSx%ui>vBf}@Otbx%9cCb!%w`)A3X@fBbry?)1$hh2=egp zSkDH7_XJ{X$(Llk4#+M^=%~bU4vJ86Z(G!U4xi^<@x_5INwQn^S=q$JW7bO(agp=C z4fj<^g`b#S?Y@1z{pxF}Kzbn=A5vx8QVJ%cKu{8XMG{S1Io5|{2}(nNcN83;3qydO z+H_E#TUz{~VQ+?2MMfV12~)n>#*}Koxa!S-h`tq3(H&^{Wg6G+>Q>}gda-wi3#rbT z#Hf35n0q%gl$z)k?ktQQ^+*)y{aKS<=L;`AJtzuoi?XmAsrq_n_#H4WTxLmhf6^6a z5McZ6IFui1eZgBd@JV0F-XI&oCf#Z1CXhbUH2$NvJl}#OsoTrj&BdC@FaXpW$yvl5 z8~g02FyN)e`dVrmUQVEj>6E!p1V_%qxnFbi9t*9JXc^w^nF`#5m9g3rE-m|Gi&@9M zu0|-%o=EL?*Qmblhv!rOL#PmvQTPxH#OTsU%Z)~e4_${iHPTV=>kK~}bwrSJQ##T% zZHYe#a7=>C$l%p%N&#HeEqBr31Xxm3TE3IU@btHhRnbHGcfqX4j}lrIq)(M4 zfLbTONJ>1n03{R~kChyr5sJ~AWJVQwTCB$1*&l~zNJH36J_MigS4Y%APY?C0byQw9 zSQW-Ne|doaApKIAaJPy8GIJ53W;%Fx4yZ?XlM_*zGi*gHQjwrIk=96!Zd;{3mAyG@ zidISnGPN{$CZqwz!3KxwGGJLS#DO;4`?N5Q@$9x_iKf71bNsH$OXrfjoa_P*@1r#| zCaEkSL91Bs!*kv_B9-_GPXrVQ|KI*=-FO5 zS!Dh{1~yq&#ih17k-XOm<3M67=^G z2u}`0HLd$19mGlarTx}c4cYN5Ox{9hiphs0KW|;=fq6*M>N*j5IpsGZYX4F z0ts^LnqNIEWY8`&)}HyK9n@c{$&*O$2FqIp_W2+c%e$iPe!Uv!!~@Tcc5NHZU7-ex zBClZUS6w}Y!CMUhl#*vpxz&#wbeG)0g~Iu9o1eu*^?is^fh^9DL&^x*aB#&}2%SHU zC?*1V=n}*tq{Uo}=b}x<@By5%6sgEUL%qCsIvr1xL2#o0r`)tMgnbZyc?p?2_LL6= z@x~2etv;~r22*tC)=SMKIP*bjy$27ss-ynP#Ok!f6u!u`tW{Qh6e9YkEr-4hI%%Bq zgf0iq1$%+$;;0hF6s1=(%BA85K(Q{h015Tem=UW_%pOsPT47vqD;R*bS5XB)63~99 zHp0o5$NOXBvg7&J=8PGtW&A;gT|U3yhAtdD&X7}aMVawO0(CNV8G>>hSW_g;fGW%Y zEA2q)!Y5?QTG zC$y}sr4e2!@*|=`0u)^MIL>(i?V2fUeib@!5x8Wy@rcR-SZFqzpVG>aI(ysFVPWTg+XtSK%3Khhig*|$6$;loN|1k6L+Bou8<@D#F2vkknCbU>fUCNp5ZIFVj`8f9z7 ziwVo^NuKlUp)=Issv?6)qI8rOb*NlZWB`>$m6UkZHL|B1#J;g7n@=fHW?5wZ z?3u_g-`zock?`J{2p=z#EAh;BFMlm;^7YHN(H(i=fDj}{;^EAl9d*F7Ym3tEBr4+T zj|_arCM#l2ZDTJifM-74utZ`Nr}oDFbKHveg5i(GmWe`ja++Ae6nqGH2LGM5Ol>k| z&`oAwIjyMM6Hb@1iC$Uo&`+ z{koN#fpw6wm=*vu4(+x9X2ETzxLqGFGY+gFg|gf?NG8SNDxf#yUFZ4+)NABOUl1SA zGn3C7B6TZ+$XeAMr}t33Sw-ot39rD-Q}?Kv!%9=THJQ>t=3j}&Y_kdxp_7A@~~}?_#O1E2kN)B zy?eLhM_#SI<>E%`!+W_pA4Km{{kG=CG!IC7z^71n%f|OO%ArrDr*q3}BTYuvG7S?! zo89A=hdXFzd{4AE1thHJ+< zIL+n(;fV)MZdK{x5O~th@Xmmj>zww4CuJ&#@bEq&tqX^HN@xE!AOCpa=aA}QjJ3Lv z8`3eT*+UseMFjPOLiU{fXT#I@cTvZBf>$jgfw37zBppcFqwFUq+p?0Qd*^dYxT9)A zuoJ0d?|F@YGNBz?uNV%moy#ZqsKyRGGim2W`P}|nS>(JvFPnKy*eZ|8btJ|wB$I^s z^BYE`N=L;LD*aW?NN{_?9%W<9zDEJ3Kzyl`)K^xesC^-f zXH*lc?nvq(!1B?0*6Or{i-wn!M2aZL=@|QO;r7=YAc> zY-N5WBXkFAhwOOvUl<641uYKYiFXt>Fcm&1AAgIBkm?Zy;!iwae;UO<#pUMcWN2sZ zVQ$CZ=H=#k55ETj^q+62;JM0U1pKFp3Iqt~PwCYE?P*oSMHN-V+@~g7a+!dD=DPaC ziA_-V=0FG7lyIA}R_9_Pw2WxEOio>BZH!gZ20Nr`_FC!_L#X>1SnmNdqjv^ zTzP5raI`i7dd71FKD_zFbXjvS^5Xk72+N8t$9r5Jcpn?A1Wo>`H(0?Dr!T;+1R^;|~ z@ZU=;{tX2JDh_V=Qz`c^@c$~f_&fOT+p&Lv2ciEB{@hX8PJ`?p=>A)kf9LwUcK+f5{1exIDCzHQ#4F_2JcfO&*PeB)1`L0|PO!cVXsW0kE*K@BskaEN&()P*;BMF2p^}22V z6+6l8LFDnHFKq#Wf9oLAqrL%K7R1jTLhMNse$z3eh6pS0U-q|5X?ddV)k3W!nw^fga!yX zUvjCj=D&KW!sG$d7O94T5&Id>14tl;J4Y|r=R!v>5V1#y;0?(Fn~j7xe%O$UFKZ;y zpQ1R&rV2c7?pU2QoMgT*VuxxG<0?9(XoC}vTd7|{2;l+erZnt@ zl6%8F)Ok|jf;{vEyP?(;l#K=I=3JSj^s_l5`C8_`_5N-pn~w%Dk3YiBT8TDSQbR)_ zp#3~^FOYB$GG2>8_#@P)72#w(2DE-c`VNrQT8Lf7+re-l;h+;>7oGyp%Gj|a(!)^(R;#ZUj zJU$~rxaZ=`mp~-u%uwA6l?_L{udBEUyAdC-&9vRXEDBG7UA2?pL(5W&D+Gq89NJEF zkop8YUw`i0c-pcx**iGk5KfXso7(qy@R&7RM;}7C6M+&PqlVu|yXLA~FUX&>qYpcE zxlKmGpCSz6iHFrg=ii@YFX*6-T@Lht5ZQEH1nr4)@K*`QVn62K>$su}Dyd0*hM#LR zcpfV^_4(UzR~sdQs%jRtk{U_}1!3)c@_o^l#YLQAC#EN(EoYkz%wPG&5#)-x5j4|> z66WQ15jJgIV^Kokg-ut2G)gvw4UM`_s1lSq9Inn^MW&vl0FcUe!-q~cK_YArH@`EFUD#?`L0xOH7n)vT z_#*{D2+`)D)S=p3>#WDG?(6Aype(za2nJf-%s81`?$gxQUzii7A>nhy4d0nZGXK~j z?6_fvyao+6N43ia(Z?c(TeY}O{=J!9;<8-9C22}vRna7x(}IF8t`R|ikswM0I>Gb^+&s($6YP$lH+UWQ-@__F<*?_ z34;DxZA%y6DDo@1XmM9Wn9E?KeqC@Q>{~tls(=t6-rk4cErD-^<>5@|S}b5tOHn%! z%9CRvn>SKW#eX?>L$QSO;HE}nAZTa`1;4g<%7!!fm?)0x>=BVGD{$Lc5q&3CNHT9K zTB~OWANJig$}nua3_4_7Fh1rh8zIcKmT3ncfY_+$7@x?nk2;in5hhj^YnUkMhRET< z`at)LL)>9wMV%>wI6`f4wc#=~v=3DQUk2Uq*E8ZP_;DhR6uBS0x#N7Cj)I`t7a1BQ zraH9`oXQ=n+)ruf7;)!&tw)waPiuZD zMBrRb6K<7oXBlhD?8>ezNT}g0p-%eC+R5cJ|0P6UTrFe1C2YH1KV5THEAdpBSijs? z=xn@7-f7V}w%WTRwUhFVNalUqW8>_@$QzQr11Wh9sJVhnJe>&6f$MhKSIO=FLM||+ zy&sKVgab-$`dyw@~m*Z6!?_)m1b zMtY*S>e&E-zk;ixWLd4Yhvgv;+#n(ZEQ zFeni_ebnTkR|oUr1AqH+GrW0Dh2hu)L=3b8f7JLl76*mZp^e8(_jfDv!LBC5fo%if z%a$CUS<7~NK_@6N4dl7ky|6lxk~QXOqqHspec2x)F?Ok>uKc=ch)gpypU;djj()Ok zpvbzUcrBM$v5O^7+t^7j{(eemZ-7k+a?g0e-HKv(tZ)`5sMe`E4A}Exgj)p^wxW{} zan4P;-6A3g2i?h#=>A+g5T0#{*m!^Of#eT!tS)-NnBO4slNt3OZ?UavDyP>y8tJQ7vV@$(^l>vf6yImFAt0kITmiUWVP@b?k=|+p) zp%cV$>B3Zj)lz7jdT{FHi^ue--gQfQZbr(IR#6Fxgrqr%tJU}DCksw!UH2LMi_ytF z#Z7QlJBB4;P^t3S`O@Gu+MPhzo~OOi?(OjKxHzl&Kugi~$(ZS%=bJe05Z_&4O{yN?&Qxd2FU5;$88z&Tj|AJu zTXn*~o-i|WI2Zea86%0OBFTj2ifk~^Z804-@g=Tv9CY`ReMYqhe;d(T)_2t6jsi|M z8k%x57$>N>mZ6O79lez{8h`8HAANlIDOt>nL-@o_W@kc6GVa^169!6q9P2htNH%C5 zQ8zshkK(%=MX)y0e5PR-Q8qmyhODolfoL1f*9X(flL1nmJZ0@32nYjj$)2fF%ik&W z0&pxt@L50Y;;n=J&W3PlLETWk>g)8i48);xT=f4*iG-|6qf^+Hw7t{G`_?{8D;+7` z(smMFG00)X6%%m(wpU=HwSRzed|)3YaufYa#7h5mH;J$MY7sSkH`%dy9L?PpZHql` zzd}<;zuGPYE&jcGS`{?qx_)xAv@@6PasEi&4K7*@czB!LcvJ2%{V2c>ECvdHnDh!0 z+SNkPq=mY{_klp+u34e2*W4P@log6Tm~`eJ8r6VEnRMS>4<#==c;VX=@w;ICmi4-H zhZL(dvgv@MxV|!7!^G+sXBP#RkCx>WyA~=BB>giL1Rx{r7Nuhgl;{P5qEF2FqMtKVyRGQX?C+7Tw@1)0c%=zb3dO0wz1SS#YY z-+Op^fHoD~kS!Uq zl)s6ElBkO+yd3BUnjc)hk(Q&&^X^IZIWnRhX8uw>aU%sMtBap6 z+J^T}AAhuMJ3{LZaig!iJ9d{Ds%(DC3i@e{ET{M&rm}!kUad~z4&AKUYt5Mfl5^a=8&bfh`_cUkZ#ZdD=g{Sn1up^F2SP=MAzRFiO zyKL=+WT66%YUsD0YYEJy9Fy45>nf=|2(esP2-ZCz)OQc8WU!uaN7fa%4F#^Q@blXTLis1VDMdRIa0f=l=v5o9Zf zMs(jNyrd52PlHeCvZx`s`u}D4Zj@s@*$RqbIGMFl?N#L?IgbX_AYGzRi!H4y{glj~ z+(Ww2mSnfx6%zDBPP0EsN|4LjVqAyMZdRUf%oeuKvoonUPe%7Hc`HW9&R52__0*3p z&DA37k;h)c;e>gRy{uR6?NkXW!nxHmXVdJPr1qV=f@;B$&LOms{jBfIFtc=U}<%dZqbB*gz`4;?V31&D{k9dk&UiY&VP^ zDdXRK4q;fKv(Zsc)$JjWV{1D`s)^$8bFAO&s)J9_%s789NOAdt{q6bQ7!1ybXT*^- zHV(_|C6|M4D=F_|;P5rdcNa7pI++c>ChcFj`{pz~8}Yo|_b)>G_GQNdR)6xHt`qF* zxr=Vce0@0k>-pB`$d4oK&%kd8eEFttI@J*4)PtY1gDVqSa~WfukQ%NevqyNvekQtz6xZ_AkOIC7KSHB?>attK!S&D2o$!IJ9n53yw&NmkT+5do zkv1=|pk)~*7wxfCXZaLR2!O&njajCex%?iub@JF$UnZPD^PS{#F`(`lhTa>s)BhoH z0JK9~9(dXk@>}EN#UIf2%1kO(0vLQArr-1Y2xU&?>!F>ok86uVRnGwS25UZ8atlGK zb9O6kFj}GM*jQi7yvLpCZEw_2<(kDk-evewcT2%s?d~A`$=UGdoO~3J?rlQ=!+UE0 zVMG4&tqKLrld&c=c1@Yff^t1e))FJgrP%Ev4<%1+68aa7NktSjQ?~rT-6z=rH74Y7 z?Chv!Gdx@q`L9EHh0KdtVKu*qN0+UqP^br5kDBue>64=*{|MjT>uOrh5b*}LJRRNW z;ML3LYwUf~M0~ap-vYIN*F?x&_1*HyvtIKWP;K*iaC%?tMXQ9SKB5%D*M)!3R0(Zw z8qCs!GW=CiIIP+D^#?Sv7hRrX4a_I5$WT2jVL}aYbS(<(3sI$adR!AVXS`AnoeN%8 zGcY?Z&9b&Ow&@!MJbbU8VzkFB9}2p%JGKq7e1o6q1_3XA?hT&u=c{tcIiGi&+b{~+!k(Efw;e_-(+ME(QDf3W%wY}YyYKz~T5?eKKU z#i?J&cnuY%p}=f{R+b%{d{eSPU~4pm8@$iCz@DdX@5upYnjvLTA)r97Z2Ex^G*vtT z?I`13+qjn!h6E$-k!qA9QY@oNnAb)&OHB$MX$5?tbh;O`o8Lr<>6Qcv={9H;hz zND@J;QO8bjFUgVVOx)H;92$0vHx5o1qyBYl?sHvE4)3@k5A{d-<`4v>~k1 z&d}0J5~t!{IdQ!#4UAIzt0EY&F+V_0Upc!(Vhw-5 z$c;ra2o%t$4DAkza-o={_hTPm)^$^;MMBe)u_4|vJ!G0x+-B9|CuAVDd|t!;2<~WL zSYvF^@SVQUd6G+Q&_|Yv-2T^6(!q4&$Pa5*e%{v#vO1faxKM!4k+iilV3srpisFBBC!^tLl%GW(YGvC9?vkN%pUr;>^}U zyAQ~a?x!DMyBLRo3MwY?IUCa|W5T}H7lWv;yHXFO5vro{@B(9&_KR?o@cdQLge}@_ zkd*9>w`)YqL^`KoELJSD`YSIOFVw=XxzOCbWl&@Vc{<5Prc})xs^QeJk*#WxZvHEV zoZ&`63@4Fru~tgQ~Rkw*XwIperhO~C4)GQLTM6rSR z?i+$@CEfQQW>GITIJ^h1G6ie+Tuwtj#GJ7J7BSq&St#Vw(I5Xcv+9=NmBZAnv$(Hs zMlg~jpVVUOAXSNx+Vr?@Z@ma{duY^L-;k_9G*Cha&Y-iNR zJz!bt0pV1_UXA8 zJiS~*3X>%(h)s`Bd=-BEEr(t5E@lm@Rcc%OcnjX~8!aCXj#rmv?WhDlc@L^O$De=f z7Ke|qQm zpEj>%yNTL(teHB8Uh{R5yZmpby|GfG@nbKPqXAfEZqc@#oxU}Y>pBQxvi*nf(i=qd z0b;BVd2T*geItK>4Da>|dB465XJfMc|I=J@w9&&ut`FhBTj3Gv1)s57NZ18Lo2js! z!sp==>djOy2m4u!UR}lD3=)z!qcTfqu{)js2D+Ar2unMooCEB|JJVQ>v}dCez5cEj zhQQr^trInYmK*6TfB30ej?)OtNfsrF5fFKI&{N8Ap02aiA9b8Z)-ua^h{QHX{K9QO z>1}Pb!HkK&cKdCIJ%d<`X4lYH8KEY+?>&}qem*{ZH!sog0REK{N|1@S8h*ZI0AOhX zr1y`om}W-s%;(%1`>XRe*jIU5GN$KlU3Ue_iHB*vH|QiETg|9uAd*k!_9UvyP4Prr zXew4O{c^Vf{u@M9ZG`Z(_jGWk_%S9-%J}yBG(Okc0j^kDxY~CQ71Q}bY;rear$%28 zJcUxkf%8(;Z<$3b0Ji0rFRPUuTxm*`C!OT|GG04By(=qDP$4y=pJ<6M6ZT753WdD) zhMumL!68xS>>}n+^0L96zFGeVPh)5q2*0#AIjq zNvkSG6bz+B5ei8V=^ZJQZeifp!7)_Aj_#+i8iFkmF8mwQbw<;UiaF9GeJO)${K`N% zdgrb{Q3u?6R_4gjcM1W_L8;duEzfLDafVi#A6-AJ#0QLC@oTT#7BTh)_wz%Tk?b}7 z8Em@k&KCQkgX-uU&wWAnmQmu?n7O}#^&VgYqA{*)>iFTPcSpJCsa**}2D(Cd&gcld z`&u)-GJ*nOLJ~eN9V_-(N7@f&U*Lyxt%|Hw4#CX>sK%meq4y8?eaMu5!uIq8Cr-D+ z?Yrn?uxAzgDWSYI@XhF_;7%^2_xjTuOc(BN#Fv^1Sv-ZpAx3h!*FE%SG^Es(+k=4+6?IpohjKRs6V{^JykHEU#Qd2Nq3=vPy z;lh#1;qMn8iLf$-l8DZ^EZwryM&j~eqMFnJp42KAQr)A>5<%L8lTGpgW+ z{M!R7P#G5YTcbgvT&AZyI+jq@&wZjRrJB3t77w4$-hnTdvmxSQrxerxd?srWrpzy) z4k&##x&cPJ8j> ze+<9LH7>vvUEi8n_a^9IH)E8KJ_dd~*wPV61BLchVd%|6rV!0Z_%l3TISeO?G_ zK#7_>t}wCl4t-ONqv8#w)p;92we*G-Vx&{_$W=Eil~5Ly+A(lv?ezisiMB`Opo`g2 zgR)_dU6ePRBT=51Hwc>oxAAjAd-?YtMLW@YhOtfv>WAHnzZ@knsY+7IJ)9pWufkcG zY!-dJm1kH&D&ItoQ)>{x=IdjbsBrE&v2*tF^B+A7jcET2`4TP~Az_{TfNORq-g(`* z{D$!c?uG0^FgwC!$Y2CHgJoB5^JVIJ^Kn0a)1ef`PfIb3x#_%pARE9O`y%@XPfVSR zjKrC`W9mfKE5mzVQ=sC8YB5M7g`Oxr;e)k=~r$~SD!Fs8QAN+KzxHc)!DT5;ZY;3 ze?r3WI6cEr4wejr7Qh;VE_`QGsQ&NY3N%${sR$?8vmNmGl~2tZLW&ztriPzDGmiGW zOX}2V1u`hcp~=BZ$%riuL||guEoIz!Fs2*&iQ8%%?(u~}PzD$114EO1>8*Toe)$bn zVhlkv5!CYtw*K%oayH6Df=_53TtM+uFMIB4gP9w}pO#Sz?zq}kg^j^Agt|UKqkJ%o zYc+wUBZZH)>Aeo6AgB@~FD`M024Fe+idoS}e{a!?7rih22zYv7+dmQessT4Gk&IxR zH*m%;0AZol-hh|&;14j|w4>QtSFk*a{*sBSugqT68}V~NB9%feHd2?Dh! zH|ZA%x#OrA*{hH;B~s<>zqEd8i~Z5U{1H(>rI}Gq*5jRYc6=!jRG%7i&FNwPg|$4i zo3;+zfk;G2_=ar454z23>z;XWi&;JTo`mwb*TUgM_nWh`HuJN5zmwnLiK8pq#Bx@t zy!s>t*288Y9ZCuUvs{QJ4K`2I%VpAws+MJcx#>Pdca5CZ37&G47C498~@7OJ(`VXfq{${&NiFMHnR|3JXu~4boUz*@^SW zGPFNM;3MOvv0jhJ>&DMa*wO4taWqezhshybNsGwTu@T$1yn}u&DD*{#e|19d3dQL{ zyrx~c6Ke7JF7YIvd@{JFKJDJe8cMj8Nb+m-#halG9}#93{dGzzNWu4lr|UP3AMAoU zx+~r!f5N<@@&b}Q|M^%1ixyF3I%YCCF@17|$$s&DZZ-mZ6HTEVRhd4@C!F{(+hD** zT^x1$NrEreE#60waQE!CnB(n3lmIM@rQImoq*ZL(Jo}UUDgtyUyA>JiN+j5uK8m=$ zIS1Fopg1RieOZo7g#J#Xc*6{ENr6Y)44rmJiLp2(#KbHLnmw@g0k=!e`_PBN zG9wOuqApttx)gEz;(G&(sI#OQG=fY*Lx1A*d@`~;2c?IYTmn1W&#ncXNmJIO3!sqf zz~|ddPB{FX1KJfr_#I`xiP+W$?LJIho-$*@Zd&6J=8D+7VLQ|wiNY|6>ug?TE;Hog zx9sz_bY;Wt86E4)8>PgYsSp=0xScgbnC%~UGWLbUe!|T`+5L?7?$hTyif-Ir}%k1Y=A;&y_O&Tv% z1V+w_MF;_x3tR7yLLD6ZVImNHSxqC2V7Ey19cDd`Tb#db7tXvyGWEWFD4S$Q${Pu9 zd6-LBBOICu&J1k#y*+Rzln^;}JlFH?s6X*EXqQ&aWy;W@Yc4>3{5fpGlkWJ?GtBVNE zBF$s(YFG*8^p^alc{jS@;wmxe;19pID1pz1hIM%ln8k!ldh2`ffDkdROn6X~*z?*8 zLNn@9e2|sl-D&}_#L>;yqDGrwZ2SCn+}Uw%(6&iWoZO(bYXQ>$_^iE!P8uJD?{AuY zMn09u@}R)@)ANoPfRWrbsBe#!Yh%SrJ+1$;ysK(NMy{;1U^{fU9{s#x_gn;Rfzw370VFf*W)~w~#@{6jWJ<=O>MY-ihl;7tD zAfWJ7l*K)|y2regDO7{m9qS>?G2kp~o-@xC9PTik{eGUP4!h&Sm*uyE^*4_3V(20q z1M?>8(Ikt|?>~myXqAOl11l0)M3%a{FD8oi< zQ;gDdUqrcvXSnnQ-KP@(^JZwrJS?mKm7nn)KUU(GcMiJ#XM4u)1V*oC^>?eMb2cwY z96p;WOvk4_+H!Sca8>Vc`X=`9-6H7UKs;5TSl)n&*B=e}7(Gt&!jwfy8yss?(G;7C zP+a@>uRB?w!ID@Dd*AWIE4j(F;5Uf#bo*XimnS)i;}@Tf2_d_ky{_-_^#yZC9%Z2s zsW?(3-h(fj?w6AbTA`+>ay>Hhs*YwgJCK^^0N}^2H>AxP^1Pf)&YJhF_d>#BUV00% z4Mczci2c}2-Z!p(4iFx4e+7*G*=kPt+8 zXjqt7sppfDFxrZl*#F$Fr|01nB3@Is@(wAQe(enqoV$mJ8@z~SlfnNx?pC;W?$u}% zvUDH71_>xna1@w=WZ&)rz^4iSA!M}I4a7qVQ5+3eyxskO5I#H`<-I=}efs!VP5%QC zz(jm17=_$=8ni%s0?B=F-+P@wn6&)h$w33}AJscVRc#{|H4Xo_LP(IlnLEge6rwvC zu(F!o4B_E}TgzZ2V*zuJK>+KK5W$OhchD(f$4=w0X;hhC*AGcIww&QK`y|(afDCKn z-^qsZKVben*mc0ev+&y+`$<5+WB+KcIrth=I(ruq<6YE{3n4!^kmv7Oz5SF2@O#WF zCQ0fz&RSf`!_;Ta-8d0QaMnHaB?rBHm`mTW^U)so_F|QC()xh9G<4o6#ueLql$$8P zr;hsT7pvb`2ui|kc0s%$kD=yyCRs@iu}X2Qyt})CBBlXCJ`>73yt@P>UlJE;NX?+^ zxcN`1{1%=J068mU&%P(E&-bjrCrthqXQ>sa?4!kpxlnqtET9KS2AMu`DA literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..8cf535aec --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.1.9006', + 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', +)