From 846cdd9a3280f6f0d9bbee254c366bf6467b02fe Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 16 May 2025 14:57:19 +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.9279-py3-none-any.whl | Bin 0 -> 10174 bytes dist/amr-2.1.1.9279.tar.gz | Bin 0 -> 10024 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.9279-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9279.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..925ec0067 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9279 +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-2.1.1.9279-py3-none-any.whl b/dist/amr-2.1.1.9279-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..8b41b0e6071d27a2fce77a82ac97dd62605bb9a3 GIT binary patch literal 10174 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9279.tar.gz b/dist/amr-2.1.1.9279.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b7f01a6043f6f94e8d4dfc49bfd34c90241a1f72 GIT binary patch literal 10024 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