From c85399c3d8ce67bacbe94778fa4d6744e937ce08 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 17 Jul 2025 15:16:24 +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 | 219 +++++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 683 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-3.0.0.9009-py3-none-any.whl | Bin 0 -> 10275 bytes dist/amr-3.0.0.9009.tar.gz | Bin 0 -> 10110 bytes setup.py | 27 ++ 12 files changed, 1417 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.9009-py3-none-any.whl create mode 100644 dist/amr-3.0.0.9009.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..8874a44d4 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.0.9009 +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..dba238d35 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,219 @@ +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 all_mic +from .functions import all_mic_predictors +from .functions import all_sir +from .functions import all_sir_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +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..101c1aa82 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,683 @@ +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 all_mic(*args, **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_mic(*args, **kwargs)) +def all_mic_predictors(*args, **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_mic_predictors(*args, **kwargs)) +def all_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.all_sir(*args, **kwargs)) +def all_sir_predictors(*args, **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_sir_predictors(*args, **kwargs)) +def step_mic_log2(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.step_mic_log2(recipe, *args, **kwargs)) +def step_sir_numeric(recipe, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return convert_to_python(amr_r.step_sir_numeric(recipe, *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.9009-py3-none-any.whl b/dist/amr-3.0.0.9009-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..b86ff1a387d82ecfb9bc4829a6450b916d4e33fa GIT binary patch literal 10275 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 literal 0 HcmV?d00001 diff --git a/setup.py b/setup.py new file mode 100644 index 000000000..4079d9cca --- /dev/null +++ b/setup.py @@ -0,0 +1,27 @@ +from setuptools import setup, find_packages + +setup( + name='AMR', + version='3.0.0.9009', + 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', +)