From 62da4dbccfc421d007407b111b5417294d7131ae Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 4 Sep 2025 13:04:10 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 +++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 213 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 880 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.0.9026-py3-none-any.whl | Bin 0 -> 10340 bytes dist/amr-3.0.0.9026.tar.gz | Bin 0 -> 10217 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.9026-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9026.tar.gz create mode 100644 setup.py diff --git a/AMR.egg-info/PKG-INFO b/AMR.egg-info/PKG-INFO new file mode 100644 index 000000000..3d9419028 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9026 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# 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.9026-py3-none-any.whl b/dist/amr-3.0.0.9026-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f08026263e2fb7020455572c3db29df7793dd406 GIT binary patch literal 10340 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