From 805aabe5db7e07b99a6df9ef3e80e72d8d766cf6 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 16 May 2025 09:22:04 +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.9278-py3-none-any.whl | Bin 0 -> 10175 bytes dist/amr-2.1.1.9278.tar.gz | Bin 0 -> 10014 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.9278-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9278.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..9d2936497 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9278 +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.9278-py3-none-any.whl b/dist/amr-2.1.1.9278-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..da2206976ffaedae78a44de3439f6a5f0fb6dd51 GIT binary patch literal 10175 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 literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9278.tar.gz b/dist/amr-2.1.1.9278.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..597637c67efa679fd46c56c51102cf3db5156653 GIT binary patch literal 10014 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
Y|=gQ%N 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..e9b235561 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9278', + 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', +)