From 740aece2cb924ca3544c714ea084bb966972747e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Fri, 6 Jun 2025 07:40: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-3.0.0.9002-py3-none-any.whl | Bin 0 -> 10179 bytes dist/amr-3.0.0.9002.tar.gz | Bin 0 -> 10023 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-3.0.0.9002-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9002.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..77e071861 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9002 +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-3.0.0.9002-py3-none-any.whl b/dist/amr-3.0.0.9002-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..c47dfc1938283aca4011e94ca78609a67f3cd010 GIT binary patch literal 10179 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 uHTj>o{!LB)dSm!1JIf6Cn-Ikr>%b@gB7UHh2; literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.0.9002.tar.gz b/dist/amr-3.0.0.9002.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..b4a3e0545d41314d35667213c40dfa1596396a36 GIT binary patch literal 10023 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 PfT_kK)%0O@U}63b59H}z literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..503c82a73 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9002', + 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', +)