From 539621c89256d7fb45b2a90543384ddc80708bd5 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Mon, 12 May 2025 10:36:55 +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.9274-py3-none-any.whl | Bin 0 -> 10177 bytes dist/amr-2.1.1.9274.tar.gz | Bin 0 -> 10027 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.9274-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9274.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..4ba478dbe --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9274 +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.9274-py3-none-any.whl b/dist/amr-2.1.1.9274-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..96dc52cb48bdef7d4a5cc8d9a971902695a9a342 GIT binary patch literal 10177 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