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