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