From 20d96cd1e64cbd1123f968f256f320cf061a527d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 25 Apr 2025 09:21:10 +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.9252-py3-none-any.whl | Bin 0 -> 10187 bytes dist/amr-2.1.1.9252.tar.gz | Bin 0 -> 10035 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.9252-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9252.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..a62f89c98 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9252 +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.9252-py3-none-any.whl b/dist/amr-2.1.1.9252-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..cc648d35b6fd54e2be80fd1d3adaf8e17a0951fd GIT binary patch literal 10187 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9252.tar.gz b/dist/amr-2.1.1.9252.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..e38c7ba442db6f1142f79f14c98f56eaa1829e19 GIT binary patch literal 10035 zcmchbRZ!irx9@R^7k4%e#S0X7x8hLTt++dE+}&LZ6u08;?i6=Qakq{BPXA}lnYpj` z;oeEI@}2cr$z<}7%vzx64@SNc9zfo8ZY}7b{1D-XQ*?(7iVJb`C8zw zno%kr%{m7K$18%vOyJpzmJr;qof%+xDF!mj!xO5Lh{*w{_#p^ldY$Fk?;!K6tKPSxSZRNv^kDs>Y zQ~P4XGhFMj21^|ww7U`jnDgrc9y@Hu7V;Sn=*7WY?eqA$bQ<~E`S;S z{%bi>uUYjM^UrPpQSIvqP!re8u5-E{3nUsdICE5YLS%_@;ae83sUQ@_O>*X_MV|8G zg_d@*URd_>yipD54xj}aDjj6lR>vL<-YjJ-@3Q|l+e44+9Fa=qPz%Stu6T0dM zmr`f44T&8yA+QvGU^n~1^siGZ>A1Vnd15h$z&EFGQ^7-v8xmuf9nuU+;lo2IH?6n2ph6+gaJA-l z7o6hEB-Z=@aQJyx`*db6>H7Qc4NX-D&_pMVN(4)?i>dZ!hn>lL`KvuN3G`58^EEN= zjJZlY|N2rnr6kChmca>=NUP|_y%jhNqua2BVu}G7xtc7u3#i4tPEFCtUO_Jush?C; z`V-*K(Oi@p-2c-9SES7QY|98b#pHMTXABZH#vpHDWn~#1i)oRIhF7>!0$6;N*R|4? zz9*OgCKD+IP;aSwI$BDPgJ@)>@32FGbMsvbDOa>dA;$UBxgy3S*2rq8kV#D!iXh)$ z$Lx0fLGuJDlrR5y2X&0!tmXamvc8>zYxS%H!M2RaB=!}dqkXkTf8pRH@?joa0H%_8 zTd57kOR#b9nh}PcTCm4H!BO(lHG9H}iIE}Uk%pEp5nJZu?WmP%GR55`OY?ahrTA0dT9V|*YD)Q zt@?bCj1;Y~nY!IEFwTAB=^u^46J?Rk49h>lAfsRB_;l1O;2jl9*OQzGI!3~?(_>>$a zZ?RnrtM9PAUtm>tNn@exJE2G0=-kU{q@VHbEw<$4c|ae6nFm z3!x?OM_n5+N{8tqS!I5;i7;C;m*tc9?7vrgr*xl4`^}m0p3+qzLGuzc_tJCs&e{dY zm-%e~spnHqVlO?<#beL!wS7iE9>IQ*DP6X4I+@pXldQ08j#d&o+r8r#C14VtH8*XA z`br~z_f2a*@ov)%HrgZGpz^+2e0Ku6MT*H_#%-6mGs9kti^L?9s$VElQIy~

