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

gIWiAe(aeN&N9RFdNx6ch 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 D^so{q literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..95c779909 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9235', + packages=find_packages(), + install_requires=[ + 'rpy2', + 'numpy', + 'pandas', + ], + author='Matthijs Berends', + author_email='m.s.berends@umcg.nl', + description='A Python wrapper for the AMR R package', + long_description=open('README.md').read(), + long_description_content_type='text/markdown', + url='https://github.com/msberends/AMR', + project_urls={ + 'Bug Tracker': 'https://github.com/msberends/AMR/issues', + }, + license='GPL 2', + classifiers=[ + 'Programming Language :: Python :: 3', + 'Operating System :: OS Independent', + ], + python_requires='>=3.6', +)