From 83960834ce79786f9204b5ef674631185e696d56 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 17 Jul 2025 17:07:52 +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 | 219 +++++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 683 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-3.0.0.9010-py3-none-any.whl | Bin 0 -> 10277 bytes dist/amr-3.0.0.9010.tar.gz | Bin 0 -> 10113 bytes setup.py | 27 ++ 12 files changed, 1417 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-3.0.0.9010-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9010.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..9d6f60da9 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9010 +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..dba238d35 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,219 @@ +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 all_mic +from .functions import all_mic_predictors +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +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..101c1aa82 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,683 @@ +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 all_mic(*args, **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_mic(*args, **kwargs)) +def all_mic_predictors(*args, **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_mic_predictors(*args, **kwargs)) +def all_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.all_sir(*args, **kwargs)) +def all_sir_predictors(*args, **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_sir_predictors(*args, **kwargs)) +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.step_mic_log2(recipe, *args, **kwargs)) +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.step_sir_numeric(recipe, *args, **kwargs)) +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antibiogram(x, *args, **kwargs)) +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.wisca(x, *args, **kwargs)) +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs)) +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs)) +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs)) +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antifungals(only_sir_columns = False, *args, **kwargs)) +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs)) +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.betalactams(only_sir_columns = False, *args, **kwargs)) +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs)) +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.carbapenems(only_sir_columns = False, *args, **kwargs)) +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs)) +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs)) +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs)) +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs)) +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.lincosamides(only_sir_columns = False, *args, **kwargs)) +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs)) +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.macrolides(only_sir_columns = False, *args, **kwargs)) +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.monobactams(only_sir_columns = False, *args, **kwargs)) +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs)) +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs)) +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.penicillins(only_sir_columns = False, *args, **kwargs)) +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.phenicols(only_sir_columns = False, *args, **kwargs)) +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.polymyxins(only_sir_columns = False, *args, **kwargs)) +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.quinolones(only_sir_columns = False, *args, **kwargs)) +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.rifamycins(only_sir_columns = False, *args, **kwargs)) +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.streptogramins(only_sir_columns = False, *args, **kwargs)) +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs)) +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs)) +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs)) +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs)) +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_class(amr_class, *args, **kwargs)) +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_selector(filter, *args, **kwargs)) +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs)) +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs)) +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs)) +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_ab(x, *args, **kwargs)) +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_ab(x)) +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_reset_session(*args, **kwargs)) +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_av(x, *args, **kwargs)) +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_av(x)) +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_disk(x, *args, **kwargs)) +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_disk(x)) +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_mic(x, *args, **kwargs)) +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_mic(x)) +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.rescale_mic(x, *args, **kwargs)) +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mic_p50(x, *args, **kwargs)) +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mic_p90(x, *args, **kwargs)) +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_mo(x, *args, **kwargs)) +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_mo(x)) +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_uncertainties(*args, **kwargs)) +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_renamed(*args, **kwargs)) +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_failures(*args, **kwargs)) +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_reset_session(*args, **kwargs)) +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_cleaning_regex(*args, **kwargs)) +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_sir(x, *args, **kwargs)) +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_sir(x)) +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_sir_eligible(x, *args, **kwargs)) +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_interpretation_history(clean)) +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_property(atc_code, *args, **kwargs)) +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_groups(atc_code, *args, **kwargs)) +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_ddd(atc_code, *args, **kwargs)) +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_ddd_units(atc_code, *args, **kwargs)) +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_from_text(text, *args, **kwargs)) +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_name(x, *args, **kwargs)) +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_cid(x, *args, **kwargs)) +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_synonyms(x, *args, **kwargs)) +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_tradenames(x, *args, **kwargs)) +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_group(x, *args, **kwargs)) +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_atc(x, *args, **kwargs)) +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_loinc(x, *args, **kwargs)) +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_ddd(x, *args, **kwargs)) +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_ddd_units(x, *args, **kwargs)) +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_info(x, *args, **kwargs)) +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_url(x, *args, **kwargs)) +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_property(x, *args, **kwargs)) +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.availability(tbl, *args, **kwargs)) +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.bug_drug_combinations(x, *args, **kwargs)) +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_resistant(*args, **kwargs)) +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_susceptible(*args, **kwargs)) +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_S(*args, **kwargs)) +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_SI(*args, **kwargs)) +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_I(*args, **kwargs)) +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_IR(*args, **kwargs)) +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_R(*args, **kwargs)) +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_all(*args, **kwargs)) +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.n_sir(*args, **kwargs)) +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_df(data, *args, **kwargs)) +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.custom_eucast_rules(*args, **kwargs)) +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.custom_mdro_guideline(*args, **kwargs)) +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_rules(x, *args, **kwargs)) +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_dosage(ab, *args, **kwargs)) +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.export_ncbi_biosample(x, *args, **kwargs)) +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.first_isolate(x = None, *args, **kwargs)) +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.filter_first_isolate(x = None, *args, **kwargs)) +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.g_test(x, *args, **kwargs)) +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_new_episode(x, *args, **kwargs)) +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_pca(x, *args, **kwargs)) +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_sir(data, *args, **kwargs)) +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.geom_sir(position = None, *args, **kwargs)) +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.guess_ab_col(x = None, *args, **kwargs)) +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.italicise_taxonomy(string, *args, **kwargs)) +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.italicize_taxonomy(string, *args, **kwargs)) +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.inner_join_microorganisms(x, *args, **kwargs)) +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.left_join_microorganisms(x, *args, **kwargs)) +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.right_join_microorganisms(x, *args, **kwargs)) +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.full_join_microorganisms(x, *args, **kwargs)) +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.semi_join_microorganisms(x, *args, **kwargs)) +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.anti_join_microorganisms(x, *args, **kwargs)) +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.key_antimicrobials(x = None, *args, **kwargs)) +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.all_antimicrobials(x = None, *args, **kwargs)) +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.kurtosis(x, *args, **kwargs)) +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.like(x, *args, **kwargs)) +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdro(x = None, *args, **kwargs)) +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.brmo(x = None, *args, **kwargs)) +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mrgn(x = None, *args, **kwargs)) +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdr_tb(x = None, *args, **kwargs)) +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdr_cmi2012(x = None, *args, **kwargs)) +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs)) +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mean_amr_distance(x, *args, **kwargs)) +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_distance_from_row(amr_distance, *args, **kwargs)) +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_matching_score(x, *args, **kwargs)) +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_name(x, *args, **kwargs)) +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_fullname(x, *args, **kwargs)) +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_shortname(x, *args, **kwargs)) +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_subspecies(x, *args, **kwargs)) +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_species(x, *args, **kwargs)) +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_genus(x, *args, **kwargs)) +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_family(x, *args, **kwargs)) +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_order(x, *args, **kwargs)) +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_class(x, *args, **kwargs)) +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_phylum(x, *args, **kwargs)) +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_kingdom(x, *args, **kwargs)) +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_domain(x, *args, **kwargs)) +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_type(x, *args, **kwargs)) +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_status(x, *args, **kwargs)) +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_pathogenicity(x, *args, **kwargs)) +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_gramstain(x, *args, **kwargs)) +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_gram_negative(x, *args, **kwargs)) +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_gram_positive(x, *args, **kwargs)) +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_yeast(x, *args, **kwargs)) +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs)) +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_oxygen_tolerance(x, *args, **kwargs)) +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_anaerobic(x, *args, **kwargs)) +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_snomed(x, *args, **kwargs)) +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_ref(x, *args, **kwargs)) +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_authors(x, *args, **kwargs)) +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_year(x, *args, **kwargs)) +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_lpsn(x, *args, **kwargs)) +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_mycobank(x, *args, **kwargs)) +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_gbif(x, *args, **kwargs)) +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_rank(x, *args, **kwargs)) +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_taxonomy(x, *args, **kwargs)) +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_synonyms(x, *args, **kwargs)) +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_current(x, *args, **kwargs)) +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_group_members(x, *args, **kwargs)) +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_info(x, *args, **kwargs)) +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_url(x, *args, **kwargs)) +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_property(x, *args, **kwargs)) +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.pca(x, *args, **kwargs)) +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.theme_sir(*args, **kwargs)) +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.labels_sir_count(position = None, *args, **kwargs)) +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.resistance(*args, **kwargs)) +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.susceptibility(*args, **kwargs)) +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_confidence_interval(*args, **kwargs)) +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_R(*args, **kwargs)) +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_IR(*args, **kwargs)) +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_I(*args, **kwargs)) +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_SI(*args, **kwargs)) +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_S(*args, **kwargs)) +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_df(data, *args, **kwargs)) +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_df(data, *args, **kwargs)) +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.random_mic(size = None, *args, **kwargs)) +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.random_disk(size = None, *args, **kwargs)) +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.random_sir(size = None, *args, **kwargs)) +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.resistance_predict(x, *args, **kwargs)) +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_predict(x, *args, **kwargs)) +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_sir_predict(x, *args, **kwargs)) +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.skewness(x, *args, **kwargs)) +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.top_n_microorganisms(x, *args, **kwargs)) +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.reset_AMR_locale(*args, **kwargs)) +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.translate_AMR(x, *args, **kwargs)) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-3.0.0.9010-py3-none-any.whl b/dist/amr-3.0.0.9010-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..0814dc6e4f115aa62027a51f48d18675b29081fe GIT binary patch literal 10277 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