From 5c2182ddaff75a0cdfc924422d204d6fdf50b763 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 11 Mar 2026 15:13:43 +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.9034-py3-none-any.whl | Bin 0 -> 10602 bytes dist/amr-3.0.1.9034.tar.gz | Bin 0 -> 10486 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.9034-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9034.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..11ebde8c9 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9034 +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.9034-py3-none-any.whl b/dist/amr-3.0.1.9034-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..65b28d581c64664ae5e35f4d1c3c334f1071649b GIT binary patch literal 10602 zcma)i1yCK^+9mGp?rsNncZY)qm*DOYf*qXTPH^|&Zo%E%-8I2|^8Pnd_q|&)x2C&x z?dtAYtG}x5_3izMssbbw78n>999XTlt-hC!wrUMD7+4?~7#QlGyJAXe03#!72WvMY zBNiv`)dGTFIfCy*$4gKnCizV2#>(L$X2N0!NH+OZ3atJ0+T9h_Z*CIW@S%% ztNlwshsVt&Ml@OO`I*_{IA6zA+!pj|3Kf5AS;~_h=JaxNNMG&cXUP%5&az}c^5WU^ zOk~mDZ zuhH0Z$Or)qBq5k*QpuLxNzBjq`dm?u6T#}>A{%Bo4ycgf?3dNsDyWdHgp)8a9KM*U1C z6Yj-6O@Q{hVq3#Gv3il>j?Th!h|)f!#?4^UA)k-}n{dZcxlnk$}rG zDybkZYd%m-%#31`s>Oz55^&G`{Fx@tTtkPfLEUUd)0^l%R)j@Oc&T#eOAtvd8~qLJ z=qg0fQ-5dB_OQ29YqeAEbdd}(Y;Bm|7uYRRcGS=PMjDqxv^M7_`cB{z z-+j=C`IIg*+4Ok)!3@`U7o!qNX#f$zWRB!_Z*m6|rSe}e>g-&J=?5XxM{;7NG|)W$ z=(HzLnu&xv_lr|UeNeu2jrhKG>n+UDlLrzIP~PHK)j1=|22e{<>>!enfMo5OD{8)Z zSV(f%&Ns2jAi#K@GVksN>De?V94heb?#l=y9Wr^`D^Es872SGOB&mX#=p|{BUXOs} zsW{y4dRH%`l;K4aHI#W<14(bePLbI2JAPta)>>F{ELq-;=&ymZaBI*F<}%jL(G4O#^{;>|<`iRs2c@ePk2#pXYGF6#3Pv1?P} z^Pp-8f|_k4S7en?cFN=fJIw>q8f&GFcZaBm*vwnF@3}FuWW9tY(bt@K|I}%)af_G<>a3CD9~+V2yVF8$D3NY zKCuuRg#W&nj&47m?i`EHcUYI&XlZu+ETehSqtj;=T31THyLQ~%(?Y4_&3^iA>_W@0 zS53~08cRGR^Jh2Vp@_N9*sD|%&p4X%IW+BExa%!v{k=M`I=(wd;oHI7qmr4*Ohr+E z-#q)lPq!-4(dZyxoY#pLl37_xgwE?-Q55W_Th@gTgJ~?U5K!02u@vwp6Q;-z22-iT z_Q4UO`1QNEQ`%=hi?oI>?2VmQccTMj9wSUCV>oyEk54rHQU0`SX!*v$5gLoyrD4&` z=i2*AD21-!S0cymSy#L%hp%wL-_3oke(G2HLgiR-#BQJM{iJ+E-1w3+Q}auBzo`Fw zM%Fvs+oV3X38E=aCa`WG#8O#ZBmH1`f#2b9ZpiZ9`;^Q7geav=#+7wnItIsJjzaj^Za(dT!e92MuxQe|2d94)vP9$42DK833hs91)_c*FLr)1n2)1x z%$E;-O{Va)!fKr1h65aP*@3i5O*5Ae8tDjh#d7t$i=wHxp`*p_=lfwVut_)w4Bj&= z(7480<1)lT&g`Ag8V%}8s%3^O7q*yIy8Es{J0$agJ0W92rI39U;ivGMk+0d4{*zp2 zvu6v8l5ihBI$Q5^)b`Eb-beQnBP_SO;oVhrsO1@XB#sLHuXoT1-CfPKu8W?J3;_)H zeg3Nd<=g`USkw0*!N8CZ{&Mc0P25ae&D~u8IQJ?oh1fN2w5~I4)=4ppUF=zs=;t_^ zj9yVvL`PjH9VRGUf+~D)OO7UC(^w8iuf!b3I+%bXgYpOPt4rbc8DiMFAbA_ObhclT4g4R+M6efOUKt;4Pfx<#TVGqFNzoV4=pq@I zZ5`2x(3m~9a%(JFM)-kRvd&QUX;@j@sn7>i%b@Jq6D);Nt3Lb9GnNP|oB4S=eEyK3 z*4#)O*k`EDlKa5>aaI$i10s3tTqU2*0vNbw%4qX-$#?e+eCk@C*tub&m;=KA+)c8? zQPTt(?_%9bN55<27VP34ezOzK1(@KhF$7;K~1uhkSFk)re(xkk}O?3D(K7=%n+*2N)0 z3W_o#7}V-dDa1Ll-u5j#nR~a2 z-k1o1n>NgM-H$PQ^gl14GP-JxpGp%Mig^)z%B=$>mBpRk5#S6kak{ke?-7`B_iO;O zSbc{4o=!A%VGps)_MfXtJ(h`zB;ebnVGQ>0IPM-Tgc3dUV!95sJD$`{sEKW9Zm~WB znLbEOGE1gc^*)?dwnIa&jNj=94WFH@iN5H><9c<9;wdpX#XeIJhDZ?uG_;LVTMH7w z?QS*8mt#>w%w?kXhSIpT7Io@CQ8<*vk4R+VL%lr5n9r}3*2pwpEFP`XeoXA!@FjS@ zd5jPC`T6SFEad_s3;L?(Ag>Uf+Q8wmV+!7sYUM|!T zBwSfj@U61US59MiD?xL(>vfhL=RYNMQ4z}z*1Vk zz|j8pZqLHq!OYFt(cxbnVIj-Fah)3{^y-Z<_?}|VZkK!WVgLqi+VmS(s}*|7&rO7+ z{+XI$S!TJF?AK?ZB#XhhK|QG!pPbiF_zu09;qAVVUlg8(IZOtJ87~R+Shj# zXBCWO!ze0KS(9s>Yu1fyt(W?1t!EF~_^&U*FH*-Liva(r5ZHHw?l-K9%c z?|I;jvyXnzZq!){vq%IV)mli9oCLdcgqp_NhlW`sh&WkSQ?{J8zM5ZuR62@j>|iqL=3G!|3$Qu6BAf`w8}4FupJS&*7!ebNPNrYGZ=@&Bt8!50x~jyW zAc%<d4$`KjfI_Hp6?> z&}_O{_@#;lYv8c;+v=D01+w78)=pbD^jDlk52*vQ?B0!A(wAwc2SKLC!4u(+!6yr^ z4LOU+n=8Q*VRrg09An}iaqTD`J+A{4US_`AkC*LNeg{R|+>KRO#{DwV!xd=845<7&>Aw9rD$#=z1twKO33oILgFCBCPh$Kz`8UY=C~21<&_*6!0`x&`R#L(5`D z9#$q>7rQ=oV6A93#RHlTr8Az>4q=YApDpZdWbY9lD*y!hA@P?ZY@)f>j5xGN7s(zL_1HQsQAR4SV*SxeRGx{qT zqWq-3T(E#BMm~vKR{1@n1QHyx$9Z+k~NT2bndpCZWkNba9@yMcfxu#Jr>1Kljvy)fCL6`GV$6N$nkf+6%K8Ob-F`xAx}t9uhi6QKwbXt|~qr4#zROuwa z23Opy4^x6<)FC zbRyh4E^ZW0pFPaH=wAijR&|Sk(DRRN{yIka)K&<1YKz-2)HR>F%0kxMr5wB}mQp#B z5rI&|ed5QfHKCG}#6$QuA_#iy2>W7jY#jX@Ad%~i*u>^>02x0Dw`t4tapc$?HgkW! zO|)uT%8QyF(7Am^{_+Ju$7Y3V)PnRiA&=UaASDq-qgg*fO_mG&2 zFf|~*e}P-oFw!qIG8gcL?OeyFhd9xRaZwegGm5>O`(f<0RaL;M;x+$DD%=Pqdc2lZ zos|_Y(`^z^AUXfrW2msHio4Xe_Dk%ewW~c4kqF;CSKs0Wa?K`EXZU?9xKAJyZ+L2l zFD7ZzXoQH{g3;9xAkiPmwn!nGHvNxVSrJH>y3AO^BG?jO~UrmkeJVU`bwg3%tlQ#po;fKl&jT9mz`r&+wXSsznE=J-d zAr0F_nc=3T6hy*}*BK4FA(>_aSv&b{arQ6(6Xf%OQx(LVcU_}hDmwkK6S!Ym!Jgvq0bVlJBvj7qn=@%xA&&AU1`gB*-y^-uZ>j+o5px<@B z#voJt#+DR)uD8&`KlZ*96wyUhLn$zl$P9_anvSTCao|P|}CNn)$TYkL1o!C1k=A zea0RkMSeb!K{!WG0(bM_mGlki!Y!xAF5zUQiZEB9>=oJu?B%- z%%j|!EU^an1xYCKrRLvv0qChtpr}48lbCvS=M;zduwAXPZS}C~XS@{y4E#UNeGuU2 z7k-R4{;pq|icxuORMUpC;5(d=S|DDhjhj#T{EgwJD_wRpGN_1?_$xP1Go@eRR%rSr zJ6&4bJ?>XFzO-0tnb#CjLhgKFhvlHNs-Nj5hx#AW`8PQzndtbiuhPXZlD@|*4Z{fv3f2<)qi~rCo_VarK#P>X&vxKKAtV*>MnSE3;Qp4~g)coc-bA4DV#U!iR7e z{`nw57g7^cM_!K^enxnO)sF%Mw;HD9E9@NCPf!z*Isq9X?;FWkp= zM5-rs{j|7y!q3%3tm52+Vs`#&0id(UkhGKn$fhz>l&1I;nK=r(r>UcDFHE`Ikfb&=~czOP7U*sM3pI7kj zq+u1+2zs8&F>ajm^!aEkrE)+rm!2US7^qLP5*Fv?+?U|k-1^}{j2`|Z7fyd%1SWHb zA>ZJsUJc7<$-wvL&nI5xOnSuRm3_|8Mc-A~&OM;@ zgr>bYFJ(RGkS5K)vV`|e!q;y+iuMF&h^ z?McjailrIC>$|rqAmusIUP^5WMi)w7VAZ~S<)hQHk)T{E7R}QwJ(rKo-L}NsVGCY1 z)WHuCTe->u{@}!ZghQ4`HAz>M-0owgYrjgsBuCBL zu1YYAi84X$+vZB{DQSCnlHJSg!=mYM=c=rYQQnFDor@5BL3t3lG!B@+L}!O)EVo>S z6<1b4Vl1>ojiYMHq;?X2O%st~x1s6X>Fg*G(m`rrX(i|2;Xr0g(pF@9BDMeZor=x4OV@{5dfrHK=yx8KY zlJ&Y)+}`f&5?3uNB*$8BnwGmkLlBl0xFjv;A?fQ`qZId(#^8O-RJBB+owNQn4K--h zW_uIL15G<8PMv=Jj*qT_gpRc?LW`_|WP@2u1wF(zu3+-EkdCWWRF$@DMNgCF zdK;hR803tG=up>~tlpwB&orW5HPar-~qAA3h`nTuVZvG1;^^62Q1apw00Vz8*GTTS1D@xETmCsA2| z6$5v00^*{el*j$SsPX4Y zserBYX$qe+#+$DAeEYZ(2zpT-I^j=L_MhgR>W!miB&(UzY|}t*SMnnI7CfQZJ6n{S zd>%Eh-hPNU<5ev_6XVQfKE@e+H}8(iZeYPNq@G83nl3B3Z=3o^{Fy9GaRpsvuIN>w zUi+zUS4=NhA4VOAf0aJv%@XGeA}s;|X%Q_2GR>8;NS)yxC(s`bVE^HA?>uT~j(ATW zC`e)brV6KRlLf!Qi`25{!UDYy-YC`Erz(wjA20I_>9po#o&Zeyjo=-AyhpuP*yuzf zIM~@`QdqJpyhldTdQb7ylLj+yjW3%1WoYYVvhF=iTYQ0GyJzYRzrITGmZ!15_!kb7Pj+4Ux#Ca)8sZy*6sv1 z#+nQ4-4e9!UY%8^Qc$*}}3e2j{4RH>!_Gqa)7z{$Oa8LO}2iiSP)+T1is zh1qOn_?ES8*dv07I^`P1B-eDwxpAfG`{2j6*L(4_%Pdx$ztUhCe-ho3Q_DG0C0RJ3 zxW)10GJAbDNzQ8wZiS2tiXIq~ramd23@50>k)D7x`WWzw@G*W0B9c^Rhk{1}y(xsN>tZ!2T)Wmyqs|Et zHqFh7|FhU~c^5--wvumlDbkmsqN1@^9*a@Va}yG^TrIzV4vIjbpyWQZr&`4jv2Vd( zY{_RZGE&!~XmH);Az(d{9I-NkP$1j7Xto9B*;Ng)I))o`0>enl6ATQN6pzl5ui%}A zWc48tWXOwcs`K)mV_fR!%s8^9BD51L1JR1JNPd{;KQyo?hF30;FTW?#`yN=+qRN@g zbP*1J0(rT?&wMI2nRZ*gV&IUs0w)}R`-F;=Pq4ERN&N|nJhV7^aA83c{SXkx1-##o zR3Gk4ys@VA?_DLQ#2JtFZgW#VkltNnmh@PnOT6zMg=M%`rd;?Dzsr4IXS!|oFto=h~u<3a98-7E%m&D*FMz+1rwd* z_x*f~jNgqKWBq3tSAtQH^D)d+G$^WK&u9{{i$?~q>;XwA$c`dCOu;DdvMtXo_FSAu37~U zr(Bznn{e`E{cu57X^sU&T!)vpn~OE8ksqWtnzOh&KK|)pp5IfI^|kCKvZ8PW>j_() zIDw+6^H1%;TRf~fvIS(fM>=Rz4nUD zg7RXHz$4DL*05}1FAgaKEd)Y%Jak()J&G9F(cabOFE!dOjb)`WaxsGNi8!c{0dN3w zib-|&3CSvVXI}#TJ}t4&N+4p|rPlEM&QAJg>+tM!s0y56p;ABJUgr4{u?{t1bhdm_ z?PTbV?~ooL^-g3-&WL5-(DFs3$aDs(^qR{J= zKn{!{-Y0ocfYaYa^9;Ez>%%wgUb+|5rBvrcL~l(&k#Qw{F*=1JZ=N&Gp^4;g(pxTc zpTE*lwATv;gjmj=E3ma>OLBJTzKvQOb&tjI14N`5%?F1rM3fFi$KeYW=;Ctfm`P)}P%OwhxGsj)YWrh0<1VNHgNk&lDpWDkte;G96($M10Ak zK$D0r+SesOq}%#H8-O%;>6DRFg0ctUt0XOd!g#;_dLlY&LN5AV2{y*;Vv*@p1TN^oE}21cukx0|348{dLpnJM;00X|44g z0=GAXC~Z$9vvp)tDB}8c#8(-LFO0MIWA}Y)>C9-6XWFS(lPEDURS4~$+>l*m?yzPX zpZl0lSd6gM6{~_5##Wkk7hUui@Zg|W<<6BrwlUaWX-4@x|zcWprqS7j-z;+b8| zDstgo^g)XCVSaR46|zzl*XW*#FncDRoL`F3QcJ>ercTBC1#kAF^Tl>o#03RdUCAdm zyM%rq#$P{W4sI!l`GL?J$@^2cwlpsvT^m(*Mln&J3sQ(3>#fLnKACvoU3%s)^-ITA z@O)a^dyHE2o;50{YaGebq-OX=nm`PL%;LM%ocf814RW2$TV2!{_%pKjzJTTy?{Vf* zYon4`%S&b^mHu1zd|uEbdRuJ!~SI zPEk8wygqZ|^(mKRyuh-m6jp$}pzk=>)M8$vhxtH!fjl*R|3#*0Wf=BDeaq=JNPkL2 zu6@MIfBnQgyy~Fb%x*=#*q?1F_K0&zIW%ar7dBAkC5Ugw`e2NSa~l&W>}hSshkI~x z{^Y@aUZ|&6=A-ZnA4%*zVpGFj+>(cFt@L(4W+&YCCwun}nYZj829|ScO?R)Qnu0K0 z4>gBias*AgvL5u2T(r@I??XJSv84WRYT6hl18 z>Us`CX}MH3pQ{Fd)zv#*s^P)7)d<$Zd!jnPvG&@r8cDmMM{MMdhfiIu5QI$m9@6Ib zbp5?0<^f0t6B5!*rgQFaOY7|W^2Ik=>=9JikF!!e@QZQ?Zt6hZQ3XYFKacDC-lNe; z^s9tp4au{PvGC9&08JN`@i6_t$+o2E@Yeav66vtg2_RYwO|x zIlQh_|FfKPol?fn-wNp2-Ci~`+K3e%<*R6b4>Z%5nX_L2)pAFbV>*Lno-k;8(oUcW zZuh+~t3R=9LgF)rYWSWg&e3i~8h7R49bcw2fbU{0^px&Tv8Cuf(r)ZTn3AzFD_2|1 z4E4iCvkRREz*Sui>3$x<_+i!4*URxaUdpta28>qM$WKq*ZefZ$w(*2I?2Tcf9QwVR zB?SI8dDPH!?_wpj!XnHb$>CfVlTcFqnO~}zB#IU1x2?(Mk3@iN4uwWeZc-SQ^4cDXhvqg*#eYN~p~ z92(<7vM~vVt%oM!(z@O?lkeV&kV1La7>DVE`8g(9gj%z9F!kFTU!S3`qAZX? z0m9tj?C@(!y&)H8uGj?hpgtoVE`$B(J@s#O$AhBHpdW{oIf8RXK%bKVEVn4iFagE7 zy((l?f9-{?s1)-YJ_M+rT>d4fwp*yA4$AEEj9_O>I!fP8=RU>4VrdW7G#hWvDvXCI zceXL_YY&8U7vx_!DLE7__S2EHyqQRC;q7=C`d(f=HUf&ZHR)^GQB@ZUQ){tX2KD-7KD)3o<5 z@PG7k{2l!FYVTj*OZb0-|Fib{pXmQvvg9xH1g4Zqe^=sPbX!#aK=(ho{5#j* z)$&!977ka1Rz-g1bwC!@>1%&hqW8+TE9Z zytitqrt4Q-(=!h_5)z)p1j86L7!l}ebHLvM$8>KJ>1*@qISj9CZM%`Dk*ML|04a{vB zR0J0Lk%(ucsbPXygpe%ff0~h zwu8%BEth@6imS;(}1~RmFS4Ml9gg_#`0z}koV?`k~#E(YriSOvU26b zZ@Prs7hnV}P8@w|2arArLJxy`0hcNAgH$yi?w|u6LXZg(fDP2X@n{^w!W3d3;M4N9 z@&Fu#s7D`+SGPgUi{5}Yr!}vdFVLa~AP<$}D|C1jI&kvyjoRrI`r!fC;0hfrENTOr zH@y|Bxy~e4ET}a=Jl>$*d^HVF_@_$qRp=hV3zX!zk0$_o4ce#i3b5~W_GZUROO-3N z><*iujo8K&^f+F`3XYNCbBP-_*|6!IAsTA_)E*z}Z(*M5VTWHCKjtlYq_VGKpO~KC z-`>MaS2$Wky4I^tAe5hng=+gu<5NZYtRfvQyb!xBi$|8yp%eYP&4y&T2vlcEIu$!m zl8`kPOEi@NuP70x^2JR{x({_uQu?oC`Iu7^yK<3e(!h@~q1K*GuJPntx^c`LY7L?~ zHbt0F)Iv%l)2cL4>>Mlxmp*xcQygE+FO+|%XwX^5mGT;2EJt&r1!~8U47DalAaook zSIahn>|;%X`CVWn*(h90|GMNp5{0-_c`jd;43Ayu?x&CFwcjyWKQ_N1(zy|i*HPwu zW6hY0UGtW$EN~*jVUCs4p=Dip07o?oyv?>%6|k3BsJSBlaAF?BjziCtC|~{*%xeY5 zoqIUrAVX0?>xPeKA#5b=XC4m2ptnx%A{UC!dLqeZfH#W07ZbU}v(!Q@hslCmw3O;K zmZz0mX8UQvlmFjlT<{^3DZ0WpsNRUQqYHsA)`krJF{I%xH zPNr1jectaL`G>)RfRY8VqOmZ6$~T^9CRZ#!!MRYp`YEbY;8xTHy{6Y;Y#Ta znH*$lNFy{jwA{fz87mU-IvFRq&=>`t6yTvaF=Y{XxJ6KmVN^_Wljgoy@)`x|R(FOV z`0_}9hJh!))9^?7;bq&nmpN4<+DMOYr=cN|6gtTriD8Jz_CCfln!>if+7B+IKSy)? zK^*CCE#bkFFeH8awq`F*Dr6r0r(VE}n@zxSTd5?=H8(BdP)dCuU1KWlV(3RjDv~RP zx6sFX7k5}}_T$1x_i>kbw^Y&Z$vq9F*g9kwC9rcENVk2l7R%nK!Tt72_`x1_LD)(1 zJ?a{%%TxL2(z*HCWi_6DdYEFfS)1^tisG}nJ;+^7`(Zzw-pL}o>C#gYTeYNq5(3LT zxxQAPr*1tR+p(^Vov1JWA9gbp4kRdVu%BI^iE1rVdC0l!eT5he`oZiFYSgzF`p6aj zHLicpK5P0n;5-+PeO6?l+$4pfw!^IFxC0gIjK~l3tJQi3Q=@G;0MjAvw|+MxSryRL z%p$M-1A)n}RIX@UwP9DJtV%Z9B^j*M21mMeM3N{cY{c^ldG|`bP^}-QJVase+A$^T zZz?SG^X3{jIqZOFOPlyJixAt}!-@?gdHr?CB(gcw3%TzGvvx~o^a4U<+;kWxe6)VM z;vHvX6FcM@`=?iTf(<^HE1nc0DG#Og4_2Kk@VBd;52e`E&Y({z3GlD8JF`9uwtO(# zi8qXPY1q*%>wkV#FT(L5W+4?SR=BwADNYo~@f!X-S&uLSYLxfgB^w7{WfriAB!;wL z(cg;X)T+*XYJ5ty(#j>yn4@37KHO2V3*$^YS1v$|u9&Hc)DTb|h-0a;!c^>t%ooY? zCqi1xRL?kLAzDoMbi%jZTG$%dZ%<@9Ki)i)5ec^F^tIBL_JHSU4$iY%CoNqjtxfIV<{MW_rO=|>C zB#VkcRuUIk>~@O=&zttCFYJo4+Y}YQg~+br*5h@&Qhp4Y-}Tj#&Hi$cSqwew!qtS& zbK-(y&@4oMab@5-a$>fr)n|$O_MBk%XWM&xcR7{d^XvL=x8pkbTKU>B?207&svy^s z@me;IXV0FxfRnHOG$N7;we4glZ@>U(@iw%Q%k}|k8`w3jP3asym?o%}Ua@b**mRuj@@R_!cUOfvq-(Brs}Kn| zJHv#r&^Lz5N0E9WP8JvYI-kOZ?@&BV;eRH*BoSH)^ak_Wd0+D8c_9_G4}{;tpsQ8y zP?@Rr0iXZyPssxPL!PiK2nk!$6|p4J)FZ%a?u%1q1{P{e%BTI2frt>)spuO=fLd1i zUuI(+X7LPMBX2b;ro6+J(P-js$?@}pmhZcII*yW4@Ry0TL^xkU zTE@*@af*b*M!Gz`0va_RzD$O)S?t2J9wAHmy8Tk2`lP$tZBA!qu1UvyPc4fI^c5+L zu-;6==hSu`#Oo9jVF`C!Mk2+Lg9rQ)8WPu}O0T=eC^fcl zLf>23d;H?opWGx#tUhI_$>#9eD3O)uQsfVdsuA&Ua?`iZgIKk* zROQ3`xE@*+&M+B<^% zY`|&ln9Noi4_`CaG*^2?1*RTg8`Pwdk+a=@nnT!rcMA`=D$L>v6c5!d)?T75y)2Yq z8C>&Ro2LB%LB!TA5Mijvf#~QRzN?-VGU5T*c-Md!2Ur=cfWX+Uq0x!{QyB;Wuq=P> zXBomj1tUx6I#~QkMPrWsD6@*yP|mTfT?Se6kQI8?K9xq(5MjUept(`ZG9wx94WBrN z3I0p0ehq#1ZeqZ#c-NMAtKhd4;N44#8FcOpV1DEtA%h#6qxE=Ax{32-2vhyGlVpT!7_{?*JJQA4X7cAuMP4qycAMAFSCqLXcqxki z0=(pR7uf3+^hSh)8NUpSI4QLmrHMvzcr&jZPN4dY8FNUcc1g_<*iFT~qN>$V%S%!G zGgIotvXYMpElDkz>*cvw>q{FG&IQtXHWBUT@^M{v_}^7|V38(S<$T}jaw;yQiy~OOPHq#8W$wx)$&u)*RlPS$`1DC0 zufwbqhy?B~4U-dn^O)^WvZYx5I7f7LGiRO^Fil*NXWcoEq@eRKG<1*CTfC|u=3_k_ zsEvufJN!@Fy&NCSe~d~RLthckH-kfP+W{Y$g2cJ7TC6p3t?SsKQ`Erdp;?@LRnFIJ z^pfFDU}P+>9-qBYv?4y|YS>S5d~pX|M1%aR$52A(jxWgwFM9FRi3pgfGJ3vp2_qtZ za>KoSi^OyY%QF9>eNBri_Ml*@U!(=$JELz{7CRi-8NuklzyPn)OJa$WoHAUr=tBqG zEyIZmv!E5W-Qz0L!~^$r2nPWtAHILC0Le8aU8KpX1*^71sTyQ==T@rx^P~cf-B>yy zoMciptnGz-BuBqu@ZIqt5lBGhDQ(%S%}BvU7xx6Kq5Kb#!dyF~mnLYN#1I^Y)+;HN zjWw)$o2r#c%IkK*-a;22Ow`(8KwfYwR~}URa}SS;ak{fHvFw8w$XB^GD0fQRB?#k0 z2M*V2TEbi#)|Y{Z<_7#JR{(-t1rUe#NsSEJeb6&m)P?~P5;V4Le5Gw*OO3r3-_ol> z@g}99f$T4^%L=8!)Fs--n- z1yND`LYUeOyB)eT;){BS55%@Tz@olJ(_WIv^b*kVDOKPsAQUZ8p>@GKaRkehc(vGaKg&V z&Z;vYISLn;g2k4r(8k!p&aHl8WUi~>ne3EJR~{V~am)5p5FE8$1Wt>*ac;($Vz(#v z!qi9B%%)r>w1l4}X(ZJ&2Lr0C64ImhbaVd&mJ)n6PGQ$p{`MI0hy#r05)AlGZ?eU@+ncxu2CAsyl+uJPcx5^Ij5$EXe01jGn zAXh4!nXJ4?)zpLeP&ZrHpU!@N4qA!cvi*#X5T^o7P_+UPm-0} zLp)*XCaBh>nX~a)y7{jy$RXu7#t!*0=S=bF@m=Z2x0!xEAWlL-G1_;Y^2dJWeLldp zlA{?YLaX03L@Rq@Y8&}4XMJ&${8L!a!2TUy)R!J&g@I{=Jz)>D+qZ1k1YdiXBDYE& z&?6%2?w5lf5?R8%)KjJ*%12nNQ&+*BXhPd!GMcu@pt#T32Zi`FgoiKn7Imu$!+k{4 zAcD16U1X&xWeBRLSIbwjUyI>*!NLuJPE`|uv=FjQ5y-`o{ot#a1|l2(euk;8S?lv; zEMi>>@)%2FMiW}>u_`Rn8v+|dvFA6}x)O4C4bHw4mckEIHeEi;B@=wTVg-CXD^&$G zO+A@pU5&_el~_O&`$AsS{1CR$B90v*UMaiqMJ0}{R-*&9UkE}w+WwC)I{$>s0_>k~ zzNndKoA#%>63(&t#Z^C*MsM>UMWOgUqUNh-ZR*+Xz?YQ*{?JG3RJV?qW!Imk*nKZ%$OR#TI!d z#;oi&=TT}CreqRQirY?&io%1dDoRZZ$a$lKfV(I+TaA!&vhgxMy4IsT#>``0Fgz)Os>&Jw&h1 zLqnbf1MJeYtFqr^rZnpN7sX*i6uk!6I_4Ci%{Ex2lwmTS|3nK#wk-_83o4ppH z(J+wh<9S8~hF6~Qv=NI*1tmJl3@RYD*2>Wa@gC1@uwaJTDrXT#@W&!FnIj}qtHSe# z2TsiCl#NR1B&9VHrG_G-eI=(x2?~w0zpS2b%%{WmAY8y{r##qpi*nKZWDvex)Kk-@ z&sWG^HG4o_ikJABpFu?!{YoZQw!kE9ObPbl%erZ|uxc)G<n`irln1GU8gCO z`#b#@9pH%z!5i(t=-SSF#O`} zGIsa(xy5*j_DUmjR+5xRlYW4lK@Y3O1La}VcuHU4v(qlh_9tF_1~9(|!i_z;I>Yni z9?HEv*`LMv55gZlVplk02fT$@B`%iN+{vC$0uL?&hjOj@1pr3KI^U)Cdxa1$lgyszYU_;i@@T z%9g|h=A$ezN17tZ#{x`V*tKF|S*SiDU$bLWIo3Abyabt$nej`5iD+Xj%AFIp^tm86vvDu$E`vkl zaoE?@qW9!CfYNx7X@dJ#S7WGLONQ1KBaolOQ=Q?;dB9piu7>2vNM(O63s*34Q8R>v ziU!$tj5;sCTk2}*7i}V67{foNHRLi10FQw#_y?@bH!SKbkD9B5eHPY1)lVM#hTB_Y z>`324Gg+Di7BKX5jd4>ng6b`67NoTl_8aGJKZc~yT3a*Z#8=6DmJQYafLq4+5o}eX zB2WLmzk#yq{U5qgxck208d-7jgap^?%mDZGZcSTV9XNThv;4Ih?|IhupLALB)SAT2 z^kWLkex>4W>?mE-e&S+3ZawO7qNXjQD;^)AL>@J=c6JwU%@m4mf}$8en;tI$AznzL zk}Qp+CM{NO07(Xcyi&ZD5zLZS}!HoD{477ca>& zZL>IHD?Z{NmAJzy_{I0SF}Al)SK;Lj*Z7uSra@+Kfk?o(?tS|TIaWfT3g{8(4Wd7? z^$F!eG;D^{y}83HHe)pT8fVY3I^*Dg!|a*5NXFcOXJ5VOUbaVRE0u3RVaU-BK?G3mgWU|;-F&*MIOBNZ?c5a^Z=+* z1|W}AO;BLz1C%fcg|n>)EJIpU=kJCgQoiiGKmQp%vowo|SZTg1*)+R>ABQCSy}aN? ziV8R3HHuTjzB#xx9$5?54Ho>MibQgbhzt`L%ua ziE&(oSFK9f#Y13AZB>!_HSjzyA^E7Kw_Wu#N@Kh|dxtz?nc)^#Zs&b-u=IE|B6$7# zDGZisBH3BW`+_^saWx=*$6)PqJ{%P@reJkARf;0Y{-53`A>eCIAnK`(uJ z=0l=M%(87l&Ly6Jq=9{3woLe@?h*k2re}J(fk6qDM=ke>(TvT{?bl4|!CY|j8Pv07L@mqxxZK~P^?qpawiQ^i=^1>cX*l1Kh?_An*sT%z1c~V@ovFUa4rdtVEp$ zAGE%U3bL_8X*b~5;jDXqD29I1*3q|)!AfW`?j8+Ou0$C&7zRL{ZJ{AXE zs)DXC+my*7%u=bk&($&khAT`{DPi@@+1}gG&YXRmzXQCQnhCzU?qgC#(_Pk~hsYh< zkv3G{HFAotkTCyAp$lQPCiCKGd_c#{@HauojASO~tT8@b-h?aF!9>>?O#HxQ1owNG zCy+{g7QVMPx=6JXX-`W(hbOPJo1t_s@QFK0&4oc0|KMW6P7~uoPQ2q*oH%pSp?-Ho zlSXM$a8Ru*-K1>rr}YfUu{ANO=;WABvdBo^TMjR-R;nfptFttsS@rJPdj9~j_wlc# zm-`iSZGI?OKoaqer>j@o^Wn>{tiL2oKf`oMOu-(tQWBSC3GV}of7{#<&BtMFj z8<8$)-XJApz$1_HXQ9-ai)rIK+cNebu+zQhNNZ9sF*O0R$Fg`yp>Q0ac!Tj_ zyq)FRRw=RK_2t}sIN<(oYgl>10sbV4662!H&{;!<4u^(pazmV#(|NtHv59%{&UMEV4QC59Hq4j? z*CxG)$Q7J=S?$)^8_@;@LXV))o6_{yuvB;hC1)=h^ix751jiBvG=Pv5=AOGgum%BfY{>Tf6#g&naySvYzrEB}71n7gs9H9oxJ|G5Jy= z2zj_XCKJ(Ek!NtwPrl%i6acJ|QM5y3u%lxs3ClIuP30#RS0S)sLNn(69f*rV#Snep z1Is|ZcE8MqaKt0;{BLEJS7+fYFq`tWayAE&JOicP#k6oeSy8d=^V+G7!;nnW;8)(D!lYG z8bbybGU~9`(aDNmJx~FfP zTtg+ZWINe$yc}UPoiBhUlBBeR1nb_xEgfvwVuOBb#ug*^*f}N@!{0sUMu2Ko8kc`rtPl&MRT}s4R_gb zqa$F3|58DUTfa?1N3L{<&sA|5t!R7ut+^*YMPc&mOiRB-fcQG+4K*d*l>-JZZoYmF+6gamO`!)b))cmaJNNuvY&c?C$t3yZK_HW_W z+A`1na7zVL{GU4SOgEZ84OUr!KbBDx`!e-ZB)Yfy&y&1CO34@&i($B77K4Ko%0ml6Qde*i!xIsS@HiasN-eoYfTX}zJ*L{M zu(YB8>t$2Q9HK(4t^f)OIqMN81R%?JUIgO8nNcbSmbTn9K3Z_5vigL?$iab&>)nC?;SPtV?RVUG);SBl0j3D<+?bu23N+vMCy z#<<9UFKfC%adPN!+k&1(PA_<;_ks)V^+mq|3L9sWd&qIx^)IC@#~~!7n42LP(^g81 zKU}6|MqFo4Tz!8c41Fh&Sw4}Fh-IoT7V8uF@&?|(ixmqPOIDGfjhz%+;lUy2dG`O{ zn^z8#rfQZVVfNWur0~z?{7emJ9)6sAd;A(lOJ=&l{t>V*;65PW`EW^l?Cs0N3wL5U z??Ly_w@5Te9DMtiU9BwoIgqMcxhC`@brMnpqzd4$O#!oi)6GsSg`m6<_bIngsdqM; zZ*$yyrmnoa6kW#^Q!MWYZnP$~ln@yJ?L?-tMWu(U|-@3bHUs z4R?+tp)XDqZ!0@ncak{yAq)sJFstIXYTj2YCs2N(3+R#hSRmvVSBjOonfL(9+Q~6H zK0a84hVwC&V#8z*IQ!A{OxzqxVZZeoMsWb$88p>QmF?-Q0e6_ zks<9i{mTm3HR|g-bUXIfQFw~8E(LPScg?n+ul^f%xA4mOMY)~!(Z8Z_Z`OfxPai57 zD4bg$p;jxKGT1wAf^Pj;7LF`%PjWJvG)43~=xQD0((Ws8w}?r2Kd3cKq61!~4>bY? z#6`F60P+ixVh+BU0-H$v?|tX15M8PxADvf2AdXPJ>??JNW>u2IkVncc7RxGk ztYvi8v-B3?QczmkSrwC$z5=nrlljh-ktGSmzgEa((eu=8AqP!}q!}>eIkDR@Wk4fQ z3l)knk^ZHex_X&-Mxa;`3G+B>m)4j;{3|=%xiMR>_?Oc_MvSB&VMy_lT<fn1mb4B<;(HzmhCIKKTfFZ)O?n! zH{5L@E&Z2k@5FARWu`PB+*NuK&gYzfalaCRKy?q6LOXY?g(eOX^5Cm|!EI#5dU#yn zCO`yUcz@%9&$Uk|78@`aD=C^wxVas3SSzI0@B3Z6N<)`>34ws#Ec)W^Ah3CQC-ycw zua5}*bQhiY0$*#tf+GUYu)#$Tb}@41DA4&PCB5xy>otRX8ykl;`YH4%-D}wV^_oU# z+wQ?DD{$3h*W@R|s)j>kxAyM?B}`ruuTRe#J}#5O1%nmn(o$h+t9j4;Mv8cPZmHC%*~ZI>UT@t9#q2ywV3jLt@WPpEK<1i~LM#3Fn!yL;UU?XaE@clzn;ne?00(p%>S{h1-`L z2+*B-^#;n+vnP`R#rC|OiOv8;E?`Ia6wm(GV)gZ0!CJSKy0p2}9afm}^ zD+0r)pa56!%-rP@VDoi#QqMR{*(?0lN4xc8h!zZ8M8A4kUQrXNadRe` zDd)q9L(V|JyGOvw3(pAD;%(ry&jt*_mfzTcCI(msLvABXf)r!gMMC!RE9xN`nby{B zfy;dNM}v9^m2J;hHYUp*LI?l|_gdO7rRlg1A@)p`KjTz=%!JDlN?r>W+Y9Wm(BTce zwiln+Nm)l4upnUCf|q8^KBwZFae2l8Iww{;cB;_kRME`>CMOo+sKPgI@=+3){G{nl zg<|g@>