From 11b46338d7374b0763332bf99402b84581145438 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 1 Jun 2025 14:09:09 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 +++++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 213 +++++++++ AMR/datasets.py | 77 ++++ AMR/functions.py | 665 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9290-py3-none-any.whl | Bin 0 -> 10175 bytes dist/amr-2.1.1.9290.tar.gz | Bin 0 -> 10021 bytes setup.py | 27 ++ 12 files changed, 1393 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-2.1.1.9290-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9290.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..434be29ce --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9290 +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..3f906f72f --- /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 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..1e662c39c --- /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 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-2.1.1.9290-py3-none-any.whl b/dist/amr-2.1.1.9290-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..43414941ec0dcc91b7473599d833aa4854b233b9 GIT binary patch literal 10175 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..a54a7fe34 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9290', + 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', +)