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