From 773bc9bc58776d6b116b8a520dccc5261ffcc287 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 21 Apr 2025 14:06:10 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 +++++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 213 +++++++++ AMR/datasets.py | 77 ++++ AMR/functions.py | 665 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9251-py3-none-any.whl | Bin 0 -> 10187 bytes dist/amr-2.1.1.9251.tar.gz | Bin 0 -> 10023 bytes setup.py | 27 ++ 12 files changed, 1393 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-2.1.1.9251-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9251.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..ec3a3a031 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9251 +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..0dd6e1f18 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,213 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import 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 custom_mdro_guideline +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..8b1dbb67d --- /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 import 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 = metadata.version('AMR') +# except metadata.PackageNotFoundError: +# python_amr_version = '' +# +# # 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 +pandas2ri.activate() + +# example_isolates +example_isolates = pandas2ri.rpy2py(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 = pandas2ri.rpy2py(robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]')) +antimicrobials = pandas2ri.rpy2py(robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]')) +clinical_breakpoints = pandas2ri.rpy2py(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..e0146c94a --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,665 @@ +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects import pandas2ri +import pandas as pd +import numpy as np + +# Activate automatic conversion between R data frames and pandas data frames +pandas2ri.activate() + +# 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): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + elif isinstance(r_output, DataFrame): + return pandas2ri.rpy2py(r_output) # Return as pandas DataFrame + + # 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 ab_class(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_class(*args, **kwargs)) +def ab_selector(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_selector(*args, **kwargs)) +def ab_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_from_text(text, *args, **kwargs)) +def ab_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_name(x, *args, **kwargs)) +def ab_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_cid(x, *args, **kwargs)) +def ab_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_synonyms(x, *args, **kwargs)) +def ab_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_tradenames(x, *args, **kwargs)) +def ab_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_group(x, *args, **kwargs)) +def ab_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_atc(x, *args, **kwargs)) +def ab_atc_group1(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_atc_group1(x, *args, **kwargs)) +def ab_atc_group2(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_atc_group2(x, *args, **kwargs)) +def ab_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_loinc(x, *args, **kwargs)) +def ab_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_ddd(x, *args, **kwargs)) +def ab_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_ddd_units(x, *args, **kwargs)) +def ab_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_info(x, *args, **kwargs)) +def ab_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_url(x, *args, **kwargs)) +def ab_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_property(x, *args, **kwargs)) +def add_custom_antimicrobials(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.add_custom_antimicrobials(x)) +def clear_custom_antimicrobials(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.clear_custom_antimicrobials(*args, **kwargs)) +def add_custom_microorganisms(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.add_custom_microorganisms(x)) +def clear_custom_microorganisms(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.clear_custom_microorganisms(*args, **kwargs)) +def age(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.age(x, *args, **kwargs)) +def age_groups(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.age_groups(x, *args, **kwargs)) +def antibiogram(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.antibiogram(x, *args, **kwargs)) +def wisca(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.wisca(x, *args, **kwargs)) +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs)) +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs)) +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs)) +def antifungals(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.antifungals(only_sir_columns = False, *args, **kwargs)) +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs)) +def betalactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.betalactams(only_sir_columns = False, *args, **kwargs)) +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs)) +def carbapenems(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.carbapenems(only_sir_columns = False, *args, **kwargs)) +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs)) +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs)) +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs)) +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs)) +def lincosamides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.lincosamides(only_sir_columns = False, *args, **kwargs)) +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs)) +def macrolides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.macrolides(only_sir_columns = False, *args, **kwargs)) +def monobactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.monobactams(only_sir_columns = False, *args, **kwargs)) +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs)) +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs)) +def penicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.penicillins(only_sir_columns = False, *args, **kwargs)) +def phenicols(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.phenicols(only_sir_columns = False, *args, **kwargs)) +def polymyxins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.polymyxins(only_sir_columns = False, *args, **kwargs)) +def quinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.quinolones(only_sir_columns = False, *args, **kwargs)) +def rifamycins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.rifamycins(only_sir_columns = False, *args, **kwargs)) +def streptogramins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.streptogramins(only_sir_columns = False, *args, **kwargs)) +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs)) +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs)) +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs)) +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs)) +def amr_class(amr_class, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.amr_class(amr_class, *args, **kwargs)) +def amr_selector(filter, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.amr_selector(filter, *args, **kwargs)) +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs)) +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs)) +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs)) +def as_ab(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_ab(x, *args, **kwargs)) +def is_ab(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_ab(x)) +def ab_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_reset_session(*args, **kwargs)) +def as_av(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_av(x, *args, **kwargs)) +def is_av(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_av(x)) +def as_disk(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_disk(x, *args, **kwargs)) +def is_disk(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_disk(x)) +def as_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_mic(x, *args, **kwargs)) +def is_mic(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_mic(x)) +def rescale_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.rescale_mic(x, *args, **kwargs)) +def mic_p50(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mic_p50(x, *args, **kwargs)) +def mic_p90(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mic_p90(x, *args, **kwargs)) +def as_mo(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_mo(x, *args, **kwargs)) +def is_mo(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_mo(x)) +def mo_uncertainties(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_uncertainties(*args, **kwargs)) +def mo_renamed(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_renamed(*args, **kwargs)) +def mo_failures(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_failures(*args, **kwargs)) +def mo_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_reset_session(*args, **kwargs)) +def mo_cleaning_regex(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_cleaning_regex(*args, **kwargs)) +def as_sir(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_sir(x, *args, **kwargs)) +def is_sir(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_sir(x)) +def is_sir_eligible(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_sir_eligible(x, *args, **kwargs)) +def sir_interpretation_history(clean): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_interpretation_history(clean)) +def atc_online_property(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_property(atc_code, *args, **kwargs)) +def atc_online_groups(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_groups(atc_code, *args, **kwargs)) +def atc_online_ddd(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_ddd(atc_code, *args, **kwargs)) +def atc_online_ddd_units(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_ddd_units(atc_code, *args, **kwargs)) +def av_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_from_text(text, *args, **kwargs)) +def av_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_name(x, *args, **kwargs)) +def av_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_cid(x, *args, **kwargs)) +def av_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_synonyms(x, *args, **kwargs)) +def av_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_tradenames(x, *args, **kwargs)) +def av_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_group(x, *args, **kwargs)) +def av_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_atc(x, *args, **kwargs)) +def av_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_loinc(x, *args, **kwargs)) +def av_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_ddd(x, *args, **kwargs)) +def av_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_ddd_units(x, *args, **kwargs)) +def av_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_info(x, *args, **kwargs)) +def av_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_url(x, *args, **kwargs)) +def av_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_property(x, *args, **kwargs)) +def availability(tbl, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.availability(tbl, *args, **kwargs)) +def bug_drug_combinations(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.bug_drug_combinations(x, *args, **kwargs)) +def count_resistant(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_resistant(*args, **kwargs)) +def count_susceptible(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_susceptible(*args, **kwargs)) +def count_S(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_S(*args, **kwargs)) +def count_SI(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_SI(*args, **kwargs)) +def count_I(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_I(*args, **kwargs)) +def count_IR(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_IR(*args, **kwargs)) +def count_R(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_R(*args, **kwargs)) +def count_all(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_all(*args, **kwargs)) +def n_sir(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.n_sir(*args, **kwargs)) +def count_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_df(data, *args, **kwargs)) +def custom_eucast_rules(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.custom_eucast_rules(*args, **kwargs)) +def eucast_rules(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.eucast_rules(x, *args, **kwargs)) +def eucast_dosage(ab, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.eucast_dosage(ab, *args, **kwargs)) +def export_ncbi_biosample(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.export_ncbi_biosample(x, *args, **kwargs)) +def first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.first_isolate(x = None, *args, **kwargs)) +def filter_first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.filter_first_isolate(x = None, *args, **kwargs)) +def g_test(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.g_test(x, *args, **kwargs)) +def is_new_episode(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_new_episode(x, *args, **kwargs)) +def ggplot_pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ggplot_pca(x, *args, **kwargs)) +def ggplot_sir(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ggplot_sir(data, *args, **kwargs)) +def geom_sir(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.geom_sir(position = None, *args, **kwargs)) +def guess_ab_col(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.guess_ab_col(x = None, *args, **kwargs)) +def italicise_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.italicise_taxonomy(string, *args, **kwargs)) +def italicize_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.italicize_taxonomy(string, *args, **kwargs)) +def inner_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.inner_join_microorganisms(x, *args, **kwargs)) +def left_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.left_join_microorganisms(x, *args, **kwargs)) +def right_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.right_join_microorganisms(x, *args, **kwargs)) +def full_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.full_join_microorganisms(x, *args, **kwargs)) +def semi_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.semi_join_microorganisms(x, *args, **kwargs)) +def anti_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.anti_join_microorganisms(x, *args, **kwargs)) +def key_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.key_antimicrobials(x = None, *args, **kwargs)) +def all_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.all_antimicrobials(x = None, *args, **kwargs)) +def kurtosis(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.kurtosis(x, *args, **kwargs)) +def like(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.like(x, *args, **kwargs)) +def mdro(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mdro(x = None, *args, **kwargs)) +def custom_mdro_guideline(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.custom_mdro_guideline(*args, **kwargs)) +def brmo(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.brmo(x = None, *args, **kwargs)) +def mrgn(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mrgn(x = None, *args, **kwargs)) +def mdr_tb(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mdr_tb(x = None, *args, **kwargs)) +def mdr_cmi2012(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mdr_cmi2012(x = None, *args, **kwargs)) +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs)) +def mean_amr_distance(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mean_amr_distance(x, *args, **kwargs)) +def amr_distance_from_row(amr_distance, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.amr_distance_from_row(amr_distance, *args, **kwargs)) +def mo_matching_score(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_matching_score(x, *args, **kwargs)) +def mo_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_name(x, *args, **kwargs)) +def mo_fullname(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_fullname(x, *args, **kwargs)) +def mo_shortname(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_shortname(x, *args, **kwargs)) +def mo_subspecies(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_subspecies(x, *args, **kwargs)) +def mo_species(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_species(x, *args, **kwargs)) +def mo_genus(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_genus(x, *args, **kwargs)) +def mo_family(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_family(x, *args, **kwargs)) +def mo_order(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_order(x, *args, **kwargs)) +def mo_class(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_class(x, *args, **kwargs)) +def mo_phylum(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_phylum(x, *args, **kwargs)) +def mo_kingdom(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_kingdom(x, *args, **kwargs)) +def mo_domain(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_domain(x, *args, **kwargs)) +def mo_type(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_type(x, *args, **kwargs)) +def mo_status(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_status(x, *args, **kwargs)) +def mo_pathogenicity(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_pathogenicity(x, *args, **kwargs)) +def mo_gramstain(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_gramstain(x, *args, **kwargs)) +def mo_is_gram_negative(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_gram_negative(x, *args, **kwargs)) +def mo_is_gram_positive(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_gram_positive(x, *args, **kwargs)) +def mo_is_yeast(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_yeast(x, *args, **kwargs)) +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs)) +def mo_oxygen_tolerance(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_oxygen_tolerance(x, *args, **kwargs)) +def mo_is_anaerobic(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_anaerobic(x, *args, **kwargs)) +def mo_snomed(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_snomed(x, *args, **kwargs)) +def mo_ref(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_ref(x, *args, **kwargs)) +def mo_authors(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_authors(x, *args, **kwargs)) +def mo_year(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_year(x, *args, **kwargs)) +def mo_lpsn(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_lpsn(x, *args, **kwargs)) +def mo_mycobank(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_mycobank(x, *args, **kwargs)) +def mo_gbif(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_gbif(x, *args, **kwargs)) +def mo_rank(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_rank(x, *args, **kwargs)) +def mo_taxonomy(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_taxonomy(x, *args, **kwargs)) +def mo_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_synonyms(x, *args, **kwargs)) +def mo_current(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_current(x, *args, **kwargs)) +def mo_group_members(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_group_members(x, *args, **kwargs)) +def mo_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_info(x, *args, **kwargs)) +def mo_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_url(x, *args, **kwargs)) +def mo_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_property(x, *args, **kwargs)) +def pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.pca(x, *args, **kwargs)) +def theme_sir(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.theme_sir(*args, **kwargs)) +def labels_sir_count(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.labels_sir_count(position = None, *args, **kwargs)) +def resistance(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.resistance(*args, **kwargs)) +def susceptibility(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.susceptibility(*args, **kwargs)) +def sir_confidence_interval(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_confidence_interval(*args, **kwargs)) +def proportion_R(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_R(*args, **kwargs)) +def proportion_IR(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_IR(*args, **kwargs)) +def proportion_I(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_I(*args, **kwargs)) +def proportion_SI(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_SI(*args, **kwargs)) +def proportion_S(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_S(*args, **kwargs)) +def proportion_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_df(data, *args, **kwargs)) +def sir_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_df(data, *args, **kwargs)) +def random_mic(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.random_mic(size = None, *args, **kwargs)) +def random_disk(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.random_disk(size = None, *args, **kwargs)) +def random_sir(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.random_sir(size = None, *args, **kwargs)) +def resistance_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.resistance_predict(x, *args, **kwargs)) +def sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_predict(x, *args, **kwargs)) +def ggplot_sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ggplot_sir_predict(x, *args, **kwargs)) +def skewness(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.skewness(x, *args, **kwargs)) +def top_n_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.top_n_microorganisms(x, *args, **kwargs)) +def reset_AMR_locale(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.reset_AMR_locale(*args, **kwargs)) +def translate_AMR(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(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-2.1.1.9251-py3-none-any.whl b/dist/amr-2.1.1.9251-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..36cd6634162087bb4f456153fac9e3af0e343a7f GIT binary patch literal 10187 zcmaKS18` z>Z$6znoCgz3>+N*06+tJ9h0@^+tT>7Apih%0ssK%Ppy!gGNXZkmA#d#fdPY~SF+Y* z#ySW5&tKGc;2*%ouMaCGNS#GUJ#hs@IP79S$cmfpAMm9!YZ4*ze6(t@`UL>s=B+BR z;~lvYI(GTmTem>tn(Gtu)PqsSh%I#*0XcyX`U~f1ujasUl0e(CpI}hU`k-H@1G68^ zM@(y}oy!dJ=fCJ4VsBC4Mc+4DJ_+aO#%KkyMU}f&!cwe+HtOA!UG5SXw=%AA*ff(i ziLuRO?Ps8ORLi#zu=;R;y_N;=1{GAZ#b$6CvfCK4SKyVDr7d4z*o-kN)p(!;A+$EB zihhLQymW(1B~DHwcxmp3X^0r?Zy@uGQ-7UD5%*$>Wp>PJ&?6gx!?GYZDalCZVBr}f zi;5^yPQlXU8d%-dqvNHq+A@q#1YIdaEqfa#w4jHiSJrf>L&TjgU{`D+prYk@0|_Es zhEsk3g`!CwT;!OnQz%=7WuUGU9d&eH|e#XB`^}&3x>C6)K112OI zn8g0Bf^LcvlK;-9hgw`=2G2b|=@;>NrBH-mD=A2p&XRwOu2B6`Q&**y#CT<1L5fbb z53iJ6$7_E0#WSP>-6EUIx1CKkiBUKRH}y>}y@0TBB5|-u<%o*Czrp)*Rc2@DiK$>6-T13bz zsW0FZiTs@!lid+V&0iDN>dbXXEEB=%>%&=W*r9fxZov-@#e0R{)MRF{L@R8vlnH&)g!JUmWM|B;cj8oEyR_x)cJs+g@aT`UdwgSE& zeL^no_OHW4{5VB5Qz0K)N~K!IiTL40HdZ2?R8309v6#P3Em6^DtP(o7G@XFZGKP4e zH3WZdI}}aGzyKD;CueqqwXFD7{2q|p)GDr-gzF6WeU|on=92H;VsndGhf$o!l6?=G zPrl$oQN58{XJ>A4-0B_N96U8i4SRDf494CNtXl0U6+HpXWhkU}nvP|puq$0<1qVVT z1-7g_P#>Orf@REQVl-HtObe=uBxz&=cCqze;;F0W4^NM8P)p)aZ&t^XMldxoQG@h#f6r^eDz$Z7&Ate#DOQ?xtEb| zf;&l6zO>nQK-OsSLb3E>umT`BK^n1WP5CqOHJDHD$`8X}5zyLqY_fn{7j#G)kiwLa z+T*WANd_mxdu^?8L^GK_b5eZfEktX@^pJ?-YCiw;h>@WP`Z~j-)fR{!PYLc2b#WQX zn)!v#?2-iEW!{!#v+iF(*xD1>J8Oym8`sz4+wDI}~yej=rcK?*#NN zEOxWJ;tnude)s#Q~CMT55ALM z0sEu1V)Q%^~oAyWOH4~&ZcHVm`7h%a@60RSm5e-Fc^My^IKX09%OhT&@Uar<>H z^v!!(O%Gxi$B<^3Lj6W7ZYHL<9xEs?@IXNs4Q882Q>n2gl!I+=DXFFYD-&jMfYQ%e zm#NO8KHBQ&!ZFmXs*Bsk1zF4q<@b59mStY>?IH{=b*AB;ojPcDz)z6ac6!6cb>-5& zZ__cA>3Kv>#ikH*34C3qy;i4DC2NACNCT#6Ki4%{V=5n__E`8KCQfZHJ1^*nPn7EM z(Kl9Fk+M~|9M4&rbo^M@$q1J5_r5HYdYf~tL+9aAB?qS9q{c0r?BnLPK6b?|t>#w# z@>tzGo0oeCsCyL-NfK8hE|3$9S@Q|pSlt4;>$s9#;Px{<6Ycs86YL&r@J?hoj~Bbi zLR0bPs+nvt!J*&Jt~nV=dFr_fIUQ^lhJf!o3fSfmgBMBj)D*>ZGn1xj)CTKw&Mi^F zv9M3ziSW>mRX|L)p$${az&V}MgWZZeJYwGAADUVI?&w}>EDohRiGZv*$;eAowU=a! zWg^LVTT54bagO&EqWWyyof|xa-^6rX40)M?IqGRwtgQ`aeO|Eel%IFyC@n6#Y{o~- zWj;x0hW=3lg^vuTy=vCj%dDVfR^w<`BU>>+y4JOXrz>F2c={!4w+`x?x2q00SOy<< z6l~#U`aUROpje$n8k5cCO8ym9@ufN#aW690L7v{V<9fimPFq|>%3uuh*gKmWdcGUH z6Q7U;1#xLPn-dOm=8=xM=2g!?wdn6=DqmXjd=qMScv1_INed}dD%p7*yusP6kIJwj zFt2Kw$>`ye;SP)j8|!n2S+rw|tY3q7pugqQ13xViAG8YV{9?tyX#JV_eSiG62+#1b zYjNo7Z|JkZ^b3F2UMzqfE_=c=6w2N43QCM7x#5OawTS^mx)x(>KEAe?0B!z^W(x95 z<>?yc-t}x)D~Amox2iE+1}}O+5NzJG5g;dII+p0CsXK6mDyf>p2%B&;Ova3Ns_e6( zm`A|NX5zg(i3n0aC zX@ls`jzMzC7-kJYEbG5`%I#S6pQ@DxuYr$s$2#;cWOcT@O0j?ibvWEQov}?kE((pz zJ9-GcBzDS#eGecq^T=csRy_V)>t&ia84Yj%fJQ9%zJ z$o38@6F>jAmsQBO-U@A+#Ip9zZWWfdup@CwQOf>pPH*zc`Pyr1pa2kf7V=2>t9zli zNaC3~S>a`}?6|nLUAbA^4X9NijxKep78UC1l^)mB~?%$^wS( zCI#hZO9ZHolaq|2#~XE|%xuIl2^h?D3eMEAs#X+YK&5-pa!CRpXie?~J>Y;clK6ad z7uWxVXOCrbb4|wQlF=5C?dAO#?BFo+^1CXH+GuJ1ihJ$u`Ld(5&@aTkBJmP88${&` zRT^9s&ZDP&IndvJQhow6@61MTA?eEi_7tlh-ja7dYIW zp*`a3&L26hn}Ot}FUhH|u==)lT$!YPaaK5%d7c`X5}&dYnfW0-)7OqY5B-C*fT-zlh^!`~a zuvsBZD6^n6#t^ca69M!aj_d`wI)sZYL6;I9?HhcCL~U}_?gA#QfB19+;B5@o&hSDy z#0X;Ua&;c49eCOMHmPTwZ0ojp4L)sSI2ydC)1W&Sh4wURgHb+)hn4gr)`$ z`JC5=83WQLl2p9Amk=){NQV57X}M&mibz^5*6o0+yyD(8@Nvhn+4w0o=W4;|e=RV7Px)s7FUDKoep zv;lcJHZ#kz4XN9|I+-S}*{yV%_C^EW#1mSx);KQoov#tKK=_PIeV@(m^gWC4S7h3& zUkw#foHldTK`#%4ISrbo>(y>B&-5L$Om4BF`!LoMD<(-RcjXp34eijQ4cd=G5+b%_ zuR=I|7{z=@uVOYjEk$BTyfT9u;$$Ax9VvC{BZckR-(zK-#BcQ73#n+0eQjS+pLg@? zopqGo4WQj>3h*Fad}+Lg5Y!|g=#>#=#(UgY9S_L%*{aK>%~UyFg+FCNdtz@fd(cWgOk}RDk)q(d;rD8-15upD$Tp;Rat2l7$esNbNYI z_jNAYB)Pr}p;Q~`lHnrkhYvEv78;#28or{~L`>Dcuw0_O`z)ahrrHd~+Y@Jq-50O< z{=S#u8?BpBI|gr8uY&04Ilg)m>DK)HL@Nyf(hT$NkKAuyj+;p~C#U6NY7(5JxmNfv zSr4=#b(WMc92lnR!zYUh(GNf4ki?=QpQ!hG<}>=KBuQ(CX|McL237J`+h!eE8Wpjx zRIU<@mf%AyYKgTb-ywX4NAl(`f!u{e*+?R1yrc-}Np3rR`l%qfKzqYb26O5Y$-d>HlwOXKVa&&QlGxX(*HsnL>&0tb= zl1+r-g^O>I)S`Js69E@k3bBGYfeXBuVG_7f)|iup`>|vgNB1Ok5^9YFjPiI*uRE1=+#oVWuBRmP8^i;a`VXqsNl5Ewr$!OU#k*f zpbBS6zkFBg`MLu0q|vx>Y^vhexB<61pkyNh}}qrB-)h{kK4aLl z2bu25gtLn>h&wA{S6x>-bVm^|S7-*#w}FUoji;BC6HhCTRBS%h$_P_kz%HRVZIhz5 zd|!+}1AVRZCquK?tzjPP_`VbxlJAWc(`92Ac6oS6OyH|A+m2$`@5T076X;giV>wum z;DK;~?aukdYq{s?j=;+M2@&e2-m6+;&1X-}K8hzsb!D$O4tDD<+X(Uo^34Uxag`0? zMD;yG(txcboDU@@t=(Fqt)|drJ6~f9Ef&+Jh>lu*O)3Pxg>D6Uni$>93nnlFzA2i# zPf1e0{>?yO!$hMY+RIrWi{E3qxR{8y38kmVH=Xh9(}}jVQc7CXnw2Kadz*PE)&k=Y z`@>Xnkx@bY&We*SQgIv8vb(K6m1_P-sMhDTTIb2IHd^&0d zsvO=NL#RhdJn=N+2>vv9O{`A|+8KkEEJ>Bk5@MoH&K*@FdS5r>OVK@O5e?N;b|rD^ zD55d$8$9*rpINUKiQd7n3zSLn7=l-LSx>SN7SvN8)JGw$r@}C23a*ayTh+6RtqGQS zc<(yM#C(igS`W1umL=+`eF%HJiGP)3F~S}s3ity{+7)U^P|83Z>Dp8M_j_5@?pHu} z8S=5Jstn8=xe}a@3QB4a*IsfX&>fG0zh#G?h*chAYhCD^tF%cRJpbtyWr{D47JE2W zRTB3ex;)yeT}ri(PyH2#El&Q6WbI6>@n3O0b2ZNQeC0rzwuy27$ui8bReHJgNb4w$ zuD6357K0a&yEJM5vPDKb}o?sJ9vypHm-i&HBSX_7su}qUHafl*~Go{#EzYjdmEG7aYswd z3DM4%`kpfZseRoz2j5Hyle{&n1LRc#Ch3g`K-nIcg=SzhcW?`xgdx4v6+7w*;Jm%a zpj&EcA>8=kerBlZoydpWf(5x+fHH~OL+@wH^i&&a0fsEejefeov|`Y~_2BLsAsn38 z-=0CwwGm{7_tjLGzsNUSqhH6H(w{_BUD4AiooG|=p_of#{waWeIPE~AVQbgn9an#M zODnYLsWJ<^9?pI)YpUvZeY}&*1s7}oK?8nF(f32Xa3!=AbAbn7JvZ&oU!=SCi((gd zgATR*6=b;7t`$8K-C~dqWozr5@b3kF|DQ9}7fv6fS_A;Vff4{9{#SdiKz;S3aJV;X`kD#k6?V(mZou2+2WvRdxX8ce$+%vnBps&j}Y5?Q)OU_Ja%>O~b!q%O2lm_f8j} zBVZF7F=H~%FU&Sx-ENr4{Hmn*M#P6=#pLCE7wBe98S$#;X>~t;8piCMKDjaseivSJ zt4FL`?ndEyNwlLqUXC6QwO|f|B!V-!0!1*%Qr16YVgt~1qkSG`f>MBav&~mQK^?lq z@g{sBfh0sJZc@3OmZcEpbopZP)RNmimG>lV$(Y~-Tgi!}ngrVP;)EhntGZFbK<9s0 znOUa$DShTT0rZ^J3KP@9W?Twnj`OLpsl`M=D&{obz;^%O=X8a6OlePM>P~Vctvkio zD@E=eNLzQL5)!&iE#v&m<-i0FIa!|+><*=0F zSk$+pjIzOLR;U^h+)yRw#g|1KfSlOe>?csJAX+Zmra{5=;63q^OVyGmnL8r7#xLj5 zduA9V=d*{kfkg%biHL0IsKD@_5QB780*@uON4k;7{f zyMWR02mTCL}C9sdI{5B)KxzA9L;?9=-)mU{VCJ zX`Tx!(QYCv%ZfE>5=DGuu~{51vq-T%%ZausD}@tT@GQ4hrj|S;muB;l#fWv-6H&tK z&60~+%g> zul*UqE+S5shI{XNRWcSc5Tg@*QKLw4>7Rg75z*E1WcZ$}?k~5fQT3@^_1WJ3r66r0 za-~3VFUuR6Prua>;+K}X7qbSZT>HG-okeHwGrCZaZafpB5(jFZT*S_2P=V>G$Nuau zue!8PH5;A_S>>y_J_Hckc`!c?Dr@d!g2Mx^Kp$lymD8>d{Svm6=4ZZn>K6olljmMd zw3_21?v#22OHz~DpX%paC*B&MN&$a<*7MnGrWGFMpzAAf>vZyzweJ_}o1q_UiPRTh z(GgVTO63~F?MW7Qj93o{*3(e1RR}@dhPf0tu<$Mkl~lS3foBsM(Zi?8kwp<01)8_w z&osOHsPl0pG86NlrvPSWpQD^E?~i;@UDMq!BsdYD3=r&2)9x&C5Kmc0(NZM#(v-8= zg~yMtt-380$b5{0TN8yN@sJ%Qs0moJ!Sf%a;(A<)8x~H*A>Ux)vWm1qAVMXxbsGmt zeDo^J_8uSUk@f+PN^+}|axwK!pd2vZr9~EmFV&H%;rvgCUB9>eKP%-zN3etlatcnr z!;&#O1;EaQVSj7nzvhkyDRQ;+e1kD3c9k?da;FV0$skC!ChgZGw_@g16ddddO=t7& zopSanJ6V!F{D}A%$96iu(R7GeeR;BhQsazYM`-?dz1Z1#2GcXrRfH_y8!^i9w>dc1 z7gBDx5$wwdalQEr`Ft;2TNV$QsEKzI z%FG8DN+;=tfX^=-s5uRHjt^#L?(Y$;zHUQ{Y+?gV{#@g}toyOa=lDT{46eCb7Zk|s z=4AIXIgdcbUI{kDD$l+xjCc^4$-Wu2&s)YSS2CcWP__Q%t$|GQ`{Lc#g2Pep`0%7$ zNA-cpES+_+L;81ttxYp?-8!K`OW6mnpcnL2wHR77`Lx^kJ_LC3dFo3}W%ro;*kh20 zi)}qD>(t8w(m->aP|oHrt!(bav@FP<$_w_%?e<2JVwriU!8mxVJh{M`EJ7fOYGs`8^S7Z7R`L;Q>c za}Qy4Axd(BE001h5D+8M9IV#itk9#fGh+p60#i_^rN~pE^f3?CIaC&}76pRrX+phD z^P?Hh?m`!6@|<juTugJ^DY%d8v+e0JcOZ{Rsiv&Kde;z(a_`V`^9V(7ItBbl@ zv?0MM6s@KjJMzU^de$Ri(k9mgsB;S5tXGkR7WB$kGttUSDw?*-bj1PPgKD|eE!NPO z=@CrZiS*HA1H*}U8#qS#w_F*l<=sVTo}<{WY%|L0PQ;Q4l5orV?d<4NC!02E|4Jd2ibs>`c*7f&dm)Te{l4?7 z;_Ary4PCMrk+7_=Az2#<=DWWc&t=N`mD?HS9Qlm?^5p}_1aIi*iP7{6(`g@Dj7PU1kTLM>)YT(+^@)ks_;4%|X1y z`f1~;NBV_olvOe!f^S|1wCFHr{i^v~1~}B--@H!Hbgn=`ZG0LC$f==p7 zmn!|Y4|ZVF+8Y%ie5Af5Vg&)sQzFDXNe`E>U3dv`vQ<<-cKH;KOFa~jpl~%OJ3^K8 zhy7T8UH5|Zn=4+EGk4PUpvc$EQo48zG1fvvOqz?ydk#eTm#+yFz-0Nh4Pnj|GqaTW z)Bx4?yg<)zkTq!oLygf|<4`72E;*{ya}|)@#P^39-oPE#0_J`IP?J5{RAp`SM4FN< zGd@z1BU+^C3=SSdNDyp#2)$WyBzgh8md71}@i}rYb&|r_n)&3F+X3?C1IX(d>B(260^}3VQbzU*@|Yv3%?_ z0h;k3g@Amx_Z3xWUBAt$`EOTZykRY0?Y7N#9icU!Ht{3=Sy-}`fz)k8q&NooSR|yI zhj9{B%l*c5CE{P;-3H88*uO02hEpnxBiwCP&L7vjOK{z|FZDa_Rb{Y=<+oN#$wYZm zg-TXM1kfwRiVDP@!+FFzjk@`;c~!!r5`(8p)rgIAyzaDTiEeF)bMVvJkV_r5@YF&j zpIxQ*uiJ?P1j9Lz_r@I@WIW#M)5;xpBcMK%Mq@d(*b>jHn0Oz4ttns{R}ZUYR$V&z z2%qzw)+(;99L!XpCJ!QwA_hZZbzQHI(*e^!uF`%o