JaNXQGtuS5jJDeK{wb|x%*^z zG&|omxl-G|;R=ojihM}H2Om-J7B4YsV?iuEUC@p9Bj3V7P?{<#j7{NJksBsAWj&uc zd_aM`n`e0CAKVGnh^+#QZ{w!5>rKXh5b43V-ox1P{eV-XSG_0=W`at%aVl9`ewApT zbCk>)w0Ak67;Tw$c}two2ReH8)n~BYUYPCRA#?QVx+#Jigvklx)Vui`%m_+kDdzsO$BuZK(eVY0nipM{;3G3~ zLx{bI_+Z4Q?gtJVbx{yB&0W5A8@O$y7fhR(^t$XluLS)8??t6#z#DC|jQ(uFwdj|? z+*)meq^Wvi72XqyuoII|4A!5(++=X0u%=@(gHizBpDJ4D53N=BDl4O4dxWabsN{LU zk1YY-kgHPJvkr2eDjHwH7$sFCxp+dHw2yR2b#y*6_}V?HF+<6`0ex4l0s{K?fKu4=OD*d$@NHAQZjsu+HaEOI(zTCU z;xL8V3Bu9iB4OZi`su~(c*rYkf8kZyp3VN?tNapk=O9{|=L8DFgH7=HI6jZXh6(d} zeaU)L*qQlzT-`~0^Xw<2iEhu6ohBwOY;qIW$+pE%=*Ll|J@UxVL*1LIbI3;#Ty~ms zo22zT>QrAk4$DxF^Gqhz>z|(LIB}oMoM6I`bv{dOc5dMiwJ&hq4ktuGIPUg)(<3}7 zzOYT4$I7Uk@(zvU@P!_TER4$?j~c=2P1p$?Xti z{LvZZu{J5{YV+`TuUd5JhWd>4T2@?ocqza7D=8qY3dhtaaTwHX`b#X;ooYnQgE|?O`FxN3@ zfY};%ZdGmdnv}PJ;xD}ZPi*<4E6SY~QpvH!ema+S7GSKr(6!j0f9LR8s9}p+j7y1x zDD6e2jk~in&P4zoZE;PR;hW&9Wz%^XXHGEV?cMRFpaBvaA|fJp45l#Bm|(UP*O8(y zu2#J|dvIKYhu#UzA}?Kw6N$uOmw|axv84~5&(YR!4Xk*7k%p&vqt^02;*?Tic<-LKVf%H8V?ME*q-8l8Ga z6_P~2dD6z$5uk6AdtxI#q+^M;5w@gVsM6s^)El*w$#^m{WiF&g1}m#^hUFO)N-2|^ zB`|tjqHqPJBG+FlnFdpf=JZ?9p|yL61b)?<+J5e!!nl2{`;ckqo4n$lcdO0bm!D3h zCJw%wcUY$-A4GgcUiRzoE2IY1))~7&@Et~NL?HWZ9x&&#I#fx9`^(_dzEN#`C)Tio z63vw-OUQwa#HS59Bmwkhqc*HE$J$nZrkk%ZrsQL9=Kj)m#PDo)Rf2fE_D9^vJJcJN z&}U)(#ZXe$=VT~G-2b6lHqbF3ih$oMjW2`m`Mr7UhDbIYN;$%Kp5qV0AN&5}G$+Ru z=Y?DgIRP>ogbR#wIgin|Bf(0mtS0K0*xT`9%mgfA_LsOL@jn7WRG4E4;&y^!`Fi;62QnApTSejW|t;FvFqXV=QE75Pby^1TL;Lazr zA6+-804GWjXh#;s`huoXJdJtx#uhitM2-Au>1do+R?gp@URujFCbWUnl;V;AMT2j+ z=!oE$(7ZzK7rHLXLW&4dIWm2lp8mSJM%9;D=kgn0nvg8YF|PK%;ai_RtswZCYzhme zDaj&GugLAp;2?l$p=aVb)!ikYZ=jDW*~#8~d1}b+Ry427HDLR5FrBbUl9(2aC;BYI z%@`uP@$_ULPYY{s#{Jf#&Fc4&J22 zqR&Z-Vw*Cm(P95U>OLMb(Z8`6tNY6;Lid-lp#7XlWve7g=s#!H-v0pv{(^ z@T`eciInEaDu`aFTk&rgZa<)~ox4W%RcS!E-n?0gL8xK?+fUx%;P;Dt4YW~a?5nSF zc=>n)s!3)lu?Asl;y|}L-eU<)YeOrsks)LBiw?4$_J;GyqLVs&H&WJ$#Bh4dFVnt1F4bMr5 z6T_Balt_OCZQyNHS48FS^E0R^M6$J#g!{U(YOHzi)1rvNweM8~;b*@q!EOEKh5aP; zMZ|T}YPQE0vd@n%50kss;lmEy=hdMdnu%Tdvr!3bws@Cl;EsSPA=dou3k)!SAugWL z9*@t!HjB{^3)|l{pMfnFqv*Ph|DM$zE>@h+Q4!tB?s8|N9)jOHg;6g;G=CXk4I8zV zuTq%rGz3_BSbOWc^$rR-Fy3ig$e=+OqElsTCb8E|S{;;D55^HP_DbxI7&ckZAQFfF z(xdrY`8ZY(g_MAXZ_FqrUQ9-f;2B0(h06kJV*}YV8N}!Nc5z%FX0NZn-t_v zdG-@RtpxMv+ql%%ASdD!$-CqjhRr;Z=g0FKeaYa$Gh{xXb-bkBE837nvJ}Ly=D%Jr zNvP^x+X|<9Jx1Xf&A>rEkj{a*`D|Rpj;|U3PdvtnobjFUxu_Y_xG!Q)&$h2W$1Ab{ zbuoz1PxfqWT6I-aKbpm|7lRqEBB}>Z?-<1-#;=tARmYL{b;tdfx~2khI(LA&(YI*# zH113unBEBWwD_QYP(Y?X4W)Be(O)~DsbKs$_IEDS$sDeDMn9DcnH9UHJEawz_T&hK zTd~$IGzEM{qp@_(?A1!n@PpXubv@ejm(ux7#1jsh0c{KGv7be{MMPJrnJYMhD*9>7 z61o|Y81l*><%|I_xAfrV0d4y)Cn{mJ@d}~qa#8geGJ+sevU0w}r6NYjFInYL-3U79 zxwIl62Ad(7odc$TIJG6Ts)4j%k02RspAvN4dc}#E=lhEk{le58#>wIG>a(Nj0Zl8i z&=L@rtkCvLSp_0}-!}yVhH$Fyz2B-NX^ck~o1Uq!Mt0e`j_1gbcqRm-sRE`6 zn-qtlZH=4A3Qzkj9dI%IoD$`L<+gTlY(zt`cA1?FX#Y&s46XfB*X=2x2%CfJ zo@qnFF8h4+J-6H@$rj~TKb~-?IV;3kO2-(rda7%u67#5H_X9d=qb-N#y>dFU5nhF; zxdG8twSQzSC+m72&bjl*g<$E?Gy@^e?uVDadVE6)dlb%ZP)uBTJ#Abhpqa0#^WYS! zNyWtygOFX-1of$~?_w+81y|D-&)s|gH%U;p<)X>%VR>bzE zvhENltc*CZpYLPKnPD>##Oo{_1UYfT`wP2`V+H(#dG|`gWz}?iZzFW-p#v9C@4Uou z;eyIm`ds;-eUyl;G7_L{|MNR(P8{OvqY-;~%u`?MHb`+ectNdIm>?FROlcG%9|y4Y zB~aeG{!ewY=@i&C(+Bdc-T=uvz)>G~Z2G(W47vk;8}{&b`@TGHmJtBSb3dg345fnY z)H~rx?BHw956?XS%?R+V0@$w0*t_|AJ;OA3OE5E5$8X(L!op8COQ=(_u1)uSle$KJ zfaYTY;{|@=O9BEkic2_39@9qM(qs2T9BeCtKwTT@Htj;qafcvxRzrf9W=L-BeU5{) z0G)#s$@W^09^tGL_w#}c6WG}UYUk>$WzP}k|PevCcUDo)M4=iaM0mG9J zNZBc9daPwE=aoR!w!c{Fqac427G9IV4xP@!q(uOt+<@I_&H2`bfSj#kRQv+_^cc|2bF8Sts%;j=1uy}S z(90na@7H~HsP3!QDl(b(>6^>0z3X&$ocv@qE%a}fUXjF1-y9GY8?6?-+wOkaWFJy* zLbX5hsv#1_|GNqPK6nP~LE!FJ-icE4ogq3!#`K=)>6H-cZcF zqok61`Cj?^8T0v1?QBDjW*S0GBq^pG43HPvI7m@{$uCfh#rN~qFS#{kDa3~I#tE0Uc)1CiC3VNV%G)>FK}b0cATvKg~&fsu$D0h{|qAmH9?S0w1#8}k~3lQ(8qEDi5A>> z$n12OL>;PaH$5d$07keXKFx=Q3ZYavR^n&QJM10CX`0-4FiR;ljMtUI*-uIStK}tf zCCgQs*;`n>5mEN|&-9Z@Ucq5E1@I){+R}s{=-FZ-WCdAZq^MHR@P7-U+SCLpR}2Q# z7!N1lZ^QII**yr5{Xq2fgQd#8CJT|5Ni^aV_fVqR^MSAhi`te*s@?b-hdaTX4-2&3 z2;%ecerMhJR`!ubfk1`(JV~#JPH-eIY!>7rGrFA3r+so0JSEK-cbn&+{^>2b{x)JV=a6|Wdlb*x+m%M-t#?+V% zVCq36Tf%0hn+Kp1dYf4R=mg%BuJ42=lwfg$8Uz|}6gtajT?HAk>Lfan)w|p7FXOMj zxyGEY@>04Y7DIMPBtO*8a)O2vIxyFM*_g<(ISm zPLGiS{9c*iAWa`|dO)W*`s=aU%#5_G=33a?s$YwB(N={GTrnK1_o=`ef2B3q5ab8JHNu62P5ju9p7uFA=_uZhH1(?v9`*soP7Im7~W;HP`F=7P7`5o+$^WZtf495j!XEiI%MIWjzMH^6Qs_ zZ&~!FO%VPk_99pFThn0Tw_HS&Ihu9T%tbO6&17Vp~Naa z%HXJqInI9d!V`QtUU11!($C-!xAcM=`rTmIk$`%j79vA8uO9dLQV>RyVHjhMdS& zq&ISaiZuDUCGEdsF#ik*K6H5Zha#dNeg0HP@DAyDe7k_y#(ck_=t3drF*W$BE%fNf z%J?YX=jeBM;2`o@M^knovO@#$!|`vZP{$Adlw9qr-(l7E6+`W% zM(|=7L7fT+-&+nj@D&v^BdJd;8JnIek&`+|3FSc2G@y~pEw z^hkZRFs~E-@;%563emexy5M^!A(bYbr`{WE(Ogfb#%}q^Ek++-3N@hiF8{i)uM`8Y8{^Er#PweqZmO|9OU)FD_bQo@a7~=3A?RO=={*~@lin5g}l37N7YD=B7 zxQUrkxim{EOu_SlrSCIQD(Zy#bEECx$bR%k()lnb9FfiGs2F^RannkU$e3lMQ-;*60>^J1R2}9QObbCL;GNzJyb_Jmx8upV zqope{%r#cZL`CcxYfL=C_a%>~+ut(d)FN)~9AzRxRE<}JcoK=T^2kOD2p-Hl`jicH z${4U(N6&edjB1|F%cH@5#=i-z;4>H2Pm16*ire7~SxU&4AcXcTRpH}60gZAYtv&n+ z8^XM+dNKKY##+7Pq8GsUr)KysNei#VIg)m!<)BM@T~^|Cnh=Cnd1;Bmn9zD6sspta~TA}saf%Fd|8 z(U?SPW&%G2u8cOf``ftI1SNOU^IhVPz!*qLL}X|>#N1UXa9K*EZI0GI^!3Pl0_ygJ z3Yx=Sl=KzdylY?H`%bDTew~LI%@pb7zGc{Bd1kwFO3R9Fi!@@r620(e5m-hFHhmkJ zv9zea;>0%Dnb`g1pf5G3bq$r0*fk$Cc-t~#s1NG#yVr-8AmcatN}G>4_`8FcFd|7o z2o%xumtMqd*yix|i*(C6^P#5y653pj)$M`Y=hINliyujl1CYa3=a-tTE-&b|9wvQI zsgtXPZ+cct0~-0y$TXo=bzE80=d$8CtE-q9sexT1P6GRF5~#hC7bbjBxR&N*33l^T ze>>LiagB4wo@|+CANpIpuW#LOB}A|n3?NoAXQ(EJahXA_{%_BAxDqm!9Gu{9fxZYI zYoP~O0Z5Hi+;+Olwtf~%qqQaJZjyvyQ_OddwnkKuNk59@2Gp(j7DluI8^7x?eu8~} za6&W228VX1YcI%{Hq@FO1%ej(*Xat)3gZlfJwta;D?U+D%js)Z&HZh3bM?4!;k_>Y zw?&f_bgQjbNq*}R$i9`Bj|>;f|3d2sG?~D1!_4pWbnan9QtA-CY=)Zm{qawTE$c2f zSklkSo6n23LNb1!dqNLI)gUooIFEm}L1lPf=h&tby}hzJ_p9JnHObpw>Kur;!sBqt zr!(n4wGe|F7aFg}c-JTw?)Mr+kxOvzV7@@Ewpnhu z_g+i>)(!>nLHZ?MBx2f&%#|r`+19^8ec8Qz+RA!0%}+JA^Bqe(mz!7#dIsDlJVy+l z$0&HVEFPRweOB~#^lETdl&xYq)QXDN$fWeVMh&PhX8Bho$~VkMt}u@+G)Ui z=G5gGc-wUx0)*jl3;q)Wu^c$|=-(SK5~RKRx6{A4)4Qe_Am7@rX%zrfPXobo$}@l= znk@Y@O1>d z@c%(>gU_EH4fi?T-j5N*i)|s@QDEV;JoxGIRcMbBj6`?S%=u)x~BI_ zT3uf>{~yT*VMm*)IG}1@_!Kh3=lAsmydWMhwfZ_S1RmZ8(K24=O9vOm0k4wtK3w_4 zo@*oFnhJ-*ob{y9dLQ2h#9;S>?sRpq|6MZ}DDDB~j!!dy-~&1kkn{w0WY>9nw_F6p z+`j@eScdbv)p7X{iM`)o@56{m+Zpx{VNjFKt9|yR$gp{AwD{FN#scYB^j%Iw^gt0u zWX{=jw4Cv|Visew53%+~Ao{V|_Wtx^db9+^E4T1;fiKmjCH+N2_1y6_Jbrj3q6|q| zBbtAE-_UNDDK(t_F#)WROQj3TU~=4L;IX>*21drR&}2^)|C#IcevATC<)1Jf&c0r8 zY!-AzOQ8s&q>lyMq$Y{7!kab@y&Q8xJt%Xj=z}~0bm6*Wkrc>p;vz~)cC9>r5bYy6 z_X;B9bnTt|rP|E1<7a+0dq1009Z812GNBb5AGIma<+{$x{$H4940!+)WX3E8wF3?H EU*vuGmjD0& literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..ec676abae --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9252', + 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', +)