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