6imANmqkV&axAdTOP)Er- z|J>z|F%8}t$$;^YBgnv4BI<NvouZ5JsHMhs$&}!;M5zuyt-u>oi z$$|Z$UYY#{#iURa1$aZ*b*igJyCDwq2K@$hX8d_eq-LofR-*%m@ z))-!WSYcwjnj-t#w1#lXG6(TG4Rf>j;C8g^+wcYQl@WsbVm|pdEM*W{d92`X#lcqxNBhWrN%P2lYH6WP?S6Yb}9Oq^6d5SgLaR5 zLnQwM1M@S;u)brKaNu#Wa*-W!7w!kDj%hdQa2y^fZz^pk-&e(iuqDgbegAyUJEYFu zZzm>!r|3N0f|mGnX%<`k)mbSS^TRQ@%xMjND0!q}M`G)DJP@z?{VI*U9ZlPuL}Mk+ zDddBr9Co0o29Y=KgDSyY+L~-Ciy@vbVaO`c`f>h&%6{I$5~qD#U+FC0PGVp?o|AtC zzMKmJvlem#gz=z$aA6q?G#atjPVcgP8@1ZzNRoINchI1z9pT8jV*SxK2J?-Y{pp4g zYn*fMsQAdtD=)Uw@syC>Q`7T19gEDxGWd?@dFu8Oy3XVLqlw+OQKN3@2J67zj4no? z{`o)bY=82-IWJz+#q`GL(HaL^N*k1(3hpM~@{QGXt zEXKh`_s=d*=TH7)qWQmfdm55rVzLmu%&`4T@DMY4r86stEQt8hK7n)9Av049K63#H zL3BuMzT0o_0Td3N+j4LU)bn7lwMP1_q(dm?)%S<|rCE2$m<{n3smqRyA39t<0ZZ)| z{8O1_)J11f4^aOe7a`RXD&(Jd!2e{5{}h+2gQJ11nY)=SgR7^j%LBq5DB$0jV)Rsw z3_<=lhCl%T!vDmiEGD9$Eb2BfX&=M{0PJ*32O%~#I<5rDK_Y5?fV{M^spWwN!NY-yMy&4Y@!<2f7yX3nnwGX1>AR9q2PF+t z{{Cj|dbz152;GBj$DmYt}d3(P8^=r%nJobuQ}e1)$vFnbR0oUFfUyRc&tk5nsPKW-V~^(-}R%% zPXoBVi$C2A0*Vgye_Ocz^w7VaqQJji|1fm@6Z}u(!GA*mfTF;#Kd!L9!2ipJ@K5kR zZ!-S|yZrGn{008s_nQA3{r@{A`5Uc@@gHRLKZhp&r2D51|E3cr{SS2iQsqCn{;8e6 vxz_#@*S{(0pPc_x(f@EZ29lBehxq^_! z_&pHI;5~YEh!G$4Ekd^=LcAl+@0l|XKe&hDMYr|5`F845%9CyRGx#D=Zt&v<;5IU> zm)I4)hy9Zw#uj4%2o;`lR$5#3T!Dgw^KpiEXGUB6t}B5){9napj)B0>0-|p{(J!Zt zoq3J|ny-L)Dwh`^VT#Mmu+-GCEP%?^hW9K0H`tMzT8cm0fAk8#l+UagoZ++)$cYNw z%xW`$+r4&I!%LF*W=M)bNPzo=3jb4PC#=`*l_9yVQ4y%d*ze2CYh zCIsWYa5F*j+d}$rM6PKl8%mqTKm2Rh5!Yp$ZS| z>GRfBMnX^_hfJRs`t1!N|L(VWtd&>tu&1HC7WVWD=geYYa~OJx42jP^QY}H_`WmWemP~GdXrk4>otL4-UbqrI|+2cyV^4wL`XNEp?Ln zgurB1MG;$utTn&>4Mi`(sW5gU7=bZo@aJ|M60^$e5qnEf0-zTkvqJm51;L<*2A-Im z{MhFfwtc~_m1I{9H6bq|;4M5|LQ|wmcay@~3sa9^+!tp;<>A(AQ(s8LooXZu4BQou#$1XNZD_bmrECP+e{VE#xaP>VQZvdkfHVdcoh%m*);gUVAJ>Fe{0;u4qcnJIE|qct<9CQD=xsyxj?=DKjcbM+rA zof2{9s&L!0G}d#>2~CUIC>apN2sP0hU0+Li+E^4yj}JCoPW0G+B@EWLCbFAp&19b~-|;nA zn(5KLOx><$pItc`I6F?0q|)AAFl6LnH(cQwI3^!Q zsz|Z$a!hB12ZAMt)_Y`$Kk>vOeHr@%{t|hveEjmPr7LOjg8%n3fSBVc}hc`nA`okR27v*HL4uFe;$kj3P~BGlE0- z5J;z0+RPgRk(3qRZe5y>Z`1@^)8EsOjiG56@ZYgWJA4^K!R3vcpTSx&N>L`ZiBMlu ze}}AZ>K>}F$aj2Q;>BjSoy{RlK33qEWBFMIw;DB}lmR94W5&JoB^yp=D=!mi=0uk~ zdfP_Vu;dJAQ+cBBF``xF%YLwF&-eMn{om!5h(9F94?Vl)rxe((54eeU?0a5!7_0W* z>PL1T@tU4VxYZHQ;PEYq5S~eBIzfvWPTY!u43DWY(XduxQr{)>1=ui|POk2LnM6`^oFO!b7L(o=?Lc>!0>@PGpa=-c@Y?e>?;oznc2OGgY5k z;B4UBn{W3)cf-tv_d%bAec?-)3M=CWrRfy-6)!vp$dPg=Fx*Or$zc9v^t+%W~!%FR-`H8b<9UF=5l>mTa zzxJEVnpG&W{N5H;*^e+)Y!)M5>;rZ3rdatzjCS<#@k^(vAROXFNu#CU3N4`i?DSA( zh2_ve;0TKK*3VRKJ={8w~VVsY{zXF<}Cxk@ZZQ1#%sy%nfj);5L%~HD4H_ROx*N1bpt87 zr-g|_8oj?j#k&zHUP7v;mVW)Xr@`&K*+tA;V&hVhVDGV2=qGiW#CY?^rRbxl&T$w^ zl=1{CW&!YZCnEdLK>p1EdX*H4VGru)N-&%20utR+;y9!Ue>=LLzLM(i=8bwkP zYM^^y6gZ@<^g~fUb)+$OKJA5R^xvHyxdGDE15B*0tw_MlU7L)po*nE3ryg~ayk5X0 z>eOMZKOMk;g-XfTh3(sPi2Uqbf9MtuDs(Z?G|b7i6H6MHMi$_W(W)J#Yj@PwB!6u} z(R>)mcakH(w?|d6DkTHNPFp5H?-*>GHox4H)IUJa!?QN)e8gxo-`{wKMXI7*f4e~A zlZjjI{KnlNM|w-BE(I^kc+R}xc(G1l9StgGekBP8)d94HE0?ANV*12CF)NJ|SG~SB z*Qv3)ZKZ%qPgep=xgQm zmK&e^j+`E^5`q>Cj|{A=$hj=OyrNHd*boR-G=D_j26NO zuk092yjS$pY*VsYo>;l0^Vhh-0sQ+q?_}+M%l9wXX7Ob6yJ68i>`B7^*v~#7+!k*7 z3}1yW9d{4HrbCnj9B_B{U}`!GuW2g-l__>C3*&oG9j7=&O|sVP zURnnpMs*x4YTlpr#opiymp~KOKx?D98I^|K(NvX}8E>>8OK9M9F6W8XL4#%s>WX>15?|FR?v{rzO2QJQ@z+BD|9N3d#Ue zCI4P@i%Asnz!+B(Be#seGY#V`v{e+TN)z0A68XiPzowA|QrR}pN1V*E1|2hXx>>+K<^m)zGyEtn$3^vAPE8-2Zh4sMe9 zJ$iJSb@aKc$+D|rw!sW?n8BY?#WRa=KHC{<3FB?Y_+lxoXZ zt62?u?Ttiay>Ty6WiRTF4c_!5VdTXwm^f~GVJ?Z7jrYY2D;Rzr`LcaTJ|(>Ii(GlU~@(m zINdt!!h@wGIdixVCbj~BM!cVsqlN8-yyu#=22GHw$dS#5)5{;N9$lGYraoy|Nhfey zhdUW-rbik$3;9##mWS4a=tOYRy=9pQLD^=am)@tKP@>odc$bYybF@%*S+R;R&r7gL zs{s=g{WG(b+z$MYWKHNr$3YW;WkqHHh(nGe&O*CjczODI`cynObS-sRyLn5 zJv>*|+k<6LjlT6^U z3Pq37APVHDC-HWOs_^vfzvDPy8Cj%viRIMAom;pUvu5lva3xymHzux;jOQiw+bu52 z)Z>yxSQXg-M0Towq|0A5xq4+;Mjc;xbbcO!7SEI*u?#kXnI{40eqsAf+<|`YLx$aG z*_Y^)w#5~s-3D(0%mjFwz_Q%tVS6wq^jPsFmODR$74h>s0WR31#dqXcd~C zQWNPVq0gNbRFX23tD9CNm$tH4|F^;O{zUeopuhVQ#=UD0>g78~A8;d(XVwHd7LG)``WWT)|VriO-2buYbcWacN-g|dD3M}v8x&U ze&No^g$vOy5X+_S{X{gcX6e<|)Ye>-7}sW;(v{NvtuWSe-C&kZa*jtncpAD&Y!B`T zW4$yl#4I{G&P6|MzREu~RI26{!#GEa-Qn$e1=SKl(EP{^KtS(Q`t_kK453;9$j2R0 z70!ouDf6yN3L47a=oL9~=@dB@;u)IkqZpdBME`-ze_;O~@QVE>2&K%|e@L0vSXa;( zkN5}DcgZ-Y{;h?0!$$ik!$vJJ#~Ig>7Fp$Q|HRy#{|$)#1DXH8R}nrjNE6KzH6zp} zltsKtl`Mj^53aJAxAOLrTEBXom8aZ$@$!D+0A;8Bg=fcVL{N78i@#Z9*;o{gd3L&; zHbqNDf0sJh!#9$a`W7mXDQoPr5|)wvn(Oksixz4ZZqBmIP-fl&n7o-(M}Kv(BOdWY z`z6OPL5(|ksLUc-kv^-BNPh6ar9D_>r7Wq`=7|rnvepbrIJ8yF>p_t$K~lN4yUq5W zDY5vn>opYe<0AQANpv*Jw3l27FuToEx9i1+G#tBH`sp~1wKE3@p%;E18`4K|Z~v;4 z&f2#IFuBG5{7SH{^2(cfTmo4(cBJ9Nc!`H#(;@I8hGKv31Ks%&^yo)mV1~$)(D0vDxr{nwa`(xka5)sy>`4l!Ca~}rl0OE*aRN3@0#PvFBHb{^4SRqb1F5I@A z1V;yK=p0q7B~xB%ld&Z)>M=AAI&bFJkEi2u4=RJFwcCs-FQX?(IYoboWKx@oOT~Hr zek4z(XD9z)?6(ZS(LVf5@x@B)`})npY?nL@GJP=AJF8~)X4fJlHp6nBxAxsQ*&z)Z z6m^%ACH9D!Lc2{&==NfDzdZ&`+K1)nW%qsN&;f2>D@k@>sm=3QD37(mO6Lxd{UCGX z7DxF+FplY@jQeh6-I$RABAGoy0}JSP)luxKTsSIyj9VQtHueGI7>_!3^(|waod}y1 zx(7$wcSK;LUg>+7f%7k}s1NtqKQ8Th_bzkN(r~P^%Sel39HYPX=zcLbB#`&eUnO)fW7?>Z2#_$t z!(K4PTgA0*T_}~O=o054b!1~5GN-%qkMsF?B4ZF+O|oE9{r-v4M#wz}A)vI9ls+W0 z0YO+*U!WGx5N`vM&gv{(*nUu$19-aBuI>3vC$xr}%DTC}_z#|8kq=2m;4%Z$|DvG$ zZ6S*32cI(PgrA6}b!6$`w3&KOZmS$UJl;0&ot1w8*ZJZ-~ zZ3c6q#(F9KopeJR$t#b{lOo3aAS*}O@~N_b91U>S7dvXB zgc?3KiUP;`or(w-6BH_ogZ84F$1}gqARM9X&bU8?t90!>;uGVrYN%O556%uXl1$tG zkH)3IU65%-U=>^vZVJ0=-;MoKvl$R`6~yy)=?K1U!;_tH3!KJfN)_C;3H#bYp$;>VQt}qU zqNF$P8&Y7i;+Bi}mIe1uReSTFcR+Qg7{Ca z(`Rs(>x@O5-mI3gdh>=zK(A^Or__3;^v-qv^Ai7*LK~v{tJnLZo$BlxowWw6pN39v zbCJXYk2KZSEZ2)#_J4lTUBi&sWi-Q-&iW7vXmM)I6F!!eOS_-bsko!R9W^bo3aVnq zH6j$DOGAOtU>`AeKRTW|UeONY=*?5$<()!f_YU5BF% zHzi5cSsAMVJR|YMFk{p!A1X`cXu;(m39Jjv4^fV6Kd*}NaHBz_%l@Bb_z(bid7MfF zmf8XD(@pqqZI76HbiXSL1K>s~iYV7x*~_0}J-2GAB=aZBl?xBiTN1)7-&&|=6rhTs)+F z?&IWI20eeOOg~7n$OMu8j5PJUGw(jEYtIi}V@r=)ga5sk$d#d*>Jofr7Jr>uhBJ%4 zs$Jaz$JLNY#Op=tiBvjDnB2wQ=hVtPzbo^1+ufwutvMnGH@L|hQ43?np;Cp1F}j6M ztI!H^ut6Ao+Hc4@6-2NLx(&iOTbo@VJ7I>x&itZc_c~ z{DQ=k%0`aji(}0sQyB>P9x@59PFh6yhL>3e5A;zvqzi5R2HCTcqoYUzU7tX@) zl8e0mn%|g;K??C}kp??thHmi?)8JGgN32gTZK zxP%Pz{rh>GvL)O^**`s;v%O4XWiA~D_E)f{ll)=#L}$cj<~T!q0ZFDEXWQ%IWrp>y z0r(DZIBW_Y-x8q!KoaGPP+YnzQm7RyBq0~qqXlMXYMB5o+pfat`x0pw%GP33HEG_G zI#{$nN|}=5FBc)PwGT(G2B5MWdE(4LqQXG zR_Bz}#$*O&tyVzf$Z44uQo+9I$_M2gHL#!{<8vRucW}f{_S3g+7w9K!)y{K zZ-J0RcRX;Rj}%f&Yr+kvM=-_mb)iLUm_=|{G?~Pxu#(n%~M!wkw#+OeQD&qYRE8$y$GjH5L-#<#$7$ z5pBZVk4nPLA9vv!5ACUQn7>o;kBxgCX>NF?u3IDh^jl4_B2GoPf{XmX-*Q$gi zrX6E{u&7fuvfvIVnLCnPtuWpdLncCN`0YJ3ITk-6vk~|b>{;`Iimn^c#Z=X(8 z;ZC=&seHKRjP~MmxINeWVWJZBkZgs}Rpjx<4s3j`b$f{oKl@n5@_Y<`cP7~_K#ni6 zl1I4V%YTB){IVg>b5bHx{5eu*?&Ym?$` zC@gi-H#z7mrN;tOkB;B!JGC<8foV$Ehp~j&*^cMr6BEU`b&0dJ=-H>{q7Der7|5hS z4EW<0o&4*M5lO&B{BD$ZKZ5lv?-vUjK>2Oj0+AMTt{jLlYU)2# zbeX)lV}zX&T_aK6U-VPqo48rJ5>1$Yw*bw7?6vP_!#HL;*=B<`CSS>;T9df67FeHG zVq_)|-B3zs8zWvA#xQz#<7cz=A0?ULq)&c^H}=m*m$kZr2xsM745Zw-$WKJcf5zg#e=IG5lt97as7|J zcmp`nOqZ&VIsm^byausQ21(;l$={g`p~>^ht1*>Ngs)+iNsP7Co$3x5khLbymn1Ua zS`Ki@s<3wqa24}nb?_sN#q(dW?a410qGjmtPR@Qk}EIQ zbbst>_k|re3`vPxIZCdXcwoqqzDn~@w!G-*eIO;((Y6Msfos8B_|+r>`k9P%#19k{k#PsN)Vth_0)Z7{h2Z2@><-4ep zhAaqSUabu{5)%Qmsr5J;v;TU`{dNIY5hCO*tn?0m7VCQN{a|393f6)p*(DX$-`y>$ z>9@;3rhK(A)5r{EQ@h7igBq^n_POH*+o0v)uMGyp2u95vvuZ}C_)BZJd2!g7Kri-N z`~!tI(2Ts6mwORzytzO9R6J-?jUtrE>x?f4HKkl7bE(!p3~mJ>;EASp`=ppQkZ;Hw zR92#nX@|KE8+ci`x3|qAnpDuF^{RK^Cb^>BiHR?keML7#Sw~ z)zE}ZC2Y52u^Y?_y!E&K6jhM4WXfscDsV=@5>uCS$u+Id<8;fr@bqK_&32y+{*1|4 zuYEk6Vig{_7~`a7@|cgQNpG3}r|L?s@e9-bqYn~CpPDlJyjK}Dy4jzuqYORSU39?l zuPPAYruTV~HSAJDe6Y(B7xsQwfuX^yV04&+WBkG)P*uX5E^pyJW9*9EWgwdOv0Ri; zmdP~@%ispFk&^XFuJq?-RJUS$6aV7?(33DhGW|0z3oQnA(( zfhFVmrjspQ*V0hu0aK}{G1R0G4FCgc!{okq&%ZS3siT{=*c3#4)@{U5vLyV{j#3T!lA~`}+fE!R7oNNCU{0NI!wdLEGyM5!T}_wE#Mo>1`H}Y=e*PdI z*1HP3NZq#l_stm;?S6Lx9T%u+t6qrF`;M{>`j+4|#oZ&Ah)e$*e?wlKWZmuNrnt8J zVpFKSlwMA;;%Vb%6-@6%<)C2+_7iZsM7E9O$i6A@J6g)UeW^JN5`&*YgTOD{p9F#u zpnyQ_L%3NG&Ymv}j--h1@gFpug8RajZs1QZruQAM<-!e?*E4n_OGwk4W~T0=&YD|Q_+GzcHz{K(YL@FlEw3%t>*22l2NaKL7QVb-FPmo z3M73&H@i4v0%2!3CC-Dl z6Br*$#P##Kw(KU8|Ck1%+}_Sd+(-v*MU1fF#gsPg;~iS388$;70dySanE(I) literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..cef2f7201 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9251', + 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', +)