From a1b7aea91e91979afe68a6663230fb81e9bfe3a8 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 24 Nov 2025 10:27:33 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 +++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 213 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 880 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9003-py3-none-any.whl | Bin 0 -> 10343 bytes dist/amr-3.0.1.9003.tar.gz | Bin 0 -> 10188 bytes setup.py | 27 + 12 files changed, 1608 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.1.9003-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9003.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..710045606 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9003 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..3f906f72f --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,213 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import custom_mdro_guideline +from .functions import eucast_rules +from .functions import eucast_dosage +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..bf9cdc0f8 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + except Exception as e: + print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = robjects.r(''' + df <- AMR::example_isolates + df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } + }) + df <- df[, !sapply(df, is.list)] + df + ''') + example_isolates['date'] = pd.to_datetime(example_isolates['date']) + + # microorganisms + microorganisms = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]') + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..9196b3660 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,880 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.polymyxins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.quinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rifamycins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.streptogramins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs) +@r_to_python +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs) +@r_to_python +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_class(amr_class, *args, **kwargs) +@r_to_python +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(filter, *args, **kwargs) +@r_to_python +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs) +@r_to_python +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs) +@r_to_python +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs) +@r_to_python +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(x, *args, **kwargs) +@r_to_python +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_ab(x) +@r_to_python +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_reset_session(*args, **kwargs) +@r_to_python +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_av(x, *args, **kwargs) +@r_to_python +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_av(x) +@r_to_python +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_disk(x, *args, **kwargs) +@r_to_python +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_disk(x) +@r_to_python +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mic(x, *args, **kwargs) +@r_to_python +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mic(x) +@r_to_python +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(x, *args, **kwargs) +@r_to_python +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p50(x, *args, **kwargs) +@r_to_python +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p90(x, *args, **kwargs) +@r_to_python +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(x, *args, **kwargs) +@r_to_python +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mo(x) +@r_to_python +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_uncertainties(*args, **kwargs) +@r_to_python +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_renamed(*args, **kwargs) +@r_to_python +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_failures(*args, **kwargs) +@r_to_python +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_reset_session(*args, **kwargs) +@r_to_python +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_cleaning_regex(*args, **kwargs) +@r_to_python +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_sir(x, *args, **kwargs) +@r_to_python +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir(x) +@r_to_python +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir_eligible(x, *args, **kwargs) +@r_to_python +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_interpretation_history(clean) +@r_to_python +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_property(atc_code, *args, **kwargs) +@r_to_python +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_groups(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd_units(atc_code, *args, **kwargs) +@r_to_python +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_from_text(text, *args, **kwargs) +@r_to_python +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_name(x, *args, **kwargs) +@r_to_python +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_cid(x, *args, **kwargs) +@r_to_python +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_synonyms(x, *args, **kwargs) +@r_to_python +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_tradenames(x, *args, **kwargs) +@r_to_python +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_group(x, *args, **kwargs) +@r_to_python +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_atc(x, *args, **kwargs) +@r_to_python +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_loinc(x, *args, **kwargs) +@r_to_python +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd(x, *args, **kwargs) +@r_to_python +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd_units(x, *args, **kwargs) +@r_to_python +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_info(x, *args, **kwargs) +@r_to_python +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_url(x, *args, **kwargs) +@r_to_python +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_property(x, *args, **kwargs) +@r_to_python +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.availability(tbl, *args, **kwargs) +@r_to_python +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.bug_drug_combinations(x, *args, **kwargs) +@r_to_python +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_resistant(*args, **kwargs) +@r_to_python +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_susceptible(*args, **kwargs) +@r_to_python +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_S(*args, **kwargs) +@r_to_python +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_SI(*args, **kwargs) +@r_to_python +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_I(*args, **kwargs) +@r_to_python +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_IR(*args, **kwargs) +@r_to_python +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_R(*args, **kwargs) +@r_to_python +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_all(*args, **kwargs) +@r_to_python +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.n_sir(*args, **kwargs) +@r_to_python +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(data, *args, **kwargs) +@r_to_python +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_eucast_rules(*args, **kwargs) +@r_to_python +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_mdro_guideline(*args, **kwargs) +@r_to_python +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.translate_AMR(x, *args, **kwargs) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.1.9003-py3-none-any.whl b/dist/amr-3.0.1.9003-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..414c3007e82a1f58300c45ad36206becf88e3da8 GIT binary patch literal 10343 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%0D%}El zs$~I^n+N*WaIW~L8e7I=<;I4WB)|DPK)tES!k@+K=!+XCHkHS- z#)P!>I=~ikMlUS#B8_T$RXHC@-UR0gO<2qOGLG1m%WNqg^$k5?6_E_7ZihTX-X&kc z-o>3|Dh|E?5(V#5TO_g~jIO(v8|fbHV_~FLgAvac2Rs@4M&sXwCHi&EfC$}MHfH`) zqWSq1K75S%&51b81F2~?mI!Y`kMOhzGa6id-c)um^!MlbLyGv|!PeX@R!&iO#zc%3^1_BKZKDdvOgl~KJg&`yZ0Ay6N_*M< zRl~RknTj!A&F(MM*WgwXS@`y09xugj-%g*0rB63; z6Kn>(H*OdE-cBdV0D34dDwiNIAnIXX!>k91>R~zSLwl)`6G$-Fsa}WW4i0Z;tn62U z!yV)kA*Lr8FVS??c5pV{fpSn^DU&Ybe*$bS=k_^-K7@k=g3*3{L?Lm-2e|=GdopG|i4=+Zsgfx& z0QC@$F%?m}-A#so5&)@4sIEw+7Ai{!DB2Q|J1~Pe^gT{Yo+rcPd>>Y2YynkzESo=f z*OVp;s&2%$Bi9#t(a{d+yw3goSM@awphUBq^~XfLfe=s1i)m>cOpUXAaZD9oS4q-R zx>*eEua7Ho^N|77?0Ekh^)!lG6h9wt)TjmN3M5w4s6lFKuCz#T5wz57b@3u@qzNT@ zQWZFuWnn5(l~72Ea0s5xs8Dock?~6LLD=Nb3RsCjnVSN*u|H461)J)myAU$U z)~ZR4d)zoe=*gI(aNI+f5Tb-7Q78dF-E*{{{8PIaL(eFE$+NGmn1|uz+b8t-XAN{^ zqp3>1wYA*~V)(NJg@@y)NRQ-;uSO7v>?x@yMgT}GXvfeauPXq^BBE33iKFOjG*Qf^ z62RVzv2y2QUOFh%fVA->Y6W@*K=vNL- zT3s}CF%H8hDrOwHTL?_`^%oS^8bC3LXlRA!eZ9=MhE8M;%63|N;cX3&9S4m{7-tO1 zxYZ0vaa_y!=XC7znYDI^afLA0(bCUA0Ad0xhj;_oJi4>JS$Q57J zLSvg5@!&3{xlYb)h5_wSN^1v)-!vNYBe<%G#@2IFyK17W0Wods*U-;WFf;E{8As_# z5p&9FJ2V1S`&uVvJTetEUSB#JdEY zldlvLC^|nJTtbl(Z}CpD&Hd2J-O1g;5p&VDFo(9bzlfW61F5?T%Ra7a;8oDqbql0&8L9w+LfpcOh~r zQ6kX+ABs@|+##ay0X^Cfr47azK-~0i)6ARg<%V@$-ZY_!Kg(DfAB~ppWbUdO5Z<(* z$os`|``~`KLDU-wM8?EN0gP%mVdRFa*n*ruaKeW_a3pX)8K2dLZNEX(d<0|vqZ10Y zeHc~RbEl#uAxlh51cwp@)=~_DUpQE`8A}kCb|?u3Q5G31Zo-TqG}w9ayDF|{sPawg z{MBVewD{5(1d`wx9YmTWp6Gxb{8xVD!k;cJiytg_7c2xlLZlcQq(LF|u&v)6Swq@j z6pZ4_HYn@8^c`6R)RSR}^HFa<5(<8@kN`bDBV=wg;6%4SVRK1@P$L58^FSOEvQutq z5mEp?McMrDQu3fg)msPQ$0WKpAbB(yWXsFHWEA#)O1*XmdYR3LARrD@ARr`vG74imX9hM# zW=0l99%g1XMl+y`D+AEp!huOaLR~~$L|vp+_uPI%I{l-*yuyt+(p6=)y*7MMwh+gOyC^anJb(-{dODu1ADmXmiQYunJ%4itfyHDo_rwIdd z_y?LGep2AOGK`k>SJ*9XgpL(wM#uxuR*AtOWl8vlB&isLvxd_pJP@sSybsu^0kuIv z!&CLpP$%aZLGixG0V#3dzWkd9C3@ioPaMtb=+5g*#jUOtQ<4*0bvv>~Dp>0~5L2vP z-B(Fp`(s_JU8VJ{b?G#f;F8O|%zn$fm9MD0!9cSX zC#6D39!n*zWn&lSI6u60mAVnp4Ru;UVnx;g=!wnEeiGFxqZRvYCN$kQf(H@`83*!I z3r8f^M6Ln`&urtg!q(7E@aT|e005t!8l3QfD0ovj@CaDaV$?1-Vz1$h$cff9W;9}^ z4xt~j1&39s*8rk6Bbo-oufUd-j4|;Pc#Hp(Gz%6@ti4OhC5GA-#?g1Vo*Jpu=&Ii2 z2oIg&Va!p`fI8PB<{UemJ4T7lw^z~~?&6yfczMN{Ztkc5}TeP3SIKs{ngE{VrSGUv@^P8Ni?! zpl^t%B5xsKt3mBFAP`E#^ra*GmA<-1yJ~}T>y-1kdCkN(9w5RfjT1qQ54&3??ie7U zqWZGsc`rspUlzd8g~XSU+TG$P2eNS=n2#8pJzFZpi?ux(=BEA7;}~N z51GaBXI_atFYSysw*_Ax)8=9#-8*_Ve*+ z$hTk(^9y7_$K;^>O)H*pC;xF6+$VAQEFIJ;af5x4p%V@^^yPpSPRp!-_ZQ~Aldf!1 zOQR?T-8P&dg|Dvh%Y4r;KV2dcDjC)B)!Hi;G2O5RmOUUj>BNDiBFd*N2T0q1&2Bk` z=A_3Hbw$u?%UQnM7bX8;9K>1K_3*cpdJqmJT~Hz21HOeEreiT8Z*Z zIyR)nzNH*QPKl%}@`56kuyU*q%^H}BgytZ8S4Q%%kg4h>ha z+RmI}!L;hdh>W=vUfC01`Dq&4;o@54QFgI+h!3s7mB^%bahUUKXecGYHOxr_H}U}x z;q_6QR_}u-Gd(B~{%kb;fyhynv;QpjL*1+H9&0#1%1bD$$Kk&g&#?dGj z%r4Vq=qi{t(>zw(SCMZ)n%Lv%Q(+BgzX_GoP{) zisH$eIDOOlevgCE1XxCNeWHdmVPmTCKuFDc-(u0VtFIM~wF9XC?EbFr^X~EZ?RSVU zic#1Q9Mt!vk=9$yU~l?P2^y56pqCi|1e)+br{*-2ZMsrFQqbsl*^$BP+2jI*>N}pI z!*Phj$kcpC&Ee_Xja9KjhBu+D4O5FR4I(2}^7mfB&lqbO33TX+nYW393d|V5h}v-JJaJc!xAa%oKtNseW`u9`yFoyZ|HfvLLFl#sn(-{RSD9%0+rq1yNaw zh_%und$PgZ!ED{_)x+Lhl~)PT?se?~*&t z)Mma^q}|Q@fnk;l7ji5edE)Fn+R!nrvRcCD_<$!nl_b&mpO_q(X{8p_tXmX2QZjr4 zKM1SYE~7Hjp;+}%>v7A3#ZmHf@DGd~c(FOC_((C|MxZ=6mDIKGi*%7E5SRAb+BD_H zGO_szVNsiam^Ar)xmUg$%uWdz91j?5b-@H0aXc`nGDMOTxV1leS;=9YX@MU3WSumh zYDp6)ZwAX-26p*imCL(gZoYk*=OhD94z}$ZPTe5}i=r(|}Ag+W`5{!~(Dk2y6D z8}yevL4_juv6~+yfQEi#=>S$I=phxPEChs-YoxB?Bg*jrUix_Pa2auDsz8MASB^QUU=f_6X+Zh(z$AZ6hLI_)PR22jdmU>X&f zf+tM3p37P4owSY;gQnQv2jL}hbO&=3KLO&_e1Q*>9pbn)5GaH6LYW^P8SJm<%+Gnw zch#Yl%X76rT|t#7z4*>DujSkf_DxsJ0OEST!~RNoD3;8ff+2$a0h8fW~d zC1t)<(TbCVBgqyg!g>oE2P`-cDzBEtHYpLelE%Q}0?*(EbA(B6>R{7k?zj2W^ql7A zE}rYVT&$J{g6SqAG6Z4sCj6TesW;ui!{o!zMiv7~^to2X^$b#cd@WqJjw_;z)NhQ1 z)|VlABt}C_HTl}m<;k_Sy%iVU^YJuzr!IY%99JR3$dLUIF3Zb(u4`*iBPB9w|6U)? z=P1$Kyj&s5;cNx}Je0>x6sUF}sk= zZ1)M&!6)53=YHQ&5b+O2aUdDa*xAvzdU9!1-km^4eko2TbZE9B;nFeo#JTdwryrI~ zsOHky*nf&$@meq}ZfYGb)S#e^Axdj@6$YnH`v8m3 zwqxwBx2G8=&X8hx&MP#tQb{$)E9$OOLnHbPYJ?A%H~5*!$1Om^${?anZO8E~JVXf(@NF&oi9g(J8YO=Q=Jvw;)Uk8xk$TUo)3;pQX#4$Ep}`N; z_t>zlburBg*5Usl9M-z=HI{1VgZc5?GRsJd$)#M=M96yg`1$uQSSLacsVx=Y?ksH* z(fVdSZAFzt9*>JU6SIp~l0?g+QKuoayVrDmphM%0Lp_34%YexEZ!R7+nUY{cvX8JX z|L2?Rj`&9vYN)WVet`Cc{XLbF->bJ@oXAsf%`nzl{m3oZD9r4ktb-Dg#z7%R_WqOM zY22HbLj%!^wvpiI3=@hjG~H3wqoYlE>CwH@xh29;jUmK|bduM+rhmEcj*VwDr{~V) zBVuGz=NB^>rzVA*Z+CL2dHtT&^IGuL?p5n3OrIzw@$=`mOv+UbN+;C%t6UL~cEr6Z z#@PK2g3JMg(#a_=Y|4@Q!dS<9)tQ_%N56S;C7F0GH^R@T``_G4AEIq1PX)>7YQ7d| zshT2xT5I&7axrn#SAn}-gwcIk4GayknI%b>^izUR=^Fa$so5^iawfE%QbfGdPFF#G z^fQLRzNJkVnCxG!WmH>4*df?o=%V9`tG)0_v=hZLW8K*pZ`Y+T+2oU|=NF_#U?}c? zg8qGm^jF5`dNgtI2`P?cJE0R8*VSy_h zNlP<)KD$u~U{cI}=TT6oU>twjV{uSz;y!TDCKLNA(kWEu+_&?Xz1+8Sg#KXdkb}VP z6AOvBpw&Js;TNSfT%|YK`#ni1 z$iIK#s*l07G3XyN6Bq~x@qc1cl@L=>6?dDOb}nKD0r}ZI8=M*l!F@rZp<8PdDhX%6 z3R6NlmH;7lci-L2HgmuC2ts@}ge^N+c92^2RXN-49E z+DF#JCQLwGx#jBHI}5F8l?fHtmU;-DdTg~{_qri!QA855EnTdMGx^=qQeLl}U7YDM z6b{fNH3IZEYGxOPt~j^^(IBm|O$F=wSL)6M3}`bt8^JkT=j_l9%yvpPt_T;tCU=|- zwa*e7WO?S|u~H*>=H0awyE!pgrzyQ9>FJ$3vX^;&9o2^FqhZG(T;T5`PopnLB>N?7 zuflCUvG+{aB}Y()Vg7)vEC&jP0sep6%l`bL|Gr9s{_6f=Hv1>|pPq>Sfr5aP1V#RF zto;T47l*_@!T&rz{TrMG`#<1+Jx%>r^#89`@;CY%^FQe5e=8^dr2D53|EAj_`ww*g zEz5s${Zl-DbGecK2d;mU(my%>DWm`8YzgZBPn`cFDrGsyzr+jz{pY^_qecC{Bn|Rk D(Z=AC literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9003.tar.gz b/dist/amr-3.0.1.9003.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b2add9c66dcef15630351e335b17e8489917aa53 GIT binary patch literal 10188 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