From cec70b82d1b9e987325c6cfb7687a79f48419c73 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 10 Sep 2025 11:37:17 +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.9027-py3-none-any.whl | Bin 0 -> 10341 bytes dist/amr-3.0.0.9027.tar.gz | Bin 0 -> 10200 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.9027-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9027.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..173c683a4 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9027 +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.9027-py3-none-any.whl b/dist/amr-3.0.0.9027-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..ee45f6492b8fcf6cef519cbfba9ce7420a6cf136 GIT binary patch literal 10341 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 literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9027.tar.gz b/dist/amr-3.0.0.9027.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..c9c6a1ccd1f62c2487f8bcf10b9a1141702df2a0 GIT binary patch literal 10200 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