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