From 1df420028d8dfac2e22e800e31e27de109f5e506 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 20 May 2025 09:33:01 +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.9281-py3-none-any.whl | Bin 0 -> 10175 bytes dist/amr-2.1.1.9281.tar.gz | Bin 0 -> 10026 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.9281-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9281.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..e8c23547d --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9281 +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.9281-py3-none-any.whl b/dist/amr-2.1.1.9281-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..b3301a200f4915731b9564924bde61b099ec8a70 GIT binary patch literal 10175 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9281.tar.gz b/dist/amr-2.1.1.9281.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..dfac32d8ca855d4c824e5e664fc08c35108605c3 GIT binary patch literal 10026 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 IY{J6)7fKS=t^fc4 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..ff37c2b1b --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9281', + 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', +)