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