From 8472daec8cd0e29b93ad8ece7e4ab8b98a1d7787 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 16 Nov 2026 11:32:42 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 254 +++++++ AMR.egg-info/SOURCES.txt | 12 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 252 +++++++ AMR/_engine.py | 93 +++ AMR/beta.py | 22 + AMR/datasets.py | 54 ++ AMR/functions.py | 996 +++++++++++++++++++++++++++ README.md | 226 ++++++ dist/amr-3.1.0.9026-py3-none-any.whl | Bin 0 -> 13450 bytes dist/amr-3.1.0.9026.tar.gz | Bin 0 -> 12736 bytes setup.py | 27 + 14 files changed, 1941 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/_engine.py create mode 100644 AMR/beta.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.1.0.9026-py3-none-any.whl create mode 100644 dist/amr-3.1.0.9026.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..24844f64e --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,254 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.1.0.9026 +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 | + + +# Installation Channels + +## Stable Release (CRAN) + +The default `AMR` Python package uses the latest stable version of the `AMR` R package, published on CRAN. After running `pip install AMR`, import it as usual: + +```python +import AMR + +AMR.example_isolates +``` + +## Development Version (GitHub) + +To use the latest development version of the `AMR` R package (sourced directly from GitHub), import the `beta` sub-package and alias it as `AMR`: + +```python +import AMR.beta as AMR + +AMR.example_isolates +``` + +Aliasing with `as AMR` keeps all downstream code identical to the stable import. Switching between the stable release and the development version requires changing only the import line — nothing else in your script needs to change. + +# SIR Classification with `as_sir()` + +## Using `enforce_method` + +The `as_sir()` function in R uses S3 method dispatch to select the correct calculation method based on the input class: `` for MIC values and `` for disk diffusion values. Because Python objects do not carry R class attributes through the `rpy2` bridge, this automatic dispatch may not resolve correctly. + +To explicitly specify the input type, use the `enforce_method` argument: + +```python +# Treat the column as MIC values — maps to R's as.sir.mic() +AMR.as_sir(df["MIC_col"], mo="E. coli", ab="AMX", guideline="EUCAST", enforce_method="mic") + +# Treat the column as disk diffusion values — maps to R's as.sir.disk() +AMR.as_sir(df["disk_col"], mo="E. coli", ab="AMX", guideline="EUCAST", enforce_method="disk") +``` + +Without `enforce_method`, R falls back to class-based dispatch on the raw Python input, which may fail or return unexpected results. Always supply `enforce_method` when calling `as_sir()` from Python. + +# 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..617d18f78 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,12 @@ +README.md +setup.py +AMR/__init__.py +AMR/_engine.py +AMR/beta.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..5f5ea32f6 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,252 @@ +import sys + +_DATASETS = frozenset({ + 'example_isolates', 'microorganisms', + 'antimicrobials', 'clinical_breakpoints' +}) + +class _AMRModule(type(sys.modules[__name__])): + """Lazy-loading module: nothing runs until an attribute is accessed.""" + + def __getattr__(self, name): + if name in _DATASETS: + from .datasets import get + return get(name, source="cran") + try: + from . import functions + return getattr(functions, name) + except AttributeError: + raise AttributeError( + f"module 'AMR' has no attribute '{name}'") + +sys.modules[__name__].__class__ = _AMRModule +from .functions import custom_eucast_rules +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 add_custom_antimicrobial_synonyms +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 amr_course +from .functions import wisca +from .functions import antibiogram +from .functions import retrieve_wisca_parameters +from .functions import wisca_plot +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 ionophores +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 peptides +from .functions import phenicols +from .functions import phosphonics +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import spiropyrimidinetriones +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_interpretive_rules +from .functions import custom_mdro_guideline +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 labels_sir_count +from .functions import guess_ab_col +from .functions import interpretive_rules +from .functions import eucast_rules +from .functions import clsi_rules +from .functions import eucast_dosage +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_morphology +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_taxonomy +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 sir_combine +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/_engine.py b/AMR/_engine.py new file mode 100644 index 000000000..cc6c5d9ff --- /dev/null +++ b/AMR/_engine.py @@ -0,0 +1,93 @@ +import os +import sys +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.vectors import StrVector +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils once +base = importr('base') +utils = importr('utils') + +# Silence R console output entirely +robjects.r('suppressMessages(suppressWarnings(sink(tempfile())))') +base._libPaths(r_lib_path) + +_installed_source = None + +def _r_version(): + """Return the currently installed AMR R package version, or None.""" + try: + return str(robjects.r( + f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))')[0]) + except Exception: + return None + +def _py_version(): + """Return the Python AMR package version from metadata, or empty string.""" + try: + return str(metadata.version('AMR')) + except metadata.PackageNotFoundError: + return '' + +def _install_cran(): + """Install AMR from CRAN into the isolated library.""" + print("AMR: Installing from CRAN...", flush=True) + utils.install_packages( + 'AMR', + repos='https://cloud.r-project.org', + lib=r_lib_path, + quiet=True + ) + +def _install_github(): + """Install AMR development version from GitHub into the isolated library.""" + print("AMR: Installing development version from GitHub...", flush=True) + utils.install_packages( + StrVector(['remotes', 'desc']), + repos='https://cloud.r-project.org', + lib=r_lib_path, + quiet=True + ) + remotes = importr('remotes', lib_loc=r_lib_path) + remotes.install_github('msberends/AMR', lib=r_lib_path, quiet=True) + +def ensure_amr(source="cran"): + """Ensure AMR is installed from the requested source. Idempotent per source.""" + global _installed_source + + if _installed_source == source: + return + + install_fn = _install_github if source == "github" else _install_cran + + if not isinstalled('AMR', lib_loc=r_lib_path): + install_fn() + else: + # Check for version mismatch and update if needed + r_ver = _r_version() + py_ver = _py_version() + if r_ver != py_ver: + try: + install_fn() + except Exception as e: + print(f"AMR: Could not update ({e})", flush=True) + + print(f"AMR: R package version {_r_version()} ready.", flush=True) + _installed_source = source + +def restore_sink(): + """Restore R console output after setup is complete.""" + try: + robjects.r('sink()') + except Exception: + pass diff --git a/AMR/beta.py b/AMR/beta.py new file mode 100644 index 000000000..df55d4f81 --- /dev/null +++ b/AMR/beta.py @@ -0,0 +1,22 @@ +import sys + +_DATASETS = frozenset({ + 'example_isolates', 'microorganisms', + 'antimicrobials', 'clinical_breakpoints' +}) + +class _BetaModule(type(sys.modules[__name__])): + """Lazy-loading module: installs AMR from GitHub on first access.""" + + def __getattr__(self, name): + if name in _DATASETS: + from .datasets import get + return get(name, source="github") + try: + from . import functions + return getattr(functions, name) + except AttributeError: + raise AttributeError( + f"module 'AMR.beta' has no attribute '{name}'") + +sys.modules[__name__].__class__ = _BetaModule diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..1c84065e7 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,54 @@ +import pandas as pd +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri + +from ._engine import ensure_amr, restore_sink + +_cache = {} +_loaded_source = None + +def _load_datasets(source="cran"): + """Load all AMR datasets into the module cache.""" + global _loaded_source + + if _cache and _loaded_source == source: + return + + if _cache and _loaded_source != source: + _cache.clear() + + ensure_amr(source) + + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + _cache['example_isolates'] = _load_example_isolates() + _cache['microorganisms'] = robjects.r( + 'AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + _cache['antimicrobials'] = robjects.r( + 'AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + _cache['clinical_breakpoints'] = robjects.r( + 'AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]') + + restore_sink() + _loaded_source = source + +def _load_example_isolates(): + df = 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 + ''') + df['date'] = pd.to_datetime(df['date']) + return df + +def get(name, source="cran"): + """Retrieve a dataset by name, installing AMR if needed.""" + _load_datasets(source) + return _cache[name] diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..16e4cc6a0 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,996 @@ +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 + +from ._engine import ensure_amr + +# Ensure AMR is available before importing it in R +ensure_amr("cran") +amr_r = importr('AMR') + +def convert_to_r(value): + """Convert Python lists/tuples to typed R vectors. + + rpy2's default_converter passes Python lists to R as R lists, not as + character/numeric vectors. This causes element-wise type-check functions + such as is.mic(), is.sir(), and is.disk() to return a logical vector + rather than a single logical, breaking R's scalar && operator. + + This helper converts Python lists and tuples to the appropriate R vector + type based on the element types, so R always receives a proper vector.""" + if isinstance(value, (list, tuple)): + if len(value) == 0: + return StrVector([]) + # bool must be checked before int because bool is a subclass of int + if all(isinstance(v, bool) for v in value): + return robjects.vectors.BoolVector(value) + if all(isinstance(v, int) for v in value): + return IntVector(value) + if all(isinstance(v, float) for v in value): + return FloatVector(value) + if all(isinstance(v, str) for v in value): + return StrVector(value) + # Mixed types: coerce all to string + return StrVector([str(v) for v in value]) + return value + +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 converts Python list/tuple inputs to typed R vectors, + runs the rpy2 function under a localconverter, and converts the output + to a Python type.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + args = tuple(convert_to_r(a) for a in args) + kwargs = {k: convert_to_r(v) for k, v in kwargs.items()} + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@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 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(*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(*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 add_custom_antimicrobial_synonyms(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobial_synonyms(ab, *args, **kwargs) +@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(*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(*args, **kwargs) +@r_to_python +def step_sir_numeric(*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(*args, **kwargs) +@r_to_python +def amr_course(github_repo, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_course(github_repo, *args, **kwargs) +@r_to_python +def wisca(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(*args, **kwargs) +@r_to_python +def antibiogram(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(*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 wisca_plot(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca_plot(*args, **kwargs) +@r_to_python +def aminoglycosides(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(*args, **kwargs) +@r_to_python +def cephalosporins(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(*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 ionophores(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.ionophores(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(*args, **kwargs) +@r_to_python +def lincosamides(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(*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 peptides(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.peptides(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 phosphonics(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.phosphonics(only_sir_columns = False, *args, **kwargs) +@r_to_python +def polymyxins(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.polymyxins(*args, **kwargs) +@r_to_python +def quinolones(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.quinolones(*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 spiropyrimidinetriones(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.spiropyrimidinetriones(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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.tetracyclines(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_class(*args, **kwargs) +@r_to_python +def amr_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(*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(*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(*args, **kwargs) +@r_to_python +def as_ab(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(*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(*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(*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(*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(*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(*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(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(*args, **kwargs) +@r_to_python +def custom_interpretive_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_interpretive_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 export_ncbi_biosample(*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(*args, **kwargs) +@r_to_python +def first_isolate(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(*args, **kwargs) +@r_to_python +def filter_first_isolate(*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(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(*args, **kwargs) +@r_to_python +def ggplot_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(*args, **kwargs) +@r_to_python +def geom_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(*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(*args, **kwargs) +@r_to_python +def guess_ab_col(*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(*args, **kwargs) +@r_to_python +def interpretive_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.interpretive_rules(*args, **kwargs) +@r_to_python +def eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(*args, **kwargs) +@r_to_python +def clsi_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clsi_rules(*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 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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(*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(*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(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(*args, **kwargs) +@r_to_python +def mo_fullname(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(*args, **kwargs) +@r_to_python +def mo_shortname(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(*args, **kwargs) +@r_to_python +def mo_subspecies(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(*args, **kwargs) +@r_to_python +def mo_species(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(*args, **kwargs) +@r_to_python +def mo_genus(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(*args, **kwargs) +@r_to_python +def mo_family(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(*args, **kwargs) +@r_to_python +def mo_order(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(*args, **kwargs) +@r_to_python +def mo_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(*args, **kwargs) +@r_to_python +def mo_phylum(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(*args, **kwargs) +@r_to_python +def mo_kingdom(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(*args, **kwargs) +@r_to_python +def mo_domain(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(*args, **kwargs) +@r_to_python +def mo_type(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(*args, **kwargs) +@r_to_python +def mo_status(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(*args, **kwargs) +@r_to_python +def mo_pathogenicity(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(*args, **kwargs) +@r_to_python +def mo_gramstain(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(*args, **kwargs) +@r_to_python +def mo_is_gram_negative(*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(*args, **kwargs) +@r_to_python +def mo_is_gram_positive(*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(*args, **kwargs) +@r_to_python +def mo_is_yeast(*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(*args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(*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(*args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(*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(*args, **kwargs) +@r_to_python +def mo_is_anaerobic(*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(*args, **kwargs) +@r_to_python +def mo_morphology(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_morphology(*args, **kwargs) +@r_to_python +def mo_snomed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(*args, **kwargs) +@r_to_python +def mo_ref(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(*args, **kwargs) +@r_to_python +def mo_authors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(*args, **kwargs) +@r_to_python +def mo_year(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(*args, **kwargs) +@r_to_python +def mo_lpsn(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(*args, **kwargs) +@r_to_python +def mo_mycobank(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(*args, **kwargs) +@r_to_python +def mo_gbif(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(*args, **kwargs) +@r_to_python +def mo_rank(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(*args, **kwargs) +@r_to_python +def mo_taxonomy(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(*args, **kwargs) +@r_to_python +def mo_synonyms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(*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(*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(*args, **kwargs) +@r_to_python +def mo_info(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(*args, **kwargs) +@r_to_python +def mo_url(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(*args, **kwargs) +@r_to_python +def mo_property(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(*args, **kwargs) +@r_to_python +def pca(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(*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_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_taxonomy(x, *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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(*args, **kwargs) +@r_to_python +def sir_df(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(*args, **kwargs) +@r_to_python +def random_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(*args, **kwargs) +@r_to_python +def random_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(*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(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(*args, **kwargs) +@r_to_python +def sir_predict(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(*args, **kwargs) +@r_to_python +def ggplot_sir_predict(*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(*args, **kwargs) +@r_to_python +def sir_combine(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_combine(*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(*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(*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..0e944d21f --- /dev/null +++ b/README.md @@ -0,0 +1,226 @@ + +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 | + + +# Installation Channels + +## Stable Release (CRAN) + +The default `AMR` Python package uses the latest stable version of the `AMR` R package, published on CRAN. After running `pip install AMR`, import it as usual: + +```python +import AMR + +AMR.example_isolates +``` + +## Development Version (GitHub) + +To use the latest development version of the `AMR` R package (sourced directly from GitHub), import the `beta` sub-package and alias it as `AMR`: + +```python +import AMR.beta as AMR + +AMR.example_isolates +``` + +Aliasing with `as AMR` keeps all downstream code identical to the stable import. Switching between the stable release and the development version requires changing only the import line — nothing else in your script needs to change. + +# SIR Classification with `as_sir()` + +## Using `enforce_method` + +The `as_sir()` function in R uses S3 method dispatch to select the correct calculation method based on the input class: `` for MIC values and `` for disk diffusion values. Because Python objects do not carry R class attributes through the `rpy2` bridge, this automatic dispatch may not resolve correctly. + +To explicitly specify the input type, use the `enforce_method` argument: + +```python +# Treat the column as MIC values — maps to R's as.sir.mic() +AMR.as_sir(df["MIC_col"], mo="E. coli", ab="AMX", guideline="EUCAST", enforce_method="mic") + +# Treat the column as disk diffusion values — maps to R's as.sir.disk() +AMR.as_sir(df["disk_col"], mo="E. coli", ab="AMX", guideline="EUCAST", enforce_method="disk") +``` + +Without `enforce_method`, R falls back to class-based dispatch on the raw Python input, which may fail or return unexpected results. Always supply `enforce_method` when calling `as_sir()` from Python. + +# 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.1.0.9026-py3-none-any.whl b/dist/amr-3.1.0.9026-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..4bda3b45090af9f7229aeacd3e92664418e6aeea GIT binary patch literal 13450 zcmaib1yCeix-9PQgFB7e;O_1YgAMNPGFap8?(Xh74DRl(gF6g*`S0EPcK46>_H{)^ zM|Vf&sj71#zxuMW6lK66FhD>+U_em6+3Tv11aX~1fq=M?fq)=?{wgG=%&4z#VQb;6 zug_rbk)SE-i8S&B-Nn3h*5S!QiH$W^H{KN z7W-vHw^z^WXfF14-}~DfGJheByhDphkG@aa^Xtyo(TR@>%zN^;Lg#lEjh&{FgbQey zQBgaW{MH|8=U#IVmm(!uVSM~rv8xoUGL{ABkye!s#WU&){&)A=Q8EraFRpcKZ0bXr zWfd_w{Lkz<+zNAoN6Ql?0v|*l%A>!t6Q5spcQ-0O&d$yhe0biByKJLQ%ORht9r+2y zK1ez=P0sq%SJk+S3{EmjS?XrxM3|MmU*B}2BM;VizBEcfch^Vu0O`WUd)Mo|#FKWb0$To$u6 z^X2pKr|@X+P6=2Ww(Oi*ppwDNrz^YXlb*SWbt)-Y?cS$*2bQOrr)o5H8_^m-VdCjt zP{Ux|g~D_HFz)g(`d+Xy6vxr5a~gG9))X`4JmzF_67k~Qb@)1Y z-H(PQ9T{BE%)d+2H-7}Ur>y6HNBXl^cYedOKV?XJlj6J{`kEv`X#LRlk%4M?N|1x# z)Q*tKUKrW8<;(d@Oq?(9TgQ&7gQSjFB%BlxNKy6WwYcjZ*Jdsp=Bzte1zAG-DkKs$ z21xhtC9*M|heNZ+blRSdn^#{tRP-0JATLDRaY;gL#QiwTVXo3zKr|-~{*p@X3`|R+ zFXitD>fW0+DrxQpK6k1k@t?}=X>eAkg3DM%1w>bq0gl9TwkN;?UX&p<5cQ)4tYo|= zp(SF=RHsC2)36dv*7~$l^k-w5a}Wt48jPu2+6K#lSvLJ&0Vw@n8dU<4n1zX}dM_3w zg?Xu?z{IikEDTAR^D%<`-{K+ChSK!)BX+km9aivpFz}?7y%5$B#lJ@Z@XAI=c!5E+ zB?u_cHr80}PnE_Zk^Zy=72sJz-~?F^9YBvc>sXrlVpcW{}MqE-CQN*WS zCzvbpOX*w961*P-0CTBXDJCVGEpbbMtgS@cdi3eO>$+dF=_7bMCWf)aj0rVRz`?1Wlklle)>_DR(p4jY`+ja_&XXmN3k`>>(())FzZ1C zYC=C^53F_->b=Df(uWA`m18usZILUz^A?fc`uyy|T9hBZbt3Ayd=ZhPR!5R8xhejp zf(O}*eFU%RO3Xo0{IaG+Xk4e#1iO~UcEt<1F*g&H52~%LC!z6Fi0e-26@v188Wo>% zSP9QKMUOuuVj;odxYUv4XvKJ$aF|{rHY&&N?eqc|HDDS0^yeDywUO|)f;%TkJQ{Vg z6ZIOj6t$t&-UFGofzde)tGQ@Aao84f87(ziwM)8ge>%K#K>VA_r)BiJ2X;yXWnIg! z(p>rdaDBVo1GIvZw(Ww_>W1(YyTO#}uKnE#u|v{X21zkBh_6Eh7Ma?j!P#yUyP}VW zO{9>pZ0K~3L7t}3*7%N;bhfi%k%vZ1AF@&Xte!gW(ZH0i;6WA9#Bb0j?Pg#Dp)fB^ zvnLd!2GWEcnMb_(X4DNhx43nY0uZM`)w+fN=s|Jk^>FxPh_Vgb;chS*LHkwmN^%i#vQsb=u9OSi zI=o3*17a`wFNlTji26N0&eIz=Fo($$mh-Li`n%YUt-pNPY^l>T@j9N}P-Dq&&@AfKFR^EtAd z0fYrh5rpnYJ>KqJsYJ-F`t49~WI9X~9}z$G^7|W_Ld!Zd7>TzZ1q#kxrwhp_)Z65; z_4&W=M^iUIDFYS5NZ6$5{&UzK9tZ9@Ci3i^GT%hq0mgM)Q8n&;9|}qPppq41xsHH zTw@_zN&q(6KZ;}S*|K3i9IUAmMN!WA*{4gxF@|6X>W$tcZ4fR2LB5;AKyRoNs}(~- z(DhNQfZU+)gH$4rrdXTIZ%~o)IKfs-1kKgc;Ye}3RbK2BhC~82u#-6Q?BO-3q9q&@ zkn(YTzSHK&NHlC>L;XDZYbs*jN(Q3I7!eG3Pd>OkvEvu)2doR`>xmI|ZozIT8V%i_ z_Lv=TcgjFamYZHkcF;L^U&}unKrTER5~}*WgHqdYGq@LaN*Yr)0}55U@Is_mvd$!o z$))v#Qavu9)>>v?={uS`#S`80*}}yYjjC_J+K^98iFueN|5V%$=}4b(szM}DaU>eR z(K?=)L4;r7r1;CQpVZp$RY=YyDyuAHZAR_&Nw-l-QfU-l=r~?%SMwrBpU|y-DY!cr z5K|hfmc4cZ&Z^7MIGi#kgrsp~nLaxFla<2 z(%QwW-*~>$v)HYSr}Tp~x4Z-NGRwuUx9a0uu7|TV=I-Ul=eRZz9(3X54?@JNgXO#9 zb#>eQqCxh|+@&TPt?fxY+gY>Ua5@!9uIdGr-jA9eG;OM1e`oo55;;C{Z!TdYL;t&60QLdBCZHf7SzsU_@c)pD?b#BB?LTBuvK4f9(G5AYgoFObyQenEtLPHeEFHFy5 zeiK)6&jar{miBS2p=^5YIq{#5B()l4;pdfrN)c41rNSqi`0G{35EtCtz_h2Xp!f(EYcS?8C6+U^z9AJgfm!7siET%XTIMP zLO*fnb(3fp@0XJs$f_KiCbx;#qc&-v89#;>#Z$u0XG@XjSzSUYeyhFwKaXnJF**nJun;&xNlM|9v(p z$&||UKWF0mXKVAnZH=*^v!RoTv(x8{M5)R}tTCZj9SC;(NI^j!Tn%WRwWfW@b z66GeP!{iUh@qnCQI<_ph*cYh$Lzw9hHvVg*b;><(V~46v;Aa+=_#kb^_QtjbyDoku zo<>4ZrcIEUx;mPZVUsbEO(U6CC-s#^Vq$Abpvwq@c8Td|7*-Fq>}GE>#79oLOddp9{3T+2inI#BCfPQY z4fP(DDLv&CBo}|nWcmWnX}Isr>|*hAIsnP(O$p=vlxRz&!ba+RcTG1i_8nz_1SnF~ zS|E>+gYJ%Z;lC+EHxClwvVq4^)caVHPp; z1Us6Er_F6_1<4t*=jotKD2Uy@p2TbGKXA=`2#MZGXhvnjw|=V%AOBsfMS=-GXhioL z-$GloLCkAM!ny7{Me$Wk^+V(&jCT>z?BmyE{a%%z`e@v2#i8b-nR9B<8&`8X4!k2- z361Ir-;Qm@e_xAlbi9_JpNp`r3j_q^AIf0rVr%4VVQ2f-VqC~lidkbv^V@o(4T3N~ z+Z?oTS_*+j$?bXoyUP=+<6D<;Kmmj`uM|lVNO>&LU-WFn#&=CxN{+}YO<;++7EzSh z1sCinl1k*;Hae^ns};>@uL6(dQxC6PZJe)Z8M7u*C!%{8*~OQLK0G#RZ=!A5CZ0z( zkOMI{`g>M0rQgrSd-~Hd&cJU4VkEX`-JS#I&z!FaoX!Fb*@kc#n^v8Sfa*gJMGR?Y z@;uR?1n}zK{o228R8}%%o7fV+?owK%mZt*sV^)95yElDZxc&yXP$)B<(KXLI+%bs7F9bCfvvG%O9DxnbjXuxJ4kmdtL7iv}|nE=OEcakH-Jxei>|v z3gUO>b_xmBSg~1jTl7Rd@#yNR7m@R4uLOo4Mg38??P9U*Fq$rQwa3S$aT^yjbGn6c z9*hDgV2{2xf$Jt#-k&>+SXHl|dKr2Mdg@-ddn~Qc+&L_z+KgrO#MYi_Cyp&deN4dZ z{Rq^%kw~g_8%vU4S#J_IK{)$P+spC{@3za_0&ch-{Ra%|D{|IMO2-IX|4P_lYr2$quSouqS zm-tV8!6No!&CLez_3Y05@5oj4;~daSm)hDQb|H(upj1f`U1XCw8$vRyf9Kh9=c?He z`WTL=*|Dv>d|vj&{D5yixpQy#O6hqubD_Cnq3umDcCjMBal+z8H0E4wx-k>Mc01_2 z7GcCHf?yrJ8%*JZHdJPq8nF{@QiG~8@%mwwx%PnGTViYWhFrQz=C&}a0hVZi&D~ZZ zHDTK+k+FD{cAGKZ=whnfALH{_xRSDhybJnFi?hPRWMnISQL~STl^&8|fNFD!4X9lg zpg4{yU?h-7^j1Z`h%Xv(IZa=@pJr^Z>*u?yTI#wL?)FeLt-4}tv3v5}->5}58|;1o_%udcSOu$(Ym2Tv)FeY@akur=S-_H30UzEPv# zfB(E$J4jdr`{OSDxq(TWQNYX;UgY^GXKUkSYjXYqndBEdDZK#PiRO`6+G9iBY?=HL z%>47)#YTc)ZH1HDT-#Cgwl=5U+QG?>5~vH{8sAK>BhJ&?0R~ykltOmp^EDkml;Ooz zg;{P?%wUY3Nkq+5Wg(s%@$R(CR9@fg;?wnG|SSVqWW!w#R(W?SF0GAU5>IIBcWP8G`4EGgmZX<$S*@z!l z9*ZPB2IfoH=Ll+I14|N;-{(Clf(mwN5_n4?gl)c}KHJz8D3LaN>t#bdAE)1=upaS6xZkFc zh1Hp|_6JXn4-?tj@@kB;07u0e@ygqUii4m@cwL^ zI+=t^l`Y`XgHUt=?{MoY57MKLTmB+u$}Qe(QYvc4C|=po519nPz6<-jJ9R>78!@r% ztbH5>(STrDB{*tey-d|U$y1y1ShM=O+AVbI{`H@#b961nuaLsMP482YfCIY^TWETKD3m3^4IG_@zA{J%ZZJZ?A!YyeUxS`O{|IsBh!`XOA2 zOa4W*H;TecLcIhmD4%F1-ZJQzK& z`xT4;93e1@pKos5>zr`DQ@>YiAWC{K+4$zFif4GL7CkDYZSey&Wl`MCnc#v(4TK4k z{%9CbC@NkcqSv#1ohLL2GtX3p;QIV;n*)Y6uUXM;j0gb3EFAPK(4(8=w-%j{>&ujw z)sO0m9nF03Exbx0T}r43JvP>CQ?Z{4feo>7!2A1gUs#K(0lcQ|e)QC7Q*@%rm0y=rWqk%o%HyMUNp8-m54>di za?gx!_y&~}ZE5}x7LWtj%DiJN@Dp=1yN8&GRiU{55Tbu-R+4v&5?W%qe0CoMytF*U zltCi7xEx?=8wQyMG>tdV0V6R(I=c@5D=kMeWq=F4hpf+yrYwl4fg-8MEFW~%ZrkEv zvYn&61XMH>=J>d+uuvUF65ODXIIeoaQIG{&Tb-?`eu#lJAC4srm%3&}eISuYeDb0h z7Kz1S#oUJvwJRe=7WzJ}8e4+?VrMyHFen+DBuCC7zKg+3ppmiSUqB4wl)`g=cc*^F zRaG-4OB^AsrXhZ`rmng!pj1FQ1GAur`@Y@dmsU}a;z9CSycsNrz!U{HB266W(pIa@ z!qJ0afg7n8z;`$wlnMgeS05&5iT)`{D<9B3pz_Lpgb1S@=dQ^sA9U<{ihg#0=x-bk zn+V_l8glsu*gIWyl9w70OUgs3+grS-?a=#|odQtuACq-@WLIjeaR}c>U29JRlurk`tc9hd5Ckp*bnVsOhE%yr!j>LQEdD7XJ*ifzZ<| z**PDi2LyZ2K{{;LXqWb-@WDvB!s4^w-b5A9tWsDn^S_-(SDIt@k=#cOx zTx%;PouRSwYOtt{Fc{)VyAC1G^V70{!hVPk&BcV6Ts9Cj<<|zEqj46-Xzw**l2_6X z1RP9vkX`eV4*FNd){MXESSiBnS2bSaeH+&N1A~-r)u0yiBw??pGomXb6~IjVEw~=b zuIK57o>^$HEZ<4?9cA;U)qwHET)c&wIgD%yV}ZzXIBU{Nae1v`KKYI|mC%lsSTtKZ z#fU4z6nHXSrV){#GPMTc=o5LS;>5Pp_Ag`NVNuJs9yZ zVnT|Crf#w4uUjV(3AyubOttFi5UvQ22f+cdvCFH3Btm6AAaed+4tj^Mhwu?42uS)a z#h@hCViDtd5BHUby@S41Hb;lX{Z;4N_>K_sI_2xJ#j&vt~{}QjV%*kpqgzzo* zki0qjmsGx&f_!$iAAF`?&|w;XcUew`fPX+G1K*+gF^k*y1b;x_Q7K*1YH0Y&J%r)b zX!gV%lsa@t^7vw@xrBh8$SgtW;ID`m z0`n#(GrS-t<*hwuz-e06j@B zZtQ$pCyE|&pwe}tm52)kdQo+9UGW}ZrR2?P`w#+Jn{>X~gjbPn0%58$m&ALvPOEKM7{^Kjz6Y$J^;myx4rT4y zwW9AWG+l!%Xr06M1IA~O)%~`R5exLmz4@79G?-862P|YXi8G*k9MfbuKx2W}pV+ie zX3g@r`YrG&lImf1s_n;IkT`DUUgSc<RZHTFK)<@nwvMTIgS9N$OT_6_;t^VB^- zx=4Y%{YgUxf5OItKqG)4EG8a-`QOcn5yYmcLqUG3vgQnlLj+jGN1-mzudj*{$J4+Y z;Q9vJt)O8rBoBD&LxOqp1)9Md3E|3E4VepV&@agjeAVg=1CK~=VB}z#a6Fd#<*w`i zL1wnb;clgokC0fyXB97=->(NSqdu#X@Y`gG_}M(H3_lF;A9>a!wk6K4(o7#> zwl-h2)YaAHV*LSC6LxDim`-|;qbIBL0DmeTnQYJ%WHzQ(>{-`(&K2*)Hva2vibeeE z%;O=U+>e5l9+MM}@%M>|_bPt8LY%4al~Lwv;0qJqg{o%Y8%Y_jPWc)`*Kda34I75u zNM!zuk}x4mcyM{es#gYL>dGe@=66|aSP4DaJ~6tIH@fMqeSYwde%Xkj=~G1t{C@^O zbGQuPHnzHtsI!!@dXBisx`fOS1YoQN?`L_bSf~+Jr;oc^w84=*F135%wnu`@H=g;R zJW7JEva&Rj^pp+OwtaYbVslJc0=+?)(J|TK?rDURZ=yc5g!RcDI;r|s1)o?S9Foa; zYYDwE{b|_?xREjTq|}w;T$x2$zto83D)Uzn2fFJCXY=HeEf4<|yL>&bc*NYMiCF}Z zlDumnpI_!%n`DDrW>hsBS9Z{$4%_7IvTi9^=;Ri;>mv2K#hn!4J_{BOLd=&q3ZaUu zw=Z??jTeWxS0VJWSW1ITlgv<66;9|$w*KPfa~~xk75Y?qcvevSYuOVjEhr#it^xTq zBU~+r_W`T@V@cpcAp^#c%AYWs2JlA z=VK1;Q1dHnXNu-KTRB^uTu@_Jd(5hO(Jk)-HRDN17!06?SAf6kYwT1H7+#dT&$11zM=p`js)=|;nhdbm5C2k0)yVczqg4+b@qzmk&>Nu!4H ziztLK0cM2!rGTiAh5CV;=2!x1FY1UuUS(?@adhv#)@I_H$Y^#QX0+`#yxds zg@wjors7`Tr}-m&=(K8Qd(&;kW}xur#A8Dg^*FW5j|5>a zjSfILjuP-I7fM1-Y5;y*=1at_nlzhIiM*|#nAyC8q$P&6N3xmO2oI0S{u~S!E20KL zu2<}vDe!c;M7Z-iKPGG?kwOy0YcNXg@L(! zwALuJW3o!d^${BqBl!V#H0npI*syYlCe8UxrlnwpLQm?$z3E*e-x4#!(MGBm7uC&f zRmB*v*&Jgrr~R<&n$m@TzSd)YK_^L5Prli?U0GaWLq&G~Vl<_=M>DN7klGKEykDRi z@4$DFL@7mP7Vr9qRhn`wfKi9=^HOYMV&;LGEQ-^+P@ciEju7MQjc4uR^5MBar~~KA z?DTsr2Tn#E5BqwPV83Aoo9}7f1}P5SRiKoe`!>qirIE3_{WM+_mFvENv3PKo(vMj^ zi9c>J6m`Q&VUi38oQCV?QIBf}q|oRHQ6XK|t+`$wAY=tyo9^gIW`uiS9&&@yx45G_ zw!r!x8KZv3tLUs!&00Bu5SDmqDyM~vK6rMCuARc%8>K|-Tr^CtY8i-M2fj4|XDu>` z;_Y5_<$6e__}$>fS1Ti^rSs0 zJG;lS$Qp}vnu0B&yQ`Wmk2sf9+)>0${uc+kOD1x2jQ+af%-}ydl%l4YETXJvRMI`0Hs@3oyXR=Kb`_J(Uh;*oCS)qfI>$&Imh+C!aAZ+*=HlMVAT~vebrt(dVF76~oN54# zQ#H`2l83u$ZvSoP{5nC~YAD;^;n_vf8}rx?vU@!W}+jgS^r zJn`Xb{cqh|0=)dxn#+@WR-rt$?XkAMh}3(xuYnccaY-t_OtM3^__ye|G06N{F(rj7 zc{vT^U%RN#B5fO|PP0;-u^M2)CueWGFYiiiM2g<9pV+Fd9&lDOC2yYWq+ z=(lVFA8tFexU2OPj&QgzBFfzm#5pvF_vd@5gwVvPBh~k6^c!rHYg|$9_j|dbXaRM2 z%qs8eTz=fmYwj3qM;~eoeNO%Yk8T7@O?FDI!gAGv5s^lb+#M4X zhyf!)nRyU5+09lZ-d5(6`RcNtP>lkq=$Y#N<7BMf;k(nDNLvZauEm@7nwlHvLF-zSo)#s%5-i&Iz?B16~tTh;)2UYp}n*egr_ru`QfEQn<%Qv3d z^?sJ7iS$JY_9InKAZxbV>rLv1vh-7ebWzOL#}K#*b3;C}=wsl3=eh^#IbZ6+X=&=_ zH0>aV`^H?8&5H!_VdkVE z$A+`o2CS)5@=SE-)%x;b33LlkiXXm6FQ1fDxHfqRX+o{3qsC0bN~3G}p>576ZN`;x zi3^!yqakhXC~9bAfa^-eflN3l6$x~yaG-f>_{@f%EE@A#)r`8dPhb*zZIMR7$6oD0 zJ{4Unq|>-hHY+SrpE+x)eZYEd15MiNDDngG0owh}oEy|9WJ~0y1Q;74j)v<`%nmHl znZwo`TMd_BA2(xMp437l+SSOV=nts^SBn^3khmW5$lPu9&{m{G?%SQ}9Fv6O@M5yV z{&%dP;fFA~2)0rlk=h?`w?FDerpBe2l-s>aRKgNhD5;(N?P^G2qiiJG1Y7B}N4%}} zA=gs0i`Q(dK!~CQt3`P=6ckS4*+`^Pf<_FxyA9u58SBTnKhQ3%2YZf&Q&futl12XED25GS;$P| z!u5uP1IE{EsBv+kyv(ll@0rz!ynq-a_vW=`gyz*kJTlo1haU#BZV^pf$~2a4kpci1fv6v4RlWk zmIprFkGaFQ)y>m>>GnlcnI@hLxj#0BM&d;TOB$l;%ttK0)IpNt4lE+O5UoLzLFq2y z39tD&4``$OQplNNy`b!6&K2k7jl3HUfeT5=*Vkm2FL|gn2d90Mks;3;hngJlz{T93 z9985^@B$61gYvvix`=rNh5Kn^9>rmyymJ~Do;{epLBbXc*d8YgW+QQ9rV_SZRNV9K zEhnbs8CFYU97o;moniHsIfaT8;fL5Ecq2x|wxV4{1FnrI2fyACaEQHsSG#J2!QRe; z2Db-3JBP#Hp0KxD_gFi7Shwa<9=tTkY=>K#pAVEXPAgH!1s`N69IR0EkYL<)=QjrxXX3~nKgnB0Dw z3+%h80ZJ_vj)`;VE{JJmH+WTj{7cg3FN0zPb>`{Yr!k@P`6m2N28D*Cn3ybNA2Zx% z_y=-Yw`6)5fkiGo?+L6(hq@?>;E5cR3{s2G@umB5&5uUkeNB!v=C?F5pfkwhF!)#^ zbzv~&CA0V|(j7az2fK%h#74^a4#6F@)!|-eSh{d{w&;(4H%^EE4``op7m&})A_(Pw z+An82dwpvYR}*UnXLo0(JH%Zukbh@dz~yOg`^+-Me&*uGR?D>7S=m=Ub+mee&NfcmF5LzWMZ7dnP zO;teKym$$%zQ5N%f%3A3ZoY*__5+hsRRn)JiM+K_F`vw98?tVN|^- zH%@;^#mLt@Vg8Nd9a5qDl2_7(ztHoyWtba5vtTUdPDtA>R@WER3w8F8hAhEm;J6T9 zu*?xlVmlGTK|Z{=Gd6G6GVUUl;FDc^E*4v>&1UL2Et!O71z^lV3SxpwfVIeJgiv~( zT8>PHq1i&~t3Iw@$nNWq6c27oVg4lw)#3d#fn;(u^UT8mmu#m-DfPO)4Y#@RZ^oW6@+YF7+LVVah^_FT!&t{VbE^)!7T!KIR<<47wYExzkG;B3L;S zs5xIacvW9HpVrGlTO|(ShB!g8^a=G>oFdKu}l#8~| z`Pj_WC@4_dx?-05-Q?KmEGYSVeXBipd--|5*GQ;@vXVhwTarK#g@4zrh_=7u^V2@F zeSROED`1N`^~07Y*p!DGq(MMY1{4ef{Qvzh$mi7m_p8wVuaCby8uEAW-}AEn0|fyo z^v8w%2l)S_XaA1%VPq5Kv zT<5P*|23xbujv1qPx()D{HH4Xe_hMJ)BRml{z=Em_#f#0TVwvt^>-!sC)e12;`%pT o_&ev{HQ|3b8~rhv{=@$Lk3uNQK>npnAh4gC#a{tQmcPFJ7hdqWcK`qY literal 0 HcmV?d00001 diff --git a/dist/amr-3.1.0.9026.tar.gz b/dist/amr-3.1.0.9026.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..805cac2b72fa1646c18d60382acf405b1601f69f GIT binary patch literal 12736 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