From 73db969fc727ee1c3aedabc3f6beac24fea38bac Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 1 Jun 2025 13:36:38 +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.9288-py3-none-any.whl | Bin 0 -> 10176 bytes dist/amr-2.1.1.9288.tar.gz | Bin 0 -> 10027 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.9288-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9288.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..4a0eac027 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9288 +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.9288-py3-none-any.whl b/dist/amr-2.1.1.9288-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..5a9b5790bf09d2d6221bcc41c9f793d2c16c2ec7 GIT binary patch literal 10176 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9288.tar.gz b/dist/amr-2.1.1.9288.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..6f81803d652b75864b9baedecd5d7fe3fc4995ae GIT binary patch literal 10027 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 M3LTGu0zyOm7phOw0ssI2 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..c49894617 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9288', + 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', +)