From 54717451acae3c86d1f0dc41a6c3078d646c50d3 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 15 Sep 2025 07:11:37 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 +++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 213 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 880 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.0.9033-py3-none-any.whl | Bin 0 -> 10339 bytes dist/amr-3.0.0.9033.tar.gz | Bin 0 -> 10191 bytes setup.py | 27 + 12 files changed, 1608 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.0.9033-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9033.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..9d14994df --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9033 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..3f906f72f --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,213 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import custom_mdro_guideline +from .functions import eucast_rules +from .functions import eucast_dosage +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..bf9cdc0f8 --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + except Exception as e: + print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = robjects.r(''' + df <- AMR::example_isolates + df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } + }) + df <- df[, !sapply(df, is.list)] + df + ''') + example_isolates['date'] = pd.to_datetime(example_isolates['date']) + + # microorganisms + microorganisms = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]') + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..9196b3660 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,880 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, (pd.DataFrame, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output + +def r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.polymyxins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.quinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rifamycins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.streptogramins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs) +@r_to_python +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs) +@r_to_python +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_class(amr_class, *args, **kwargs) +@r_to_python +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(filter, *args, **kwargs) +@r_to_python +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs) +@r_to_python +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs) +@r_to_python +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs) +@r_to_python +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(x, *args, **kwargs) +@r_to_python +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_ab(x) +@r_to_python +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_reset_session(*args, **kwargs) +@r_to_python +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_av(x, *args, **kwargs) +@r_to_python +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_av(x) +@r_to_python +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_disk(x, *args, **kwargs) +@r_to_python +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_disk(x) +@r_to_python +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mic(x, *args, **kwargs) +@r_to_python +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mic(x) +@r_to_python +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(x, *args, **kwargs) +@r_to_python +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p50(x, *args, **kwargs) +@r_to_python +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p90(x, *args, **kwargs) +@r_to_python +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(x, *args, **kwargs) +@r_to_python +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mo(x) +@r_to_python +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_uncertainties(*args, **kwargs) +@r_to_python +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_renamed(*args, **kwargs) +@r_to_python +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_failures(*args, **kwargs) +@r_to_python +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_reset_session(*args, **kwargs) +@r_to_python +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_cleaning_regex(*args, **kwargs) +@r_to_python +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_sir(x, *args, **kwargs) +@r_to_python +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir(x) +@r_to_python +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir_eligible(x, *args, **kwargs) +@r_to_python +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_interpretation_history(clean) +@r_to_python +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_property(atc_code, *args, **kwargs) +@r_to_python +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_groups(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd(atc_code, *args, **kwargs) +@r_to_python +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.atc_online_ddd_units(atc_code, *args, **kwargs) +@r_to_python +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_from_text(text, *args, **kwargs) +@r_to_python +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_name(x, *args, **kwargs) +@r_to_python +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_cid(x, *args, **kwargs) +@r_to_python +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_synonyms(x, *args, **kwargs) +@r_to_python +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_tradenames(x, *args, **kwargs) +@r_to_python +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_group(x, *args, **kwargs) +@r_to_python +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_atc(x, *args, **kwargs) +@r_to_python +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_loinc(x, *args, **kwargs) +@r_to_python +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd(x, *args, **kwargs) +@r_to_python +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd_units(x, *args, **kwargs) +@r_to_python +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_info(x, *args, **kwargs) +@r_to_python +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_url(x, *args, **kwargs) +@r_to_python +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_property(x, *args, **kwargs) +@r_to_python +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.availability(tbl, *args, **kwargs) +@r_to_python +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.bug_drug_combinations(x, *args, **kwargs) +@r_to_python +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_resistant(*args, **kwargs) +@r_to_python +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_susceptible(*args, **kwargs) +@r_to_python +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_S(*args, **kwargs) +@r_to_python +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_SI(*args, **kwargs) +@r_to_python +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_I(*args, **kwargs) +@r_to_python +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_IR(*args, **kwargs) +@r_to_python +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_R(*args, **kwargs) +@r_to_python +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_all(*args, **kwargs) +@r_to_python +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.n_sir(*args, **kwargs) +@r_to_python +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(data, *args, **kwargs) +@r_to_python +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_eucast_rules(*args, **kwargs) +@r_to_python +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_mdro_guideline(*args, **kwargs) +@r_to_python +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.translate_AMR(x, *args, **kwargs) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.0.9033-py3-none-any.whl b/dist/amr-3.0.0.9033-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..e5c60536ee60b8ed628edc594f05861572446c3d GIT binary patch literal 10339 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