From 24452ad28fe639ad5f066c0b6353bbb2c8b965c7 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 11 Sep 2025 12:42:11 +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.9030-py3-none-any.whl | Bin 0 -> 10341 bytes dist/amr-3.0.0.9030.tar.gz | Bin 0 -> 10195 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.9030-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9030.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..ca9b4cc1d --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9030 +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.9030-py3-none-any.whl b/dist/amr-3.0.0.9030-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..685bba10f6b001ab7deff302d787b3cc967ab343 GIT binary patch literal 10341 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