From 195919673137022318ea9e9addcfd9109193f655 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 4 May 2025 12:26:26 +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 | 665 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9270-py3-none-any.whl | Bin 0 -> 10177 bytes dist/amr-2.1.1.9270.tar.gz | Bin 0 -> 10015 bytes setup.py | 27 ++ 12 files changed, 1393 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-2.1.1.9270-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9270.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..088665f0d --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9270 +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..0dd6e1f18 --- /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 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 custom_mdro_guideline +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..63c92aabf --- /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 import 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 +pandas2ri.activate() + +# example_isolates +example_isolates = pandas2ri.rpy2py(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 = pandas2ri.rpy2py(robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]')) +antimicrobials = pandas2ri.rpy2py(robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]')) +clinical_breakpoints = pandas2ri.rpy2py(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..0c707e39d --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,665 @@ +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects import pandas2ri +import pandas as pd +import numpy as np + +# Activate automatic conversion between R data frames and pandas data frames +pandas2ri.activate() + +# 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): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + elif isinstance(r_output, DataFrame): + return pandas2ri.rpy2py(r_output) # Return as pandas DataFrame + + # 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 ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_class(*args, **kwargs)) +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_selector(*args, **kwargs)) +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 convert_to_python(amr_r.ab_from_text(text, *args, **kwargs)) +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_name(x, *args, **kwargs)) +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_cid(x, *args, **kwargs)) +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_synonyms(x, *args, **kwargs)) +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_tradenames(x, *args, **kwargs)) +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_group(x, *args, **kwargs)) +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_atc(x, *args, **kwargs)) +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 convert_to_python(amr_r.ab_atc_group1(x, *args, **kwargs)) +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 convert_to_python(amr_r.ab_atc_group2(x, *args, **kwargs)) +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_loinc(x, *args, **kwargs)) +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_ddd(x, *args, **kwargs)) +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 convert_to_python(amr_r.ab_ddd_units(x, *args, **kwargs)) +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_info(x, *args, **kwargs)) +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_url(x, *args, **kwargs)) +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_property(x, *args, **kwargs)) +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.add_custom_antimicrobials(x)) +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.clear_custom_antimicrobials(*args, **kwargs)) +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.add_custom_microorganisms(x)) +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.clear_custom_microorganisms(*args, **kwargs)) +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.age(x, *args, **kwargs)) +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.age_groups(x, *args, **kwargs)) +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antibiogram(x, *args, **kwargs)) +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.wisca(x, *args, **kwargs)) +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 convert_to_python(amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs)) +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 convert_to_python(amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.antifungals(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.betalactams(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.carbapenems(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.lincosamides(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.macrolides(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.monobactams(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.penicillins(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.phenicols(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.polymyxins(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.quinolones(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.rifamycins(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.streptogramins(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.amr_class(amr_class, *args, **kwargs)) +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_selector(filter, *args, **kwargs)) +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 convert_to_python(amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs)) +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 convert_to_python(amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs)) +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_ab(x, *args, **kwargs)) +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_ab(x)) +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_reset_session(*args, **kwargs)) +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_av(x, *args, **kwargs)) +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_av(x)) +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_disk(x, *args, **kwargs)) +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_disk(x)) +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_mic(x, *args, **kwargs)) +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_mic(x)) +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.rescale_mic(x, *args, **kwargs)) +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mic_p50(x, *args, **kwargs)) +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mic_p90(x, *args, **kwargs)) +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_mo(x, *args, **kwargs)) +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_mo(x)) +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_uncertainties(*args, **kwargs)) +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_renamed(*args, **kwargs)) +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_failures(*args, **kwargs)) +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_reset_session(*args, **kwargs)) +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_cleaning_regex(*args, **kwargs)) +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_sir(x, *args, **kwargs)) +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_sir(x)) +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 convert_to_python(amr_r.is_sir_eligible(x, *args, **kwargs)) +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_interpretation_history(clean)) +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 convert_to_python(amr_r.atc_online_property(atc_code, *args, **kwargs)) +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 convert_to_python(amr_r.atc_online_groups(atc_code, *args, **kwargs)) +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 convert_to_python(amr_r.atc_online_ddd(atc_code, *args, **kwargs)) +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 convert_to_python(amr_r.atc_online_ddd_units(atc_code, *args, **kwargs)) +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 convert_to_python(amr_r.av_from_text(text, *args, **kwargs)) +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_name(x, *args, **kwargs)) +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_cid(x, *args, **kwargs)) +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_synonyms(x, *args, **kwargs)) +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_tradenames(x, *args, **kwargs)) +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_group(x, *args, **kwargs)) +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_atc(x, *args, **kwargs)) +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_loinc(x, *args, **kwargs)) +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_ddd(x, *args, **kwargs)) +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 convert_to_python(amr_r.av_ddd_units(x, *args, **kwargs)) +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_info(x, *args, **kwargs)) +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_url(x, *args, **kwargs)) +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_property(x, *args, **kwargs)) +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.availability(tbl, *args, **kwargs)) +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 convert_to_python(amr_r.bug_drug_combinations(x, *args, **kwargs)) +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_resistant(*args, **kwargs)) +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_susceptible(*args, **kwargs)) +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_S(*args, **kwargs)) +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_SI(*args, **kwargs)) +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_I(*args, **kwargs)) +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_IR(*args, **kwargs)) +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_R(*args, **kwargs)) +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_all(*args, **kwargs)) +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.n_sir(*args, **kwargs)) +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_df(data, *args, **kwargs)) +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.custom_eucast_rules(*args, **kwargs)) +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_rules(x, *args, **kwargs)) +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_dosage(ab, *args, **kwargs)) +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 convert_to_python(amr_r.export_ncbi_biosample(x, *args, **kwargs)) +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 convert_to_python(amr_r.first_isolate(x = None, *args, **kwargs)) +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 convert_to_python(amr_r.filter_first_isolate(x = None, *args, **kwargs)) +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.g_test(x, *args, **kwargs)) +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 convert_to_python(amr_r.is_new_episode(x, *args, **kwargs)) +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_pca(x, *args, **kwargs)) +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_sir(data, *args, **kwargs)) +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 convert_to_python(amr_r.geom_sir(position = None, *args, **kwargs)) +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 convert_to_python(amr_r.guess_ab_col(x = None, *args, **kwargs)) +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.italicise_taxonomy(string, *args, **kwargs)) +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.italicize_taxonomy(string, *args, **kwargs)) +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 convert_to_python(amr_r.inner_join_microorganisms(x, *args, **kwargs)) +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 convert_to_python(amr_r.left_join_microorganisms(x, *args, **kwargs)) +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 convert_to_python(amr_r.right_join_microorganisms(x, *args, **kwargs)) +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 convert_to_python(amr_r.full_join_microorganisms(x, *args, **kwargs)) +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 convert_to_python(amr_r.semi_join_microorganisms(x, *args, **kwargs)) +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 convert_to_python(amr_r.anti_join_microorganisms(x, *args, **kwargs)) +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 convert_to_python(amr_r.key_antimicrobials(x = None, *args, **kwargs)) +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 convert_to_python(amr_r.all_antimicrobials(x = None, *args, **kwargs)) +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.kurtosis(x, *args, **kwargs)) +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.like(x, *args, **kwargs)) +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdro(x = None, *args, **kwargs)) +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.custom_mdro_guideline(*args, **kwargs)) +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.brmo(x = None, *args, **kwargs)) +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mrgn(x = None, *args, **kwargs)) +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 convert_to_python(amr_r.mdr_tb(x = None, *args, **kwargs)) +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 convert_to_python(amr_r.mdr_cmi2012(x = None, *args, **kwargs)) +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 convert_to_python(amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs)) +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 convert_to_python(amr_r.mean_amr_distance(x, *args, **kwargs)) +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 convert_to_python(amr_r.amr_distance_from_row(amr_distance, *args, **kwargs)) +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 convert_to_python(amr_r.mo_matching_score(x, *args, **kwargs)) +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_name(x, *args, **kwargs)) +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_fullname(x, *args, **kwargs)) +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_shortname(x, *args, **kwargs)) +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_subspecies(x, *args, **kwargs)) +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_species(x, *args, **kwargs)) +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_genus(x, *args, **kwargs)) +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_family(x, *args, **kwargs)) +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_order(x, *args, **kwargs)) +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_class(x, *args, **kwargs)) +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_phylum(x, *args, **kwargs)) +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_kingdom(x, *args, **kwargs)) +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_domain(x, *args, **kwargs)) +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_type(x, *args, **kwargs)) +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_status(x, *args, **kwargs)) +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_pathogenicity(x, *args, **kwargs)) +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_gramstain(x, *args, **kwargs)) +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 convert_to_python(amr_r.mo_is_gram_negative(x, *args, **kwargs)) +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 convert_to_python(amr_r.mo_is_gram_positive(x, *args, **kwargs)) +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 convert_to_python(amr_r.mo_is_yeast(x, *args, **kwargs)) +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 convert_to_python(amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs)) +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 convert_to_python(amr_r.mo_oxygen_tolerance(x, *args, **kwargs)) +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 convert_to_python(amr_r.mo_is_anaerobic(x, *args, **kwargs)) +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_snomed(x, *args, **kwargs)) +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_ref(x, *args, **kwargs)) +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_authors(x, *args, **kwargs)) +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_year(x, *args, **kwargs)) +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_lpsn(x, *args, **kwargs)) +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_mycobank(x, *args, **kwargs)) +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_gbif(x, *args, **kwargs)) +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_rank(x, *args, **kwargs)) +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_taxonomy(x, *args, **kwargs)) +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_synonyms(x, *args, **kwargs)) +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_current(x, *args, **kwargs)) +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 convert_to_python(amr_r.mo_group_members(x, *args, **kwargs)) +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_info(x, *args, **kwargs)) +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_url(x, *args, **kwargs)) +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_property(x, *args, **kwargs)) +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.pca(x, *args, **kwargs)) +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.theme_sir(*args, **kwargs)) +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 convert_to_python(amr_r.labels_sir_count(position = None, *args, **kwargs)) +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.resistance(*args, **kwargs)) +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.susceptibility(*args, **kwargs)) +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_confidence_interval(*args, **kwargs)) +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_R(*args, **kwargs)) +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_IR(*args, **kwargs)) +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_I(*args, **kwargs)) +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_SI(*args, **kwargs)) +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_S(*args, **kwargs)) +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_df(data, *args, **kwargs)) +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_df(data, *args, **kwargs)) +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 convert_to_python(amr_r.random_mic(size = None, *args, **kwargs)) +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 convert_to_python(amr_r.random_disk(size = None, *args, **kwargs)) +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 convert_to_python(amr_r.random_sir(size = None, *args, **kwargs)) +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.resistance_predict(x, *args, **kwargs)) +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_predict(x, *args, **kwargs)) +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 convert_to_python(amr_r.ggplot_sir_predict(x, *args, **kwargs)) +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.skewness(x, *args, **kwargs)) +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 convert_to_python(amr_r.top_n_microorganisms(x, *args, **kwargs)) +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.reset_AMR_locale(*args, **kwargs)) +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(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-2.1.1.9270-py3-none-any.whl b/dist/amr-2.1.1.9270-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..42f8e9979c6461d315eaf1775a492267b0ef81ce GIT binary patch literal 10177 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