From 9828188b1e5aa3337a7e291acebbd517f9450a1e Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 15 May 2025 11:09:21 +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.9277-py3-none-any.whl | Bin 0 -> 10175 bytes dist/amr-2.1.1.9277.tar.gz | Bin 0 -> 10047 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.9277-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9277.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..3c513e9b2 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9277 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..0dd6e1f18 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,213 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import eucast_rules +from .functions import eucast_dosage +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import custom_mdro_guideline +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..63c92aabf --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects import pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# Retrieve Python AMR version +try: + python_amr_version = str(metadata.version('AMR')) +except metadata.PackageNotFoundError: + python_amr_version = str('') + +# Retrieve R AMR version +r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +r_amr_version = str(r_amr_version[0]) + +# Compare R and Python package versions +if r_amr_version != python_amr_version: + try: + print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + except Exception as e: + print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +pandas2ri.activate() + +# example_isolates +example_isolates = pandas2ri.rpy2py(robjects.r(''' +df <- AMR::example_isolates +df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } +}) +df <- df[, !sapply(df, is.list)] +df +''')) +example_isolates['date'] = pd.to_datetime(example_isolates['date']) + +# microorganisms +microorganisms = pandas2ri.rpy2py(robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]')) +antimicrobials = pandas2ri.rpy2py(robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]')) +clinical_breakpoints = pandas2ri.rpy2py(robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]')) + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..0c707e39d --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,665 @@ +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects import pandas2ri +import pandas as pd +import numpy as np + +# Activate automatic conversion between R data frames and pandas data frames +pandas2ri.activate() + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, pd.DataFrame): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + elif isinstance(r_output, DataFrame): + return pandas2ri.rpy2py(r_output) # Return as pandas DataFrame + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_class(*args, **kwargs)) +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_selector(*args, **kwargs)) +def ab_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_from_text(text, *args, **kwargs)) +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_name(x, *args, **kwargs)) +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_cid(x, *args, **kwargs)) +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_synonyms(x, *args, **kwargs)) +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_tradenames(x, *args, **kwargs)) +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_group(x, *args, **kwargs)) +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_atc(x, *args, **kwargs)) +def ab_atc_group1(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_atc_group1(x, *args, **kwargs)) +def ab_atc_group2(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_atc_group2(x, *args, **kwargs)) +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_loinc(x, *args, **kwargs)) +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_ddd(x, *args, **kwargs)) +def ab_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_ddd_units(x, *args, **kwargs)) +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_info(x, *args, **kwargs)) +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_url(x, *args, **kwargs)) +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_property(x, *args, **kwargs)) +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.add_custom_antimicrobials(x)) +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.clear_custom_antimicrobials(*args, **kwargs)) +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.add_custom_microorganisms(x)) +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.clear_custom_microorganisms(*args, **kwargs)) +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.age(x, *args, **kwargs)) +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.age_groups(x, *args, **kwargs)) +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antibiogram(x, *args, **kwargs)) +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.wisca(x, *args, **kwargs)) +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs)) +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs)) +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs)) +def antifungals(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antifungals(only_sir_columns = False, *args, **kwargs)) +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs)) +def betalactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.betalactams(only_sir_columns = False, *args, **kwargs)) +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs)) +def carbapenems(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.carbapenems(only_sir_columns = False, *args, **kwargs)) +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs)) +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs)) +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs)) +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs)) +def lincosamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.lincosamides(only_sir_columns = False, *args, **kwargs)) +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs)) +def macrolides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.macrolides(only_sir_columns = False, *args, **kwargs)) +def monobactams(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.monobactams(only_sir_columns = False, *args, **kwargs)) +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs)) +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs)) +def penicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.penicillins(only_sir_columns = False, *args, **kwargs)) +def phenicols(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.phenicols(only_sir_columns = False, *args, **kwargs)) +def polymyxins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.polymyxins(only_sir_columns = False, *args, **kwargs)) +def quinolones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.quinolones(only_sir_columns = False, *args, **kwargs)) +def rifamycins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.rifamycins(only_sir_columns = False, *args, **kwargs)) +def streptogramins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.streptogramins(only_sir_columns = False, *args, **kwargs)) +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs)) +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs)) +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs)) +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs)) +def amr_class(amr_class, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_class(amr_class, *args, **kwargs)) +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_selector(filter, *args, **kwargs)) +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs)) +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs)) +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs)) +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_ab(x, *args, **kwargs)) +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_ab(x)) +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ab_reset_session(*args, **kwargs)) +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_av(x, *args, **kwargs)) +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_av(x)) +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_disk(x, *args, **kwargs)) +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_disk(x)) +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_mic(x, *args, **kwargs)) +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_mic(x)) +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.rescale_mic(x, *args, **kwargs)) +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mic_p50(x, *args, **kwargs)) +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mic_p90(x, *args, **kwargs)) +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_mo(x, *args, **kwargs)) +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_mo(x)) +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_uncertainties(*args, **kwargs)) +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_renamed(*args, **kwargs)) +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_failures(*args, **kwargs)) +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_reset_session(*args, **kwargs)) +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_cleaning_regex(*args, **kwargs)) +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.as_sir(x, *args, **kwargs)) +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_sir(x)) +def is_sir_eligible(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_sir_eligible(x, *args, **kwargs)) +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_interpretation_history(clean)) +def atc_online_property(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_property(atc_code, *args, **kwargs)) +def atc_online_groups(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_groups(atc_code, *args, **kwargs)) +def atc_online_ddd(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_ddd(atc_code, *args, **kwargs)) +def atc_online_ddd_units(atc_code, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.atc_online_ddd_units(atc_code, *args, **kwargs)) +def av_from_text(text, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_from_text(text, *args, **kwargs)) +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_name(x, *args, **kwargs)) +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_cid(x, *args, **kwargs)) +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_synonyms(x, *args, **kwargs)) +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_tradenames(x, *args, **kwargs)) +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_group(x, *args, **kwargs)) +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_atc(x, *args, **kwargs)) +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_loinc(x, *args, **kwargs)) +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_ddd(x, *args, **kwargs)) +def av_ddd_units(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_ddd_units(x, *args, **kwargs)) +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_info(x, *args, **kwargs)) +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_url(x, *args, **kwargs)) +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.av_property(x, *args, **kwargs)) +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.availability(tbl, *args, **kwargs)) +def bug_drug_combinations(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.bug_drug_combinations(x, *args, **kwargs)) +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_resistant(*args, **kwargs)) +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_susceptible(*args, **kwargs)) +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_S(*args, **kwargs)) +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_SI(*args, **kwargs)) +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_I(*args, **kwargs)) +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_IR(*args, **kwargs)) +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_R(*args, **kwargs)) +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_all(*args, **kwargs)) +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.n_sir(*args, **kwargs)) +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.count_df(data, *args, **kwargs)) +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.custom_eucast_rules(*args, **kwargs)) +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_rules(x, *args, **kwargs)) +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_dosage(ab, *args, **kwargs)) +def export_ncbi_biosample(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.export_ncbi_biosample(x, *args, **kwargs)) +def first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.first_isolate(x = None, *args, **kwargs)) +def filter_first_isolate(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.filter_first_isolate(x = None, *args, **kwargs)) +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.g_test(x, *args, **kwargs)) +def is_new_episode(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.is_new_episode(x, *args, **kwargs)) +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_pca(x, *args, **kwargs)) +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_sir(data, *args, **kwargs)) +def geom_sir(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.geom_sir(position = None, *args, **kwargs)) +def guess_ab_col(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.guess_ab_col(x = None, *args, **kwargs)) +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.italicise_taxonomy(string, *args, **kwargs)) +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.italicize_taxonomy(string, *args, **kwargs)) +def inner_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.inner_join_microorganisms(x, *args, **kwargs)) +def left_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.left_join_microorganisms(x, *args, **kwargs)) +def right_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.right_join_microorganisms(x, *args, **kwargs)) +def full_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.full_join_microorganisms(x, *args, **kwargs)) +def semi_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.semi_join_microorganisms(x, *args, **kwargs)) +def anti_join_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.anti_join_microorganisms(x, *args, **kwargs)) +def key_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.key_antimicrobials(x = None, *args, **kwargs)) +def all_antimicrobials(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.all_antimicrobials(x = None, *args, **kwargs)) +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.kurtosis(x, *args, **kwargs)) +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.like(x, *args, **kwargs)) +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdro(x = None, *args, **kwargs)) +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.custom_mdro_guideline(*args, **kwargs)) +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.brmo(x = None, *args, **kwargs)) +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mrgn(x = None, *args, **kwargs)) +def mdr_tb(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdr_tb(x = None, *args, **kwargs)) +def mdr_cmi2012(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mdr_cmi2012(x = None, *args, **kwargs)) +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs)) +def mean_amr_distance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mean_amr_distance(x, *args, **kwargs)) +def amr_distance_from_row(amr_distance, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.amr_distance_from_row(amr_distance, *args, **kwargs)) +def mo_matching_score(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_matching_score(x, *args, **kwargs)) +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_name(x, *args, **kwargs)) +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_fullname(x, *args, **kwargs)) +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_shortname(x, *args, **kwargs)) +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_subspecies(x, *args, **kwargs)) +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_species(x, *args, **kwargs)) +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_genus(x, *args, **kwargs)) +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_family(x, *args, **kwargs)) +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_order(x, *args, **kwargs)) +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_class(x, *args, **kwargs)) +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_phylum(x, *args, **kwargs)) +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_kingdom(x, *args, **kwargs)) +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_domain(x, *args, **kwargs)) +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_type(x, *args, **kwargs)) +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_status(x, *args, **kwargs)) +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_pathogenicity(x, *args, **kwargs)) +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_gramstain(x, *args, **kwargs)) +def mo_is_gram_negative(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_gram_negative(x, *args, **kwargs)) +def mo_is_gram_positive(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_gram_positive(x, *args, **kwargs)) +def mo_is_yeast(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_yeast(x, *args, **kwargs)) +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs)) +def mo_oxygen_tolerance(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_oxygen_tolerance(x, *args, **kwargs)) +def mo_is_anaerobic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_is_anaerobic(x, *args, **kwargs)) +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_snomed(x, *args, **kwargs)) +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_ref(x, *args, **kwargs)) +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_authors(x, *args, **kwargs)) +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_year(x, *args, **kwargs)) +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_lpsn(x, *args, **kwargs)) +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_mycobank(x, *args, **kwargs)) +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_gbif(x, *args, **kwargs)) +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_rank(x, *args, **kwargs)) +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_taxonomy(x, *args, **kwargs)) +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_synonyms(x, *args, **kwargs)) +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_current(x, *args, **kwargs)) +def mo_group_members(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_group_members(x, *args, **kwargs)) +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_info(x, *args, **kwargs)) +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_url(x, *args, **kwargs)) +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.mo_property(x, *args, **kwargs)) +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.pca(x, *args, **kwargs)) +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.theme_sir(*args, **kwargs)) +def labels_sir_count(position = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.labels_sir_count(position = None, *args, **kwargs)) +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.resistance(*args, **kwargs)) +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.susceptibility(*args, **kwargs)) +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_confidence_interval(*args, **kwargs)) +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_R(*args, **kwargs)) +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_IR(*args, **kwargs)) +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_I(*args, **kwargs)) +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_SI(*args, **kwargs)) +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_S(*args, **kwargs)) +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.proportion_df(data, *args, **kwargs)) +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_df(data, *args, **kwargs)) +def random_mic(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.random_mic(size = None, *args, **kwargs)) +def random_disk(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.random_disk(size = None, *args, **kwargs)) +def random_sir(size = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.random_sir(size = None, *args, **kwargs)) +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.resistance_predict(x, *args, **kwargs)) +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.sir_predict(x, *args, **kwargs)) +def ggplot_sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.ggplot_sir_predict(x, *args, **kwargs)) +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.skewness(x, *args, **kwargs)) +def top_n_microorganisms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.top_n_microorganisms(x, *args, **kwargs)) +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.reset_AMR_locale(*args, **kwargs)) +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.translate_AMR(x, *args, **kwargs)) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-2.1.1.9277-py3-none-any.whl b/dist/amr-2.1.1.9277-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..9d056e08d056efe28a9fc4f15c80525140e6786f GIT binary patch literal 10175 zcmaKS1x#kkmi33bySuwX<4)u5?(XjH(D;YD)401e(71c!(zv@$-%!?DKi-uSlL^-8W=D- zdZlVjX0CI>cRkYFfWId-@!YMLAaxfb^?fTO#^DfeATMdYy(5s$s!4{-_tmP!8WaS8 zo42XNk9X!t>ev-%Z(b)E*IXW%1NTQAqc+uP1?2=o8P1$zy;_3CNrP<5yTG7Y^g(&1 zgL3Z8f11|PIF}m~%;V}FU~f|5$KJMBK8WP%#%Tqy$5gmh!BVb-HR)ZIpYISFw=u18 z+O&{0i?h#U?`5KQR?D{%viWj@y_5&?1s7Jc$7gaGa@ZJhRN|MGr!Svj*o?6#)p(!; zBeXTEioHkRJokc3B~MNxcxmoMXowo@{X*s)r{S4Lk?>-UXK~DK)Fb~1hh;%wQkt2; z$;vxM9urlroQ9>#{bO}YkDia#YSS=E5p<;pwfuF2$btcqL0QwG4iRs@kVCPVkeZJ7 z6(pE!8BX~Q6pA)=Xq8VhJ2WLRBraN2A zKPfTUz$E_jJ9P6mVfk==J=Bs)Gx#s_lm1a37YfA)wo*dm8LS1r(G{w@G<8*KNsU+L z6~5A|4&aw@=y=VKJbQ+AqFdx}`*pC(rZ9;F;{jjgG75>BCX$DmRSu~+1{;0OXBDgR zjAumEl)}Dua!ut2vKF!H84r{}YqMQ@R$kG!i+%wdHN>M(Sv>V4ZmS=uQ_@!Nql{;z zOVt-rFSw?tE7R3v;?>5EX88;IJeW9aIi@f1<{6J z&>=!ze8mN)Ocvu|cXK)=Rs^J*bOod`>2}r$;6V>2GK2|E7QcXtBxmd7HBUw3MtP(b~G@Xdh zI)-?rH4J}hI~+^I$Osm}FK2d$wXFDB@)nrd+$N!!g69nQJW2nYIp@E%*w|#zVUi%W zxc42RZE)3g38>d8=9 z!GRD>gDtNJ(ub#*U>$Rr7!6S;*MjOHP5C(i-fQ!K!7$t;nL-_&OVT4W0h?j%u)PrD z*{h#uAWtkBNcSl*%2UzGFL#gQd-!~_5NLJ(f#X{cme5O% zm^-?AN^8EyYF_Ud;Ku{Zwu*W}Gak18;(J zKNJ7NmlQGivKGG|vPO$%ie+a*l>ng$vZzICs;=ml5PrQ2e++{~K-<7?lLh3u-~+nA zH0DfTUw|4FIh-)xrM1Q(?PSKxQOSvqFr5|iT{4cV`TWB@My4X@%M7npdk{ea6}Usp z*?Bx$7B0WpIVpk5x?zPHn-=AS2%ow>cs^)n#^G}CTp*|>W#uwG58T{!y;gm6k z0WcfhiI*e&WIM(asTlX7CHT=warGFn8^CPE&F8hRngu>w7)(x`TZkT(gF2rd?-zkAb4-{QFbT@%Z~180TDE+_ z@`k2|TYMxsiCcTuL_kClA1CiH>YV^Mx`tQ@cVp0|b9Z8g>`va*RDICVjmlwD`T5m% z{-Z}hLDAAyE>@?hhm?)buY(_VOp5=u46AczzP5q^0RAw4FT zlMjl{CdvJ7!aF~!#~1zYhu9Ombz38CQt}AXcWmhb?F*D4JI304^Cj{&U;1+H^}0qs zH9!5cwrYBHM;@VVq{O7mR0;Sx01M^kT-4bF>{?8PXvSN({{4_}j1OlZQ^V(j^wh1o z+9RQXbIXnPi#p~(#(ZnsjPx+IRhu+X?>^Z{`S{}@0E~VTl{F^{yPF)G_Kp{ZD>nwa zkS4>D@C+5pGI8zZZ3vIug)iQu_Fd*;{#PG$A;t<`7;B#&(+KBd1GGo&@O-lf!ekY{ z+PcUkzIpDr{1(BeQaYn3c$yEF0ji>8G8}if-R7W81i6uHC7@VbIYnNjm}xcTr&^xX z;2{#RTqU|e-}FH7BZFzLs&x&qOl#WJI2zW-mQH}3eAsZe8BK6*!$*M4WF@cD;MC#w zY3>8LT~4l`^x_L{>e^X;#D3jo_AbF1z~L^43o zFTX;YAW|h8t7D9lM3Q-dR$vP?-3?mSr*4>)I(hoI1%DlT=ho_z5TwI+z3y>*3-lVm zZ5*z^rJ=JdFje4Bdm<2WCpZLSJmlLiy>>{Bs~UeV`I7lBOg!W2miK9Ord+x=V+0< z7mWEebOyvL(*C1I@ALGnLS%bvoA^=xgKIU?Wc?=NEyU(~mm%pEuAxudCtVxxplhFd+IQ4E?em!n zy|FigX;+fMsK-bU@b4PmZTW^;3kLvD*8u>?|L>?}?q+Y|YUN=6m&g}$gui8TV~$+j z(l}oPCv2GXg+1V~}F3JhK3xu$!Rx+dedBqoAFpi~f zeXjbq^!wLUrj3zT+7n%*PJEQM&%(@(UOisqo4S46`^nur=CHL;25-oLyJD&4%H%j4(<#yWEHv9Mqy3;l{)N~Lx%ivU<6CIJ zNAR!5pMGHZNYGu-N$m)Z`&S|Tov@jClK(R!rn@zm(nHnvg3fJMq zJY!HmFZrjy+#8KiL}*4UfMbn)Rgm&Ik-9IR_Lw1HImZ;uhO&u-v`k>+aj$~W2g{UE})`9M$%T%GQu-Gy}TRw)|X5_HbbQsXL z0$CkVz8-}jD%P1NXNE_IrVi6c`Px{~6Ed$D-K2Las9n2D>*K&Xzr?=sL(C6pxryhO zn^vDisarC}gKXYK&+AG__^){{xGlWZ#l-QB0?Sp$!csR=ZM+`TDM8ciAa@Ptb6up- zxoouR$ID3C``7)A&N7QvV2Ic4;iQLrRB2Qxdt#h)u2m^co8s#FByZb3;C_~nhdrAL z0|j9xFR6&7`Qz@icKcmGC>ZHPzY>)-=SJ7NcS>V(x^M$wKl7$WZYMOa59$Pgx4|*-L7O778=AGLn1MF&3T}TEcPfh zMVgaC8>P`TH!mHZ;T?WGrCZ|(r7;w+TapCzCS617O`*#g)G9GK=k-z8x6UP4utgn@=^sAXxGcToXdR<21U*v`NSnsB)+dz)JxH5Im%%bn zFlLm1oPYZ4BBa7*b%im?(1dj`UlL}6((f8pnRut)|OEJ)OAtl3sQp zNu~MPL!37cn4~gkP%RdrC52z9@-+WK#r+Q^~!{S|N1!Sy_>JG6ipL_ifqJSG? zIa!0gu+|$2rT5B`nS@P0lkQ(vWpl($;!2$vweYb~Qi&aCZB%GlR;|l+ni31$ZSDW| zaX1q>_pqo0v-N}Dx+cHJbc2l@v*>Q}sT+dT8aiVBD+ch+?iW^Ozhowv>~8!_@+#g# zVy0myJXbUYE!j4orD?MvUhBNNoma^EY8{30(*E@(=n|`K@5t;3{V6+{5Z`c>Pd|&9SYAz2QB}28p^~33IOG zR^;o^H_&-ncrG|E^cxK&Mn#LHOmpq~CPd&0Tba?d$E(@E?{6G$x{)~8-mp6S_3pC^r35?uhtYNX~p%IEcGGts_j%t!I%|L^+R~SlGSSOrvG4y z711z?kA8y$g6)OVevigviQur@?!#$wNpi|uQY~Svv3`*TS^nN9kD{|p>B(h~Mrk&1 zaW_w|fU!7Xe;#w%zjDgamYJ`Tw4>X|5ySaw^}I&{@Fn4?c|j3>Ay9J8eS~MAq#!2J zWP^LB8c$<(xWh?Ag-hOKW5%lg4oy32s^6>X0S37*o_@0dW3c1ZGHr6b`IQi)QW9rr z=pf})yfMoW!Pz1mRjMStMM;;zNgCk_ zJ{%Bh{L8x`@+h_3KF=*kWe`8ROb~e(FRU5b{FriSgkN4y>`wa3oT^_8=2+$>SY-^f z=n=^5BYMhgvC=hi)*~5sqEu>1bMU=sHqkND1ESa`6HsC6ORXjv|3hd{>KpSruyVu0 z4L&GMTuftKE?3&H6x)~P`}Vh3b9&nm(WT;&hHVt0_(KN zMw9q(^!(d5&mxk^2Dw!wNl|U$yD!L+qL~r5cmF-<<-R|gFc265JHS1PZILi$NkZXTIv&e6=oN+OiDE4UpUE>l%P~If4L3{2V`(FKc*HNq#`I;x?ow*DENfpVe+ z{bc$^gRY6+Todl1xV#}Od|%W40|YnI=+}3a_&y!p`p#aT-Ixr``K_uA+vhxcGSTv@K7q6`xMyl>$XBiztEEPInrwcG3 z?@L=rQ86oP)b|^~r=*iJAyJas3{8Xf_cz#yeOZnhmdG^(-}-bcH!4}Q>pkx_M0kfE z<0Q8jn!0~%jZyNx?q-5jf&u7cM_IHkvEVP&S8$}ZR01Zk(pA& z^njRv=?mkvCacxD;I&kL&r1_V#}2B_$^kuAxWF3!3gvwDdccv+S8LW^U(%2zDZGXV z{a>E~^`}^WuXa1X%<*@p1z#;dVkbYG547=)Rqxl()1XvLmK$CmOi=UYtEHQ$rjn@j ze%BiP{eDL+5u{W8{_#CJ{mt@G;8>UTJ4GAhJl#O&7$1P^LN_#~Kph$Mj`mK8Hbh$@ z!Es^Mw4;<~@P*j}#Yr_-Zx|MV0s}!GqR};3ZxmxsN}~qyx(l=dHrf@*HqyQUZ&gBL za7<9<_w%XAI9{;>Dg3S%gu+Y|7HVxMAa5D4g+@6eoj!64dj=q4_{9IU0>m*!_5i>2 zG~uOmlwK8Y`q7bUgmAFJMyG5Q(yj#lXBR8&46VqgU^xqIjr$JLt+-gL94Vv*?OIt0 zp;`=AjtMBEtr3qA`));X!ENqq)gK{bo=yA1BWfu~emo9ZD`Ha^zR2rYAPr+#L1<{T+fC@TV@wD_2jda2Lni+-2O$88bxtu88$+KTYB|{SE+k zJPBKPE6j9%+y_+S`|s`H=j}Rerg?Uk5fPB(Xtms@I7O7k~W9h>v0k~*43iZgT$vCr|;rc8mhKfhfg<^vbPucb+2L}=EDJ?Nq z3h)bsb!vJ}nz=$Pk*@W3qQ4LK)PL%z<@=RMwFm%!0~G*3^5<}GWarGl%E#SciK_~W39AY>YoFS$|HSyHEldAGZHt3i(Mb=Yv*1*-@dU~{dNB-h zhQgC%F6XR?Xr-frb!2mQ|3dygl|UBVaJJGX5%Ya?knOjB773F0m|yPAp+%x)MIp;6 zclR0!(op(2QSOp@pWPeR34BCzBR#xV0|1m)tJnpjJ}Y#jUTQ^^f<6aMdsJR)qMJ?t zt=WSXeG*&4gi~Q&^P8Rr<-8ZC6CXxLL2jg&SdV+umOo_hXga|Sd(QY4hfjteJt4dJ zPcvrof}$Mb)vd;vEFLArS7Lq?D`qdBn;Izw=xcKkH#H&q4K3)z6itiY=S zs7#5ZLi5S7Wh9}GJq2FdJS8fCMiXi7@NtQvw1jc=oUf!rV%58z}h|5 za)?UMr{mqaUX+f-{fN_vJgZTpJP$}jsf_AreK34WRS%F`)cF3P{r#h(1Gg}JB6_7z zaW~rsnqR-o5#mux-HSzoORi&H?#80K{|Q|A?*kf<@(W@@~ zL(PWwOjh|~ZU6zqb{@>1liK=AD&fJtSCFqVvC47JyM8HqTFVpvJk2wLfXP$8CR)w! z!!K#|2$p0f*InwT+($kdph|&%e%903OXd|`mf*_^3F{1sw6*ZF^^LH1_GFqfu-GW- z3Z)7Sl8zLM8z!tf1nX%i*zX9zy@q*|II!?8iB;6Pi9sh58nGkC%F)G97=@bG5>K={ zd#Ll@N@XVIL5~3}&c27aJwERRV!Ea~xTH8yAB+$jPSftJau5&Mhp}Ht?WL(^bBcc7 zzqIMLRwDB=4Q);o{Y-%DEJaPknhlwMCzH_QR{Uk*R1)e9^DVnrD-o2=NU%AqkejvgqQymK&`_kr^ zCrbJ$2~LU;d-eEv`Wi8}_6G4qau;+&!n@rnIs{bV@g;d6Br8bEddrq4KqhPAUxl&o zLx#~yxgih;NC#<7!<`a@@HKvO)`xG(FzZ}2<56C;Cb?$iYbvA8+e zb*1JL%GfKxhFay@w?~i+Av4>zpbq%RSmj9t78a@2U%fVxYlbi0@Dv`5f+s|#a{!m`9PwlWbk`m9#M-9QjXQM!1f@U%!ol=3B6pK@H z^27ZyC?RYr9?U?s+#b2VvBC0U6`7j>9s~K4zuez#fMKCbxJy+4g{6>4qXeQW8q7VE z&4oC{39cdrxlmA?SaYaahpSSL+RltENi!)8h2|>-5K13&f1Oih@nTUh*q%1b>$o76 z>EtGCfi~Y+cl@@~Q~QFVoZR-D=%XVnI-$%zUb9&6{j%%ePSWoMq31yH=aagayG1(^ zoI>#`(Abeb-qN!k5tA;pCQzMA=xY5td01h;j5RZz%%q}ehfL46B=_LjFX|R+XemI4*26%j=HBQwdY>$_MT27=Q^Z)2$+Cq^9$% z$^!m8t1m6)yNCu$D`*pKu+AwQ=7M76Uf8LoP1=uXBwrKIzIMLikIFq0MXQEyKUQ8G zTEC)8l^_z87d578Bf*3RnDL&ctzWpEV9rs@=r5n&A)Lj#>F_AG>R6<1d0S1x+#$SJ zZo5lD1aSpNEPR>zHsLy0mPCQKF0(AukEz>0$aIPuu< z-x}-Y0xjlpea$N7bHe_!)w3#R)+U^_NGF|R_IJo^6Ywf08fN)Jj4D!Q52!gvv|2y> zy6BUBrXFRJii+Z&mjNw4$X&l^Ih9Eo?ig%YCu}}dAf+)rjv-GG7=_`m>gKfuMk7g$ zb(5^X=N58HO{r0nRWJm-MqehTya(~x@~d5QeEU6R*~-iKvB<@yHKIk*PO?rlJ^cVF z8Zyj`Z*^j&*=r_kI#wa7O4q+%Abpi0ay21+RowI`PvHqCo|%~LoJ zV}o_Q3)Zi$_|48=QZ9!?d9upr6EwuxiV!hr&n9m<5#^tG5-F2X<=cOWaIKh`rOg8a zRXg&7JR?EYqzw!;Mr)13n8~>1sDY;{ApOa2cQt%L+pdKygMcJWj#yKbwb3JKD)y{| zXerKE(dH94co1PBu<2p+7O9`H3+T1H?hs5*(YwG&N@r`9qZiUcb4$7lM}&?Kh~X;U zaF&ZqsNi_53y2Rglx`HOTeI7p^9e}kq5JWe*0R?KN%gQC`i|iCB5T-V>31VcC?Hb| zO{wxg<$-cA0jHz5-F_-R5k z;~`2x`ADA&>ae;&n^p5qR}%aYEkEt{jW-?PHQ#oLLxEXX^41@~EkvYmjPmhFNLP2` zq^g#CO&LlgkKnxqEEm|1mUAO%mBvx-HY=z1Yd)oTZePyzJ8xBGuu0@MSIfx7_<+Kt ztD=JFRpP~k;!lyh65U3<{MdXdkuk|3(`9NT#<^ZM+Ox#hwj{X(>Fvm64x9LDVNy@7 z(tDR3#DYSRT*$lQ4h}LNZ}sUFjyq9M?@FWbTw3hOr{9_R?jF|^FpaB6)Uv*xJNb&7 z@*USIuCDCQRHCL1A&nx2Kw|Y=u8-3vrGs3gcQNL-Q5%Y@yy~NQ!@pU2&^f51aut?Gn4=?P$q~ z{jOe>^9seRP#gnzMcHwxt4F&ciSPmS20JnSxF%M!)Q_l9HgI_h(Vdo;>YR0SSUG8m ztUjnTv0Y7*{WPs1nzGC#xc4audj!jSfKnNl9|LMx_Kjd8-nI@t+Q#No%%887`viv} z1(bU8;3Gc3wlwV}Xt>+dix}o*^TTax*|~K|zUS81S!}Gg-22w5@j>=H)~#urP11t4 z`THw`HE$3iNWR+(KAu`+7-}%Nl%*L9TJQXRzQ1L0B4~j+@1GmUQzPYXY8O;hRFC0v zDJ|DGJiH-|vApbe?tM7Bi8cV)GTbpRz^$84mVI1r;qgk6e#qB?mwc&FR_@=LVf z2m|vY*s#8HmgvX*WYr=Ec}^IGCm+(H$RVJV#JbV{9Zr-*9}s4zxR;HiZAc}gM_ZF!WiizAIRaTFR{vW-kg~szh~)7=4-dWN>rotR=Tquq(DSKK zQuab#pa?!x12>kzk0v9I+UXs3?@_BQ&J@Y#aR&|B+Mk@+7ikj{o|>NF^sF*x%i!B$r@*Zxbe;S8dlNhFQKMezM(dzYCKn^nfPw}) z+b;fB=f$(Sxc)djI^z&aX@jz(;SiKz5r2w_b+;R{1C`Jlw3GvqFqK!qf6w-)lp@u1 z|73YOfBGNe%>SM3X-J8S%R=yabC>_KC{hcx7)T%vel3Nvv&=Q0 zF>#mle356}=@5J1w#n9FOEr^22D0<$X7oXxQC6|FX)RSHgAJ}_wt2f(C+ghB$ehR9 z>b<7p3La|MrAVZJdane0*yy#`)E@0Z#rbno*&Ccb=$0{dHu^<%9Ge!&7CzT=6V`J0 zy}hegsW2p8D6F?06y9K6?xj6?y*|7}xUV0zTpI~%PELXeoi+Ok)>n!pvy$!af`G7q zoCmpa#$$$V`d6RNiKwV^I=GC+uOb$uoSDQANJ^-fBhK>I>_}8G3eba(*iy9)%QN^I zP=?oViZURe=wSc1ZR^h$`tPSW=&#`)Ca!;i|7kY(A1DA&92D`#3HBHGU#tiJ1po6E z^KY=tAMe6n;D5c-{8#k<|EZ$?W{SVw{tNvgs literal 0 HcmV?d00001 diff --git a/dist/amr-2.1.1.9277.tar.gz b/dist/amr-2.1.1.9277.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..cefa63b5b3d0796fb3de80fdc48cf056e47244cc GIT binary patch literal 10047 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 I1q<_k0G0g*i2wiq literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..0d31c5bc0 --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='2.1.1.9277', + 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', +)