From 45101f9ca5203acd55a5d37c81a645d3d28ec33c Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Thu, 2 Apr 2026 09:44:36 +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 | 228 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 940 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9042-py3-none-any.whl | Bin 0 -> 10603 bytes dist/amr-3.0.1.9042.tar.gz | Bin 0 -> 10484 bytes setup.py | 27 + 12 files changed, 1683 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.1.9042-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9042.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..ed421499f --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9042 +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..42012c791 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,228 @@ +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_sir +from .functions import all_sir_predictors +from .functions import all_mic +from .functions import all_mic_predictors +from .functions import all_disk +from .functions import all_disk_predictors +from .functions import step_mic_log2 +from .functions import step_sir_numeric +from .functions import amr_course +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 ionophores +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 peptides +from .functions import phenicols +from .functions import phosphonics +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import spiropyrimidinetriones +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 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 interpretive_rules +from .functions import eucast_rules +from .functions import clsi_rules +from .functions import eucast_dosage +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..bf9cdc0f8 --- /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.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, 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 +with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + # example_isolates + example_isolates = 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 = robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]') + antimicrobials = robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]') + clinical_breakpoints = 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..4f28a517f --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,940 @@ +import functools +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects.conversion import localconverter +from rpy2.robjects import default_converter, numpy2ri, pandas2ri +import pandas as pd +import numpy as np + +# 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, DataFrame)): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + + # 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 r_to_python(r_func): + """Decorator that runs an rpy2 function under a localconverter + and then applies convert_to_python to its output.""" + @functools.wraps(r_func) + def wrapper(*args, **kwargs): + with localconverter(default_converter + numpy2ri.converter + pandas2ri.converter): + return convert_to_python(r_func(*args, **kwargs)) + return wrapper +@r_to_python +def ab_class(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_class(*args, **kwargs) +@r_to_python +def ab_selector(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_selector(*args, **kwargs) +@r_to_python +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 amr_r.ab_from_text(text, *args, **kwargs) +@r_to_python +def ab_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_name(x, *args, **kwargs) +@r_to_python +def ab_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_cid(x, *args, **kwargs) +@r_to_python +def ab_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_synonyms(x, *args, **kwargs) +@r_to_python +def ab_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_tradenames(x, *args, **kwargs) +@r_to_python +def ab_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_group(x, *args, **kwargs) +@r_to_python +def ab_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_atc(x, *args, **kwargs) +@r_to_python +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 amr_r.ab_atc_group1(x, *args, **kwargs) +@r_to_python +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 amr_r.ab_atc_group2(x, *args, **kwargs) +@r_to_python +def ab_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_loinc(x, *args, **kwargs) +@r_to_python +def ab_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_ddd(x, *args, **kwargs) +@r_to_python +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 amr_r.ab_ddd_units(x, *args, **kwargs) +@r_to_python +def ab_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_info(x, *args, **kwargs) +@r_to_python +def ab_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_url(x, *args, **kwargs) +@r_to_python +def ab_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_property(x, *args, **kwargs) +@r_to_python +def add_custom_antimicrobials(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_antimicrobials(x) +@r_to_python +def clear_custom_antimicrobials(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_antimicrobials(*args, **kwargs) +@r_to_python +def add_custom_microorganisms(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.add_custom_microorganisms(x) +@r_to_python +def clear_custom_microorganisms(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clear_custom_microorganisms(*args, **kwargs) +@r_to_python +def age(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age(x, *args, **kwargs) +@r_to_python +def age_groups(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.age_groups(x, *args, **kwargs) +@r_to_python +def all_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir(*args, **kwargs) +@r_to_python +def all_sir_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_sir_predictors(*args, **kwargs) +@r_to_python +def all_mic(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic(*args, **kwargs) +@r_to_python +def all_mic_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_mic_predictors(*args, **kwargs) +@r_to_python +def all_disk(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk(*args, **kwargs) +@r_to_python +def all_disk_predictors(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.all_disk_predictors(*args, **kwargs) +@r_to_python +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 amr_r.step_mic_log2(recipe, *args, **kwargs) +@r_to_python +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 amr_r.step_sir_numeric(recipe, *args, **kwargs) +@r_to_python +def amr_course(github_repo, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_course(github_repo, *args, **kwargs) +@r_to_python +def antibiogram(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.antibiogram(x, *args, **kwargs) +@r_to_python +def wisca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.wisca(x, *args, **kwargs) +@r_to_python +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 amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs) +@r_to_python +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 amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.antifungals(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.betalactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.carbapenems(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +def ionophores(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ionophores(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.lincosamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.macrolides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.monobactams(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.penicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def peptides(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.peptides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.phenicols(only_sir_columns = False, *args, **kwargs) +@r_to_python +def phosphonics(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.phosphonics(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.polymyxins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.quinolones(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.rifamycins(only_sir_columns = False, *args, **kwargs) +@r_to_python +def spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.spiropyrimidinetriones(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.streptogramins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.amr_class(amr_class, *args, **kwargs) +@r_to_python +def amr_selector(filter, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.amr_selector(filter, *args, **kwargs) +@r_to_python +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 amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs) +@r_to_python +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 amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs) +@r_to_python +def as_ab(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_ab(x, *args, **kwargs) +@r_to_python +def is_ab(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_ab(x) +@r_to_python +def ab_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ab_reset_session(*args, **kwargs) +@r_to_python +def as_av(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_av(x, *args, **kwargs) +@r_to_python +def is_av(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_av(x) +@r_to_python +def as_disk(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_disk(x, *args, **kwargs) +@r_to_python +def is_disk(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_disk(x) +@r_to_python +def as_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mic(x, *args, **kwargs) +@r_to_python +def is_mic(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mic(x) +@r_to_python +def rescale_mic(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.rescale_mic(x, *args, **kwargs) +@r_to_python +def mic_p50(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p50(x, *args, **kwargs) +@r_to_python +def mic_p90(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mic_p90(x, *args, **kwargs) +@r_to_python +def as_mo(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_mo(x, *args, **kwargs) +@r_to_python +def is_mo(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_mo(x) +@r_to_python +def mo_uncertainties(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_uncertainties(*args, **kwargs) +@r_to_python +def mo_renamed(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_renamed(*args, **kwargs) +@r_to_python +def mo_failures(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_failures(*args, **kwargs) +@r_to_python +def mo_reset_session(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_reset_session(*args, **kwargs) +@r_to_python +def mo_cleaning_regex(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_cleaning_regex(*args, **kwargs) +@r_to_python +def as_sir(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.as_sir(x, *args, **kwargs) +@r_to_python +def is_sir(x): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.is_sir(x) +@r_to_python +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 amr_r.is_sir_eligible(x, *args, **kwargs) +@r_to_python +def sir_interpretation_history(clean): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_interpretation_history(clean) +@r_to_python +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 amr_r.atc_online_property(atc_code, *args, **kwargs) +@r_to_python +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 amr_r.atc_online_groups(atc_code, *args, **kwargs) +@r_to_python +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 amr_r.atc_online_ddd(atc_code, *args, **kwargs) +@r_to_python +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 amr_r.atc_online_ddd_units(atc_code, *args, **kwargs) +@r_to_python +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 amr_r.av_from_text(text, *args, **kwargs) +@r_to_python +def av_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_name(x, *args, **kwargs) +@r_to_python +def av_cid(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_cid(x, *args, **kwargs) +@r_to_python +def av_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_synonyms(x, *args, **kwargs) +@r_to_python +def av_tradenames(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_tradenames(x, *args, **kwargs) +@r_to_python +def av_group(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_group(x, *args, **kwargs) +@r_to_python +def av_atc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_atc(x, *args, **kwargs) +@r_to_python +def av_loinc(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_loinc(x, *args, **kwargs) +@r_to_python +def av_ddd(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_ddd(x, *args, **kwargs) +@r_to_python +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 amr_r.av_ddd_units(x, *args, **kwargs) +@r_to_python +def av_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_info(x, *args, **kwargs) +@r_to_python +def av_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_url(x, *args, **kwargs) +@r_to_python +def av_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.av_property(x, *args, **kwargs) +@r_to_python +def availability(tbl, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.availability(tbl, *args, **kwargs) +@r_to_python +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 amr_r.bug_drug_combinations(x, *args, **kwargs) +@r_to_python +def count_resistant(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_resistant(*args, **kwargs) +@r_to_python +def count_susceptible(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_susceptible(*args, **kwargs) +@r_to_python +def count_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_S(*args, **kwargs) +@r_to_python +def count_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_SI(*args, **kwargs) +@r_to_python +def count_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_I(*args, **kwargs) +@r_to_python +def count_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_IR(*args, **kwargs) +@r_to_python +def count_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_R(*args, **kwargs) +@r_to_python +def count_all(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_all(*args, **kwargs) +@r_to_python +def n_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.n_sir(*args, **kwargs) +@r_to_python +def count_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.count_df(data, *args, **kwargs) +@r_to_python +def custom_eucast_rules(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_eucast_rules(*args, **kwargs) +@r_to_python +def custom_mdro_guideline(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.custom_mdro_guideline(*args, **kwargs) +@r_to_python +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 amr_r.export_ncbi_biosample(x, *args, **kwargs) +@r_to_python +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 amr_r.first_isolate(x = None, *args, **kwargs) +@r_to_python +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 amr_r.filter_first_isolate(x = None, *args, **kwargs) +@r_to_python +def g_test(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.g_test(x, *args, **kwargs) +@r_to_python +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 amr_r.is_new_episode(x, *args, **kwargs) +@r_to_python +def ggplot_pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_pca(x, *args, **kwargs) +@r_to_python +def ggplot_sir(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.ggplot_sir(data, *args, **kwargs) +@r_to_python +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 amr_r.geom_sir(position = None, *args, **kwargs) +@r_to_python +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 amr_r.guess_ab_col(x = None, *args, **kwargs) +@r_to_python +def interpretive_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.interpretive_rules(x, *args, **kwargs) +@r_to_python +def eucast_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_rules(x, *args, **kwargs) +@r_to_python +def clsi_rules(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.clsi_rules(x, *args, **kwargs) +@r_to_python +def eucast_dosage(ab, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.eucast_dosage(ab, *args, **kwargs) +@r_to_python +def italicise_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicise_taxonomy(string, *args, **kwargs) +@r_to_python +def italicize_taxonomy(string, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.italicize_taxonomy(string, *args, **kwargs) +@r_to_python +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 amr_r.inner_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.left_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.right_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.full_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.semi_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.anti_join_microorganisms(x, *args, **kwargs) +@r_to_python +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 amr_r.key_antimicrobials(x = None, *args, **kwargs) +@r_to_python +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 amr_r.all_antimicrobials(x = None, *args, **kwargs) +@r_to_python +def kurtosis(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.kurtosis(x, *args, **kwargs) +@r_to_python +def like(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.like(x, *args, **kwargs) +@r_to_python +def mdro(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mdro(x = None, *args, **kwargs) +@r_to_python +def brmo(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.brmo(x = None, *args, **kwargs) +@r_to_python +def mrgn(x = None, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mrgn(x = None, *args, **kwargs) +@r_to_python +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 amr_r.mdr_tb(x = None, *args, **kwargs) +@r_to_python +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 amr_r.mdr_cmi2012(x = None, *args, **kwargs) +@r_to_python +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 amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs) +@r_to_python +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 amr_r.mean_amr_distance(x, *args, **kwargs) +@r_to_python +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 amr_r.amr_distance_from_row(amr_distance, *args, **kwargs) +@r_to_python +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 amr_r.mo_matching_score(x, *args, **kwargs) +@r_to_python +def mo_name(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_name(x, *args, **kwargs) +@r_to_python +def mo_fullname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_fullname(x, *args, **kwargs) +@r_to_python +def mo_shortname(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_shortname(x, *args, **kwargs) +@r_to_python +def mo_subspecies(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_subspecies(x, *args, **kwargs) +@r_to_python +def mo_species(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_species(x, *args, **kwargs) +@r_to_python +def mo_genus(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_genus(x, *args, **kwargs) +@r_to_python +def mo_family(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_family(x, *args, **kwargs) +@r_to_python +def mo_order(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_order(x, *args, **kwargs) +@r_to_python +def mo_class(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_class(x, *args, **kwargs) +@r_to_python +def mo_phylum(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_phylum(x, *args, **kwargs) +@r_to_python +def mo_kingdom(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_kingdom(x, *args, **kwargs) +@r_to_python +def mo_domain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_domain(x, *args, **kwargs) +@r_to_python +def mo_type(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_type(x, *args, **kwargs) +@r_to_python +def mo_status(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_status(x, *args, **kwargs) +@r_to_python +def mo_pathogenicity(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_pathogenicity(x, *args, **kwargs) +@r_to_python +def mo_gramstain(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gramstain(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_gram_negative(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_gram_positive(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_yeast(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_oxygen_tolerance(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_is_anaerobic(x, *args, **kwargs) +@r_to_python +def mo_snomed(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_snomed(x, *args, **kwargs) +@r_to_python +def mo_ref(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_ref(x, *args, **kwargs) +@r_to_python +def mo_authors(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_authors(x, *args, **kwargs) +@r_to_python +def mo_year(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_year(x, *args, **kwargs) +@r_to_python +def mo_lpsn(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_lpsn(x, *args, **kwargs) +@r_to_python +def mo_mycobank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_mycobank(x, *args, **kwargs) +@r_to_python +def mo_gbif(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_gbif(x, *args, **kwargs) +@r_to_python +def mo_rank(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_rank(x, *args, **kwargs) +@r_to_python +def mo_taxonomy(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_taxonomy(x, *args, **kwargs) +@r_to_python +def mo_synonyms(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_synonyms(x, *args, **kwargs) +@r_to_python +def mo_current(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_current(x, *args, **kwargs) +@r_to_python +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 amr_r.mo_group_members(x, *args, **kwargs) +@r_to_python +def mo_info(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_info(x, *args, **kwargs) +@r_to_python +def mo_url(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_url(x, *args, **kwargs) +@r_to_python +def mo_property(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.mo_property(x, *args, **kwargs) +@r_to_python +def pca(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.pca(x, *args, **kwargs) +@r_to_python +def theme_sir(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.theme_sir(*args, **kwargs) +@r_to_python +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 amr_r.labels_sir_count(position = None, *args, **kwargs) +@r_to_python +def resistance(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance(*args, **kwargs) +@r_to_python +def susceptibility(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.susceptibility(*args, **kwargs) +@r_to_python +def sir_confidence_interval(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_confidence_interval(*args, **kwargs) +@r_to_python +def proportion_R(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_R(*args, **kwargs) +@r_to_python +def proportion_IR(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_IR(*args, **kwargs) +@r_to_python +def proportion_I(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_I(*args, **kwargs) +@r_to_python +def proportion_SI(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_SI(*args, **kwargs) +@r_to_python +def proportion_S(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_S(*args, **kwargs) +@r_to_python +def proportion_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.proportion_df(data, *args, **kwargs) +@r_to_python +def sir_df(data, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_df(data, *args, **kwargs) +@r_to_python +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 amr_r.random_mic(size = None, *args, **kwargs) +@r_to_python +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 amr_r.random_disk(size = None, *args, **kwargs) +@r_to_python +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 amr_r.random_sir(size = None, *args, **kwargs) +@r_to_python +def resistance_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.resistance_predict(x, *args, **kwargs) +@r_to_python +def sir_predict(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.sir_predict(x, *args, **kwargs) +@r_to_python +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 amr_r.ggplot_sir_predict(x, *args, **kwargs) +@r_to_python +def skewness(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.skewness(x, *args, **kwargs) +@r_to_python +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 amr_r.top_n_microorganisms(x, *args, **kwargs) +@r_to_python +def reset_AMR_locale(*args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return amr_r.reset_AMR_locale(*args, **kwargs) +@r_to_python +def translate_AMR(x, *args, **kwargs): + """Please see our website of the R package for the full manual: https://amr-for-r.org""" + return 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.1.9042-py3-none-any.whl b/dist/amr-3.0.1.9042-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..322b59f0cbc3c820f32da2b55f3f10d304151125 GIT binary patch literal 10603 zcma)i1yCK^+9mGp?sl+)6WraM;O_1OKRCgi;O@aSNN{&|cTI4gy#LMAeec%Ht?8~^ zySls9>aVJMeS3eREC&gN1qKEN2NtUU()04sQm%yt0}CPp14I3DS42S-XlQ8dVC`mT z$n4~u@>$MfoeORK1&dcC=b-;9W5YNF;Srb@*$PzxI5-rk&0wigP;yn>o`Vt2tn_Jb zO+Xpw@VKSakS5!`AS-7a$9G)GZ9%uTNdC8`r7Y=TZZ8+R$e zX{#9a!e*O@B47_;+E$*cvnkhRr_!ggnNzA2%+CZ3aS%m1>Ls=~EQ*d)7rpYcBo325 z)@bb6r36&;#UYqx(#V$GNzBi9`dm?ulfdfXq8ev8WHtjeur2$`2)KQE^a`-6$e)E- zx3uB7SW=VG?{Y2nKVYI$-F)qaHwc87kiBEN$iM8Ux#Y7)zZ%(Uu=#$@vUp6SQ9F~$ zf_t$~=cD~5-`;pmtX3?)qrLDPs<02KK6N}Qsq(2Oto0EC^UA)c-{=+NZcxNPo`BOb zI=L`Edp<~2#FS!`s?~;l5_r$`Y(|rBuC7hisAf8&;Z1ZOC&a8OxKuUtC77g+6>tMP zx(ZSJ)ZZDrJ?t&fR^ya6T`WZm8WZJ*f=F+{PLbFOI(}kZ)>&AxFInD>=&gY>bE(q}<}ozP(G*RC9rNROx^pa{z+qitqqW7=OiJUVN4w87tiBAeyLQ~t(@Lq}&35{A>_XGO zS5?N88cQ@Z>t{FNp^&-H*sDY{_c)sKIW+BEgzGIw!@b%kHGFrF+}DG-M+H-*nabio z|9Q59pKjHpqcOoM@m?ohNT%hjk=n0!#nG^zZ&?;X^{27CLP1?8#}X<(88L;1Fc{0k zwhxXNM6cgPozl&Kt&-|~us3#I-AxXV`3x{+3=v!z-#^pzM+eZdq7@j0M5-@pm4(MJ zoonqcp%l4BTnQb!XJ36vJ$!`|{ATWF^;56P4=UG+J#PDK?MTUnc821`^Ej| zGt%A}-o_1i%@ED`QbF|tp_Ynj>KO;i3%m}8b3>N*-lv=aCtuwB=%_0zjBcNBpbTKY zmsE&m#4?!g}AEq)U=|OMOWwQ8$TFw-cU?BGpM}D-tf0Pg;uz z)k`>^9vG|-MG1_~%ng>asykLJE!x5m86A#<(8gqUZ#$I{OBvBqe+150t zPKZ@Qzhk9GP+;}7f0j_&T?Fru)|hM?5`b$jt!g#7q(3xzNwCu+%@_Uqc(L=d{(L;3 zsX#X5HHE^{3ae>`3l4b9X$R6QGs#*)Xrd#~5y{i_E{>t%f{qcnpYMmgz$RfQ(0|Xg zK;s;1i_a7ZJ+pU0YtnBht&tkCT-ah<>F&D*?U2j|?SzgAltK1YMx4TLM!n`t2266I z&7LhVh{JvOXm7pGQQNnGdmr6Tj4(g)Jt z_XQ~bmvavaWXafv1Or1t_{+JQ8M_&~n!CCFaqiWca&c>1XkBMoER!M_yV$cNG0*Wd znZ3fKh>ki?+Kf;-1l9OzRC1~YgkRsTh*jsuG^a^y7|Cot#W`AZ;WJgH%%@6Y*4>*; zzNx6FsES=HrDRw6IW>>j)HW8Sw!d5wNjQ!GjUqQ7b=CyxW^?1@*TP&NAe2<+$?V+v z)7BZP^{3^n%a#GNJiJ%?7z19TT{1L@n?^D?x~1kg)*%F(0>UGWGB9)0L741ZY2kOc z8^Whf85kFyvv9uUcDX;8WN6#LW#G#vT|1;%<^9 zjhZCVc$er@Ir?8Cw_=y{@S2`*ELcvV2K%XIVUPcIwLPZyIdYKPxLqWDP$q(_wb*g1N^*z%IvB=ekx0%FZqP%Q(+w>t|;pKjsT~RiPNQpe~-X~yJrKO z#p*NQ^>m`C4}XYbvNx+P^H?S-7K8sG38TM<$A0%{A&}&u8{2iL)$yceOigS{bBpy6 z#P~sKoK-r#s{7%zvKfDV zZg;Cuu^fjQYAzMMH%LayXQ27r^)bgMji}tD z`rdYq0;dTXMS%B-Pq4Ur`f{+vB2_6hAQ8F*MSEyqgY+S@W-*(dh_KulZ7}tcJELMw zxLON>sO3@pi9_#Y&X!je8XP!6$o|uuX75o#fiyTVpx*&Fe<`FT3v(6;VrZ2#ECqmK|mnu;>#G|oeEkn_DJZz9Rg`Sr0@(97+7j6 z7#Q0B-tAeqJD9pzJ39Q!BP?X=JFau#gk8Ncgxpi?+3j*|UJSs%O`CiLYqLUc{ke&d z+&@!WBF!YTlJoj3kZdtHcO0L*pT~;{)hs0@J2e*9cSSkVxY}yBRz7RZbdiF`obD0e zW9s&c7MMMeJ`o#WXdmP7{(Pq}HtM74nn_H7+Kq&B3+`{@itrT9{&7*$F(SzJ@$z_* zXEi#9xmQ)5;LN3zmqPVsdar< zc~;3lHjJV)l|8xExn|wO+IFe8)^_%wh5z~@_%aon_K>k`(c1|DI>H*~^8DOp3X_>1eOS0fqL7ny4Q1;jpEH zI6Ti6x-kGcVF#mOH^+ifd!WtP72!l+{%{wQ`y3lB!ib14bP8bYz6n5{U+tjCc~yl$ zK@gk3-?!m3qLq~2n?+$kNP}#-@UFe@or3*x6a{m)!+_sK0e|4g*papMQRtiHq6Z>wKg7s&h*TRZLD(7rf}9ufzpIlUXVq%YG>5B!XegC~L?gHIM- z8!{G?H&^_nf^2{-93$fI@jp;JdR_-8yiEPJA1{Ag`5zQ>jpHh`m>RY6E#MkC9>6qQ zP8gTcvml(?`W!p%6pQVOay3%@H za;qhjOYNVFUo|W@QiXgB+J9o?Y2a_j68n~Mo`9?Q>GG@!I8a(bwsxNZ)6EBH2rG{r zd03fjTkQJSfwiLD6b)=Sl+1iiKZI@WLT-Zx<&CF~ZC)z>M5)i)?^>874sap-fE29( zl7)txDjPj=DN#L&(Ro?pVxymf!5eHo$X5E9M&=DUDf?S$5BLeHsGz}$a?VS7GNHec zA<9nb$%OC;V-%3MbrnLAf=Ai57MFlSi*iacVWs@WG!q%AjEbs8jSnfiQ4}FfLGek4 z)gYVK#0)~s&s)z<5U+)#qI0+9aJ$&Zf%}34yA$54;jt)!nhc;NP$AHVqsgy*d%H$Y zW%Y(vra|++uuJd5nMe{O;SU8EXQtek^(PJ|)$}HfCP5J<(sIVk;KT;~MtMUbsMbz~ z$xmZz0sTA|4WyJtT1?X_$Q>z$AQkI%7d{{Zk8_5KEHCzjfL~I9_fZ0oK*O`E$-QFD zX-B$uT-?Z?K6{vY0bcpvR&`2Lpywak1GEhbsI3t2R2R2lsB1rWm4~jmOE`E{E~Rm# zAgVwS_lX{_)`p2w5)a|u2qEaQA?%C9v$FTIgM_X-;*wg%fn>ZWTqdp4$5CT<*i8NX zHZjWWsV}O!D$YM<)GvlI zLa2cS{R>>m22uWLQF*{GtmoQ3J;X^)42#M*ozZL+Tn}TfZOVLBm9GU?5)p^Z=YUh!! zWa!mKBnZC?FU^xpn`A!~wqzR@*)Oq;)~)tHL?L|hTz!il$TOWto8k4VJlU>zGQ>L)V4_-XajnG=8jyJ8wWuz2u3AZJym3dT zs%Ou~mTd8%B-jdk(oo#>el;<&^9%!L-vTzyP2LRTMI0(RG*JkV=tb}>p5+zQx)_R< zhBj^&XGNHlQ4k3>U1v7#hGv-#WbYKT$J@gIjgij>PL&XI-*pUksp#~^PT+oN4sYti zLNm$Go$rI;*??PQVkaIkakrJ|(HTZ$&H_o8C0`iT%}OMH=+Rx(^hU99uOnRLfqvKj z8jDO=Z{cB}JC{NN88JZnO=DZUh94Esu9ES!LcW-GJ`~<@yOjoBCteE|Q{|C)$#`j( zQ}J(8_n;hsSrwVWK`V@qUlUk+d$E1{_AZPV(~lINXT1`xPYDQzHT7w=AIY1cO3Z>M zGQ%DrMSeb!LO4fH27Bl}aoVHvnkaN85rhIQ@pY;;%~@63x^0#x5)S2U(L6rGb|wm! z!OZz&m(xv$D=S|zVb-&ABnk{;NIT1Rj!>ah^pKKhi7ueE94cXnQ$;8<9LKTEu>^x- z%%j{JFR_I51&hh^q!rwE0RdDeP*i4$BqmU+HhUGNebNf{QtbeYsRLQv1bj1*UIu zG9*Rawz6woM7)cAwNjs57RPoN! z-2nel<+KE?g7i9}tShM}z9Fk!?b1%b#~uL4iHBHQnZ1&DNP_3!=#LPke<$k|JcPpt zC;;)pz_Y4}5~OpCfF{#;$eD#=SMVdJggQ*jm=l9Z4G*;IuIJ!y>`R4|Ggzy*A2FRmM8#Yg(Z zMvk;!TC2kbt5T1;a;1Zwo|ruv3i#~)X%eLm_-Y3z_pWoL-``fAfGge7^o_oX;CxBj>gqlZ7q1v4HORZ_UZ zk#F#nuZCqap~Iu?w#(IvCyd4J*M3PVYy5fi(66AeLeyMW@6$!v867P@<&H!2evebX zYSBafw1^K&iG@MUG6?d<=%8hFMcWm=AJUS zgre#cH~^IR_3=sHLyh%C;Mes?Z$37D(cqEks^ z=}F3SilZ6A>$|rqB;`KRT1smUK^MqaV9~mK<)PEH5u;ox5zf~sJC}{i+qT5qVGUU} z{Y2NjVZ8?jAMtw|p}n`c1B;_XFiE%-MhC)Tc1h1&eL0vhC}|)jp6b3w(pcHUo?dZR z-Zq-rsbJZMzEFhZ&+56hVcvN%3(AA2rE%Z{COR85Lxtrs ztf->pk9aBoI6dZIe;l&nr zwY1l@{PuQdm#A`i5joa+^R&zj8iJrC-z8~b4@qCo8l|YeB*v%5EM-e1+Bxg5(@=v} z?Y1{z+|aahqSP7J@A&9SNa$GWLbS+ANX8hxsi1h;FsRA&++p&Jky6ubd}LbZNltmt zd87$++WoabAc`GEn=9)Lyh``tko$Ynfw*$KU$xW}Qt(4u(+cLNR?>0R%IdP#t(a-j zJa413T>ae9P;Kg3j}uTc#2hXzaTys(d;CGS2)yUn~|ib(_hXAfE5FY%-Mv zSc%FGPGEdAl;U^*7&ZP}S^RqIQC!sAvNe{eh-5|k1R#etb2N0(_42o&|Btcadq*Ul z&a^}*Q5Wd(th-G;Uk;3w1c>(M{|JBL{v^9`3!;M>kiozlX~DqA|Aarr_AX59%q+~T z%sea{Y|LiXu5L`$4i=6;1qpQ#aS?TqCY>{fHR;s%n$j|NmI!m{qRV=yaU{?X_ZuB!ecmTd6FF72VHD$D%H!Iq6edf!@CMdeY3>*f=G)%Kw3;oflPCyC{%B-$DtAc2ekiixpy8lFh{%x z1o2Z?zbV6M*<{0Sd_rnnbYX_x2XB(-?NgRSyibt&iga3gGEV@e^+xaxKi;F(D`Pdr{zs3^-cp2JynJoLIV+BlbMyPB-)kubDdb7qBt5Nq= z(${`p)oM{`dTp9NNv8f)(E|Uqp2ff(!j$AmkK3Szf<)GFw3YSz(9hu*;WVXPgQYvs zjiL4ed$$y=yH|VFsZ3bpvK;{pcXBL|6Ca~80#%|p(A0G3G-z_KamLD5RNkPcL5qt< zp(uy79N)689eacyQM*Fjh~%0sB`>}#V;}t3_IfXYcA43V<5xN?!%w1na%vezs$>f% z6t{TpJSMMi#wqztA#IRR!BJ#ngp72M#P=kib>+ZA>!L=Z7P$cj4HslCjP_xp0W)>=}tzqmO~V2p%8Y%j&Z7?GvP>^2+>Zg48+LKBKc#Ye^BgEepm&v=5@$TdyWLIgKyr7HN!(+JF6q8|6mCI$OV{Vqn`~uw$tiqM~_HW3V|eRYhVXFB@%8RAjUDQS-`S6;YD8TvJF9LN$AjvWDIkv`3t*7UWw9G2r4 z&bmC2mqeX*T%`-`?xDxt)b}1F5@C(Y$SDyW5hOXpMC_-%LA!!qZK>zwy!NRsC>ZI) zzwH-bWd3eaAL~EMyyB0BoR{LX?6$Irj=`;!A^Suv@Y3I1DII!jdbRWN@v_w2RF3vU zG2Exdv7sD9MT4R&@{A@Hw|Jxv%NCf7g6t^N!x(}BKfdmuF+D$5sA+G8S4qVb28&R( z+`^J%0bKTGM#bI;EAI%f{4kAfb#*K7EIHpjAcWQ6jtAp>3L@=;jEJb zamchAx(TLCHVhYbmE~Gc#CLdkySZ4i82UqcqdAMZ7guf9nl;!dlUYW585Q{}tcMghYMAbHT0Z z5u6`;1Ri<5wT5LAcX3D=WWg88?V;1k;Ze-MhW4&Hf2rPnX(TO?nTHXKPsC1*41@!k zQ%tJCPl#8$JNpsv_GyZkDS(J+m)ausJ39f-))6@wP?b2t0%iVwy-f3^A|0xN=&S{# zS}D*S-yl6g8=T0Joe|5wq7?{9kZBK8>$X(r)7hJ|Cu%3Aq61{8(_js7_Sd-77A_Zr zKn@I{-Y5Cdz|-Hw^YnQx>%%ucymT(8%c#zYh~AomqvA{bW3`Kf-aKcV!;;9~B)44X z%zSAnel+k0hFZ>^%dxiRh;wvk!+vd&)e=46DpVin0gcrywbN!1&bJkukvM8b$n5g_rMLS<~ zcUhzh5TpP+3>mS1iP|M=Q_qhsYKFRG=u%Qek-BWXQ6J#u&*3XvyJ&k{TAwt-w2awL zwaXO{TGK^BCg^i2DlavDiv=VAN>Nm5pc=yId(;qm*cp0~X5V2`wu!N? zRjx9Y)_|3}i$MNDgKSLc>i?c-ID}v<>GVzcJ692HUUmdbAw$i-2=*oLGl7i^mt`C>#CS({9ycf)Ed9lZRWg}{&L`mo0>BIFD zDVmj&B}CKzO~F40?O|O7-Z*@zV&eTk^iyoZd!xsXx0bNRH<#dXzXDEahe%*IDKW8O zP7V?A?n#gB3aVXJaqCOV3=!e#y8> z?$2v`kI{?XvxbHBO(Xdl)bw9T6NzDvnf-kf$c^zsNMK48p&wZ8^OL>rE-i z{21{HSU+)(s6MDLwOf%b31D4{JK~s93=1CZg$+`A3Fg_cJ{V)<*v3Q(e_Gq|;ToKr zKY6g97wGAg`Y8IsLlSq7*xa}mzvN+CC%GM%)d{!#+1|ZF>MiHHzUACn^WAHi20u*K zL+z&4`2;UStN*)jXwzDDG;QBI%fp#vhLIM~wN%qY$Y$s0>Fx&Jnb=cmL&bV$iavp4 zbv>89tU@A($5kE3;_96s(fDB0W(e!yJy8?rSakOY7|S^2IMkJoI5KRY`;V|RD$+ook@Yeav66vtY5b9Vu!Fxv2zf^e3)+>t3YwO|x zIikKz&rHU-ULo`6Z#ndwZZDe|EyPNXid8h=2bxLj%-JuXa)qPPF`fQ0cQ~{?X{U-Y zZuh+)O8~KSV$w6aa>Sl6&e3jVI#<=<9Z!}dkmq78?3C_Lv8DJv%5LmLkdmP)J5Nj1 z6!pVKqYIrI$XQbX>3$x{@L|={*UN5}AYsx?14gT3=&!40w=l&O*K|T1{zgAh0sY?1 z918!MGHPJ5cd?RIX%TLZGU!Rn@l^DVV)ZUHB|#* zE{#zU*_fEa)j#1y(0aUZZAzUhw)+GSzXFA^Jd2@DS`UlBy9jIx9`nc z-(~jdcSZghoz2tzJ1 zcOBQ4VVj=7?!u1lov?Ko%3ldW&KC-IT}~jsQt8*HZ2+e7-c*%zMPp7R?}XS%uV~+C zI^stgTy+zv1C;SESY0!4{&emA z3;Z7q9e)S^z1;g3_!9o#;QuWC{wMnXmM!@UeS!1;kvsW2-QT777u^=sKhXV;F#pc= zclrFqmAezjOXwNdJekF{tOCIR7mxWjW}7$r%jx&w2YtjmCd6OkiOD3ntWf AP5=M^ literal 0 HcmV?d00001 diff --git a/dist/amr-3.0.1.9042.tar.gz b/dist/amr-3.0.1.9042.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..0abae15160a45e712a779363529dffcfa3af7dd8 GIT binary patch literal 10484 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