From 0b998fe3373e18356554ca582f7a6da7f920a1b9 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 4 Sep 2025 12:41:22 +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.9025-py3-none-any.whl | Bin 0 -> 10340 bytes dist/amr-3.0.0.9025.tar.gz | Bin 0 -> 10215 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.9025-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9025.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..e22e732cb --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9025 +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.9025-py3-none-any.whl b/dist/amr-3.0.0.9025-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..50b2c86b026729d3cce039e19c2c8890ded9362f GIT binary patch literal 10340 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