From eab89513606be1021a45ff9b0d608126795730df Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 4 Jun 2025 11:13:02 +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-3.0.0.9001-py3-none-any.whl | Bin 0 -> 10177 bytes dist/amr-3.0.0.9001.tar.gz | Bin 0 -> 10026 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-3.0.0.9001-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9001.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..b4bce8a8a --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9001 +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..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..1e662c39c --- /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 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 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 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-3.0.0.9001-py3-none-any.whl b/dist/amr-3.0.0.9001-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..23bb16f11cd206b0936ef42d46735fb11e447319 GIT binary patch literal 10177 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