From 73ecc73e0f76f6d6dacf62c7e09874ebd81e6903 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 13 Jun 2025 15:06: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 | 219 +++++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 683 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-3.0.0.9004-py3-none-any.whl | Bin 0 -> 10277 bytes dist/amr-3.0.0.9004.tar.gz | Bin 0 -> 10110 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.9004-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9004.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..93480ae82 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9004 +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.9004-py3-none-any.whl b/dist/amr-3.0.0.9004-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..dfc434e0a8ad71bc6990b56524783c57ad23ef88 GIT binary patch literal 10277 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