From 9e978ee3ee94a938edcb9d2a8e1299d29ebaf9a6 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 21 May 2025 14:54:03 +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.9285-py3-none-any.whl | Bin 0 -> 10173 bytes dist/amr-2.1.1.9285.tar.gz | Bin 0 -> 10017 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.9285-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9285.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..1695a9212 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9285 +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.9285-py3-none-any.whl b/dist/amr-2.1.1.9285-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..f3c01f98f8dd81c5037bb61783e3c1b9e66b9712 GIT binary patch literal 10173 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 AGynhq literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..0b9ea5df9 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9285', + 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', +)