From 728d07381537df74ee7cdf7f0d529609d5d93399 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Tue, 23 Dec 2025 10:03:48 +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 | 221 +++++++ AMR/datasets.py | 77 +++ AMR/functions.py | 912 +++++++++++++++++++++++++++ README.md | 184 ++++++ dist/amr-3.0.1.9009-py3-none-any.whl | Bin 0 -> 10464 bytes dist/amr-3.0.1.9009.tar.gz | Bin 0 -> 10303 bytes setup.py | 27 + 12 files changed, 1648 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.9009-py3-none-any.whl create mode 100644 dist/amr-3.0.1.9009.tar.gz create mode 100644 setup.py diff --git a/AMR.egg-info/PKG-INFO b/AMR.egg-info/PKG-INFO new file mode 100644 index 000000000..c8d2741bd --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 3.0.1.9009 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..775bbd109 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,221 @@ +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 antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import custom_mdro_guideline +from .functions import eucast_rules +from .functions import eucast_dosage +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..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..9b8203a42 --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,912 @@ +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 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 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 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 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 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 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 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 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 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.9009-py3-none-any.whl b/dist/amr-3.0.1.9009-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..cde4e8c3f013f8ee9fdb72aaa5dbb143c3e44347 GIT binary patch literal 10464 zcmaKS18^o=yLD{awr#z!?M%!!HYT?1%uH)h|ue@}Pq+SOgX zRy|$a>)HF+dnwC-Ltub_fWUybD5vX1U&{}NK!Sh-5QBgq|G5iLP-QkW1lj{#4Gozb zy;61L+}F8K)?YFB0NF(Y(F_d}Wca^9JV{peU7;Y1Kng8#}fBhT&TeS>$7he0xOw2LHU~%!S3S( zAD1$j5(S5Uc6S1X2OmR&{kLk_yBc&FES(q96ELKkGDOq!jXHnG@IxZ6;#LbiomLVy zQ1C0iM?ht%YUi7@6#c4tMVgipVTKzarCCi61KdJYT3lC3roQ7~+$McDiKP{nJ)jeH z4DcI;RQY5f|7^+iFq=1(yXd|)1|DtkG!G~`%PKa8s~DVpA7w}%v=3tjZtDu4Nb)%J z`#2T^-nN+w*J?0fwA8e-L`HT7o)EsXsj1or1b7e>n_0r%jJ35Sv8u?((`O=@=MPG% zOFIor2+3cphED{~q0lj)Wl{3q$>WCK?g>*f>e(pndH*-X1#$ zF%jwwltsRz#ob$+naW8MS6%%HLLuK|TWGUJ|5th!Fe$dEHovTc`Rhv+`S=F78I9t`lpm>m142 z`sa-f=O5e$sNR|^4NroUzu0)E?DKCr?<%WqIv`OPx!p#d6v!y|DcyOHo?r$-Kh7BG%j~RZ>&OR2K}+Y@>#Z~cUaTjWgJF?2K{}B{9&=5X4L~x zR?dO_OFIv5?AHECLQp2wOuTL}+S5oF_XNl;ZM0td0`brzAwEn)r=W5qL>4+%XP3b! zNw|d-k}OI8VJBsB9`Pca(f?=acF&fpId%N*1I6X;>8;L+n| zQC$H6(nyI_-%Bhl5nh;XqWhH_Q^Mx?(*MKSC;KWz7l=C z@ubsobfA+;n%0)A_%_c`3OuwN^a^ZixJk5R%+*VNhw0PPyQdRX=riW03(DM6>Izt6 zoOE9h-p155SZz&n(@Wk6ElLn*JLx9uhB$;Y4%1!}%%q@Fb=BD-)on#?VEuu{X-rZl zZq{p(^8476NN!__46Y!ec+$2a_&XX4#Any8ZqZNWP(N{nh=alcFc}O%7eZz`AwDYj zNOfU$fodIWT4hrqlG75x@Wo=G#^Un1>=o|S+*aZmEqPk?H}b2b$S|9DE900RT$DVr zx}@jcdJbh=G&-<-vp9I=GqMz_XxisNEF%uZB0r&Znc6d&X3nN_3{u88`v`5Qy`u1JT{Ep&{w~DSl?F zrSDj^Zh?vLJG}CLB<#Qdmdt%{5D)~ozY?~Yv8%C*xvR^cgk7a67r(}Z(tWDMG6g`} z#hfFGeMzAD)+a&?@1P5z%>bc`SB0xaA*X79AN_twsJbw&IYVU4Kw`}k?_kl5%UF@R zkS2{@_h2^luA-u%Dt4um`lHgU}z{Y=?zi8hy~<8@xCH3BGD4VtaOp;3zOS#=lVDhe{AK zt7{phw-qFV+TLlDFUKQ?noGs(4QFs^E@{^X#bA*aKOvBa4)<{%p})LU0uiacT08+W zswelYd6PWe-6w|n{8W(UYC$(mR;;Rc_9vu;AM(=Fc2Y*12)wK6$%Hpr_q8f?n9c96 zjyQNUqH>b!``S739VcZJX}ylUgT>`DmV+&pC`u@4lOT(cw1)>bh#$YzEd8J(z%O$` z8A`k0&Mco7snP-?Xn9h9=J@hDZ^I`G3CcW*&;HY#YVS!xfjBtHf50AmLgSd!{madk ztcHc=;l*M-UeYCyjCYl3p>hVzO97JIO|Pr$C?CB0NG%riE^|$V2~-dhX7cz9=b+)E z1TX!gq~+HK{96jkzD@VM2r}GfdR>Fc;T@Cd--^G_H_sbaGro9KpReD)Rv>)%=Db@DkH5;>vhNsx_PW4X zeCw!OX9XV}QQ#`Pbt4{yZWh%URv%UJ@VO?8ND$eYe^Tr17qzyar-*BV7Gr?4!i3jlWR8+<*CC zd-B%=Ye3v*=gtoy5KK8pi9j?+t1-+vq1G2^x_^wd_^E8RmDUc-L=W93$qgDyv3p%j zNtn^(F3IxHghfRhmd@U>Z{4pLRW?>cZ9q&8Yq0ibxak~=dUufsez}T8FiZ@&;l?tU zy41hLwf@G6;8#w!_I%<=6A{eR;^5WzRPg|neR%1(u>~dsZ_|-~!>Y7n{}S(O)#^=z z<+JCSLLF4aw!{!gH*ku50ORc*7yLdDO4RSshIK_oN{2lXxd7`4F+G;Iz| zF2gzNL!SXNr|{CGd3+c+-IM6BA1H7Js}d3r{31c=k6m-tTiRqttOO}rxSCEmO6nK` zfy#(Yv-)xn!XrUR>{@6$NC_dO&_6DZeo6)G;@Ou0MgBaX3NKOg2BD*TQ=V^f3Qj?K z(y2BhRn$*(2*8ACS`^t3%)-{J+gEz`#GH8NT|#!{nL~HU}8<1Bhu%l-nW^Y zD+TDASU?jVS;~`s)KTNUl1>)Tft_5g{5#FNn(or3ge{6 zYUG*9_*7X=QXxSOipeC+MtuwX?fbpc+^=oYsZ^yuR8s3pb&VA%mFf^)o-5;HQFH#T zdqL{@<6zT5y-mub&=Vw=TrL?SHDalK8(L9xw_p2_Ml6i`;6u@_T56Th-T|^$X|5>0kxx z&*P*&J)zCkm?Hjr4-#LmD*YUI3U+Rs+avgow3fK1Qd`>J+I6)rk-oFe%*>`n52~9^ za6b`^9O1!*R&}~j(C61q&z#+3xCu^lhkP_gKs4JMaDI64(3K2D%v-ZZP^$^@GhOUvRAIB8?DN~8;nKL zaOLk@m4$8>vp~0=? z!H4MvtXPEZdyOkp(_)Wd?-t)hheyu}!DHf1Tc^VxOo!^J9ER!bAP1=#IDX}2O?u_B zgbe*54?wXMYC>-B>pZ&pa<>m-2JKT0l^H5OrIJ8-AS=* z+`|~_itwjYm?E< zSiSeLnIA4#@&J+uxOtzsE>CWI*GlUSB)DccZwQK`6zKfRKq%F@#IQ=|)H9L;cbNew;9yhON7z)5{!RB~a3$)zmgk zzlWEV-hdv>lc=8z!vgK4?ftCgNvlb=D(0Kea56ehwJF8H4jAQQNuCki&|eKs=A=uJ z*bGkkXlS@GncVxfrFDbdJT)2@xR|UE2>YW9UGRoGfo3pz-IKt>jn4)kIJ8)ptNOR&NUfb1E^x(p> z8yKSZ;6iAN9&9+yaPl5wKdLNi7%2zQRgL)dUf41G*aE}Ca8#rRiN%+P2>`oF>IuUn zq!x4|>=BoxB=G>z3H5{$bavWE7E_85COWk4cgHAYJgv1@f7Fo|I}0%A9by54n`$#G z-BLv~?X|2v4D~s6$=`0&bQiyuORZ#-V;6lWvqdZ!2GP}(fu|cuf2MX}FsS*vqdk1| zTIQrTqE7{#jIm9{qec-qAjTxPA&W`85lOxye!rrAE^q=s8PohUlrBVnf^xcp>zex-89^z3**z~Zlx>HUPiGV_4ERCPB7P+~^ zDNwB|NhU4lvwweZ=o!vVsLF~6U2q>RqzOG}GgZ<(w&=m#Ol;{c#6;aX<_`ufAtnlI z+D=Mq|LCSf2cJ~ttShE3_iR=D`vC74j@&jz#bcaAu)v=Yu%)BxOuEyM5iYoXORV4v zknRc<)!{SX2>wvhqQ(#qCLz0_hw{AhWA zLAqI3e!U9zu=8E4<8~z23f|xvDZ^G_7`d$%mvEJ~8g=!ji#) zVZkj@AwGH(j#s>SQ#gvn^H_PXF|)3}4iO#T6pKS;*>>L9$x1%SXL|bOD`&trvN~{szC%yvP3KcOw za4ge1ZA!iULZ*mbLJcV#|04!HkXF8xk&>JgF1WErUgIOBn}%D{XUFUXORX&^>gCZ$ zIVA-O-ui}6Dk>@IOPwDvf{-VrEE+q=e5oV6h_oaawYz3kQVdXC+J603Y7ltF5miS* zuCZ~5F`cY%AbQH{@yy(_aiIFzvQW7xCj&;>w!0N@A*l6aMNv-<>3Z+~SB2vCXN}qF z7Q&|i5d_468U%#&PlaM^=gi2?#KOeN#LL3M%VY+0ab*PBTR1Q)NT>tE0qTGz-BbHD z>9miUl2SL82y^Mei+YF&Bf{V9=!Qlm^BYcJ9pY()*2xS^(TxQL%q%smH7!c@TeS7k zDrtoHM=;XzMA>|gdYE1msu#B@EyB^_a+nG_)3_XQUNpsL+eeiuL9dF#$9&0(mUBGQ zeF@a`B(?Jz?dqr<3Z4YfA(I+?b49tSXEB589f$CHtA1saTF?Ev0KJeeP-<9wtF&qFmRMimsp0U5i>S#E zsV)_T>kaleRQzF>?LM6!oW=~y;U8!N1;~K!$}n2iKVUa_5L%aY}PVd%er>VQ2}`Ea&;r3E1J~Ygwo7?&?B3x zy+rC|CM%BX3~2hF1P`Q?G7c0e7LG`+3Ea7io>|7Jc}*d0;8DR*BqaC@G~k2}L_zDy z0f)fCMxz$FL3<5nL@u=U5u-sfbqM|F4LGbay;=~pDbZ9I0R{HVB#g1AfNT7x#A&c7 zV(lF=ZZXv6P|oi2)szUWI#>02M|kKAS1UdI{2YQG zI%>5#2HD8U1>!|kDy{DUkQ!OWbhaCRL?_786?Rsq*m%Zu`I3%Z)(RAV5Jm?XAs=sN zC5lo9gEXu-c4%=?1ND$Ofm7vSLtJg7EBO{k?%%gcN{%%V>(%b6b|AUC#3=6mizfM@ zXAEXhd`r)p=UujMczWfR)fZ=S1^Q#`AciqD?>%6cKI6D#xd7( z!-|Pd90`C)8Yi3vA9kl$+|ge`MfGLF^G=M2q1d0Z9f?0ZrK8bN4rJ{vAO|rjYr05^ z*Gq*Y2Wv#Vz2}ogO}B{gW5iX~FL)Zqk7X(5w5To4+!lOwL|edt<15n3W|Ig8Npj?j z#T`GwgJR6Kw|634!+`2qlCQUSZH@(7sBZu(IwmLGJ)L;^jr_+!P`AYSvvgpS#1-~g zx=t8a|CfC_I4!eWzFW*aCtcaZ#yU|9`b{`PN*`V0m)Xt%0r~_aRC4Oy7b~ya#PkCi zSoS1IiAN5!rIFsv-+*+r*c_G(krxDAwp=BP?QWq*UX%~+L=s_*%ZRBFoe@OY zgaqs-eSy0|(KeI|a-RDX=VS~t;#vFoXy0y{)W-)-zg-H%fG9- z3ce2XR7i&&nO^R^e!l+dX(~f`CL8HjOQP41Rny3HSP_O0Drml$q=kgSA1M+X+{Dxi$Q8F$*ZMB)L24 zh%xZ9d2{H`2?n0=*Ytic7IW6g1#!r<8@dXmPBn}abeHB>kR^0_dbv6SSq%Nay-=J) z-EeVF4)gq;tAJP1n~3s46)eZBd7^moCQd)KhVF1M>PZ$6U7u(mP1u<$JrGhd-#1uw z?P{t-V(duNw>yUPz27|^f8Ga+pcsYr!$A!#3^rYB27P5{lb}U841AdqM4$}|aB4_J z*`zP>B?FC$lO624oKDI`sJP+HKNy8bh)BtC)Et=nzP2oO!1yM-v1V%Vr4}$~C4c7? z^o+5h5l@eK>dI_Zu|wY-Tw2{lZ9E;#)3SFfIW*B_cBnvpLz68tkNam79|<9$&vEz)T^Ckos3!#C}&7?F%p> zI}@S;YecZr&$o|pp#;#WDul|KPpp*+*_j3I9@^kYlHvqk7LAfGEJ30@Sf$reu1{lU z&Yq;5l!i(xLzxb3fVIEIrM7snC>&%@AL@0S7sGsVQ?x*r>%2a4+u^BuPFYHEMnLf1 z92}KU;uoh~DE#g*>lBtu`YyTUOk?IlP1eyM5D;oPcP7W$nk~-JsSO?7B&#KIicj)n zr;;c-yN$`2ky>Oy!?r=WB_+e(`-`xG{X8-w4T?=4wFb9XL>whs2Y=t#fe)LLnx72w zZ4kMy*h|MBbFBi zRfb5C61VDC7aIkvGab+)hrEsUQ!Q}}<;`Gm!@w>FtZZ>d%+04;^OUsr$-%Z|&8Z{U zU|#eEV)e44D=%=P&W~E^WSH=RTaGFjRiwY0pFp?mkvafj=)&<^N(s^)n6HAQ>@8=~ zyP`z>8mV><#Acl-CT#P$Rsw=~AMKZWch`!;pXc$FDe*}H;VBu*?D}XVjE@`kJ!=dy zc&Bk4_8xO~LXm|LMa)UcFBH@Zh4&YQdbC1hw2#9^>|djHN!rx&VhWofF6g_JRFR}E zT5r_{xdpQM3)arto_?)QnW0<8?x)%22nw(1At2)QI~JCe7{ABSCeoH5snkF;gwyq^ z!S%A!_a@JMK&NgKVgRK~dM8nlDS1P6Yq*`I-pQ(|FlY-5ei5D{N42s<3J@S}%;tJC z+aZo>1A#I~FH|{U5kY>6&H`Mg{1>fSNgO_9x(H$T6!@{oDnd9IT{8sgg6e0M^u-bZ zP9du(3SxBgSfKoBKRgaikSPQu8wB~W%OuSOITLMh!mT&3alnECpt7rIZ4(o4%V-Te z&hQMbFbA3SCid4&X70@=CTBF)cko=_xS{ERL@d~+2x zj0oNf=C(ZFOHBus{@$2&DdX5zRp8Z{zY9LF&FB|1?T?N)S{8#zp$AKtMT*F7B zd&hfASmV2M@PuzZr?h<}a}O~gp<#A50pad(x<={D5Rkn<^a9qe$7G%LVzw}zQDYKq zW6F~S$MsQx`{ceo*#5FCjYaf(cZ-rtgePsVd_%Y&jb??kM8y@Vhdk7tu?NT3VwCif z@SN!r(E)+m{n&iK?uw`YKZ^_L)MmF}HGJaL^Y@`G1%O`=iUa9D`qq}l#gj{u^3E7K z@=HM)p+kceDYuTXC(eaO4#R+Cdkt2lEIOj=ohO39Q^qrU+Le(Ok_W& z2%vxJm9P8PK+9oUTwrkNwDhtHZ#u^8eDyTr!s%Bm`SuFUqEuJ`@`}3SR9lCBg&OV+ z_7(iZ>bue?O@5Ae;6dkMeXZR#Yq1HN~` zZ0p#$bxOTwSL<8OuQlJlm1+n;bwAc_YMo8;fwlU5h=ew+{fMFN|6qAMwahfqVs;p za;QPjYU~A!-gEP+$rJ`5l7ED@`#oP}wZ=WF&_IQT_K;|w+22t+`M!SjjRiafRSsaS z)C^ve55r6!$T}z?Y3%25X6-#09>>0kIn)xpXd4L)PcftDLen2+K04Zz6dm35W=cS&a6 z^R=)Onw~fJqK7Ek@na!!`pO@}H7)COuRj z)VhX#dTO?d(_HaQ$CTmkbd%+fA3aQ=uy3hj1}1ywE9n&$;dTi2XS(S4;%YB^5-mhA zELb--#+%j2%r-e>>N&Y7;TVd0pP>I)@wpz3oqhRJ>FNDxME_LrX-P{+$V2wB!u7Kt zK+fow%q%0ZA?f28=DO08Ha5WLa2OSmjEmWCJqiiuj^b~6%=f8{-39d7WME%JIECn( z`n3J#DDf#8WY}Lh;3Tm7#6lv@ZL$xIzooK z@i#oeLypgdJ(c|iZIj@N-L%leUlQ|8+p1hRM_6;8!alZBs*RJE5x5US4Zs8#*H$aS z$iCRi4J10wMWxMW;F+XD`uAFw@IWA-vL?!=hYLev7DG?NE;JHQEz!SL5>Pm`B=f`D zF3UYEf5Xpv6=nKSdVI+W{eERp(9mE=Q0cXNs;>YY4|K+l?$qi15Y@S}$JHs*Y0lb; z|DB_RxYbY^e+Bq>ovpPsdOJ?LuDip-c?@EE?nJj1w{%cdiODG1+4Z3T3HSh3OK zU-myMCx55=yAc1P)1>$Zy8o8t-?{!Sp1-&*{)y{9r1W>rzsu-|X8FZdG5r{nV-Ms?%NPobRKJM?-tHS8+gqS-5z<q5EP z^^!$}PDzBH28?4cnuYMA7Zj>cOo>F9=UV-7*iFp=|D+Sp>ew=WW_A z9eF?HrI}uoJWv0DUHK&dpNDr|pEiQPkYQ+_xd1u#H&)(P)B(N(*p+M&jLyd-8=-m( zrUpt{fPIF!9l<0IVJQnRv;0@!^>O{P)*o2X6YQZCbO$3XhM}gpK&9rMV1QegxhxE# zAu3Vx*kcWq%KQAA_+vRW@NVl5%vzvw3P$J043&zwk~)W&zd&d_Uw}WKfHZzMM_B?z z^zky5BHg5N5o=n*Ez5Hl5;+Q7&atCZV`$<$2AYc)c^nMKVZng@Z22<|h5?jp{tAga z-sQPk2evWX?D2#VOeUr*{=_8{rk@_a2CUh*bfPTw0?z-Y z^d%r!Pr1nmB;zelvDg1ln@vAZx63awH?5HQ(IXLt8 zZTWRE|D@&fSeSY}y|BX{DJV3H!m%m9Z0`L`1L2R0bN4b2^cGEOf@jfMvVTLJgi5GT zKC&xLd&~ay5Zqf$>gs*=#WHaTbZz2w_qfWY9c4n2Osz@De~ja`|Aj8RiG zK4gqH0?QCv_3au>s~4F~wHugC{k4+1k6>k9%1@4702!8WxL4LdnMkv^sq{uC%R&F1DAL;-uddyZlX(7qSYGe}b*pwC4SA#!x0!wa>xtN+(w9 z*Rzd;JoYmL-{ctl&dIp8v=NY*NTGck_O6tBsoqo}gSYY!Twmk(!>}{!2mFhb-vrpR zE$fp}u<5D7U8OiZ=FXIKxcqw=g8r%>r(gVoP3}v@dsrx6e*Q&QFJnwCANRKj-VU!{ zDx?>1aMq9a*#G?_^n=NudGIE04TGz;xr$ZTmf_iIz1R!CcVf06@-WvfrtWu?Mq=sE zqhme66zsq5|6+XL|CRm&!6Bd4udv_zBx-0+h;$3b-qsgOWREPNB*pq{nn61dBrw#( z4$@ZVx}58c!(0|9@-+_;tD^Y3L8-aDeR%s}N&`ES&spf3&rjUyp*wY4u+_?Xq@;CH z6Q)GKWXIG-t=_C26Wn^jH46>{Zn{}hxsMKeqHqxBcXv9zhOkIZ_AeCU)@@N%*a1*L zB8$1Nu}-+JmBuvdP0@Frx}o0gA4U2W*ABhr?+c>*WrG~W?n?*I8Yck9g+$V`8UkcO-suD=ZhbOXEUtrTV4 z5nWsZ-eZg)bDGJ7ATT;H*8)ouH+9@&NLN=9tzAMT1IR|}dQU^FdF8o!a}DcJN+c7G z17?Ve=f7yn)Q1nmO9Zwc(|HAo93r`G>cCFfw1U6|r^P@=908E0-2h;l`b9})U;)b3B1Q}L&%7oQk)vtB`41gXdJnAh%4$vAVv#dPTJ z<_izaxg`j}7)!e?P8vD)CMmDjl~vm>4#SX&>Fc&Uo;&{3xK)uXkT9itkDoGUo8rP2 z&l5Nk+kS!)U$C&vQEo1z?BDfpM#Tj3qfnZ!jv!Gzae2Dj3{<|wmM6g4-AM_9zrDGZ z(&wc9c$wq+#lZ^mI|x<6-y7Xk^mmFLPmA^kIWt5DsYi9nE|}^CZ05P=_7&6wHCtZK zMg0exr-VEe*Fep7^4DQ^c>4Dkg3dNN+Z;W27XQlVLt#Pus;aL`3)MTdF+~;T!9E*~ zUq5zRt*$a2%Jd=qy~zB8H#Elrjue~pp2{-m$33@8;jeB))VW)2cS6=-6IX@Mk)MmU zPRvZu3Nr;}DiNPkH-_~8{J=YkYSH0$n_Mea%UZTRzKjb1eypR2E1v+*#cH;)>C41g_d=(4P)16bX^$%ibLF`<11CM-K<||KQ z_U_#_4hzNEmv)5|)g&`1X6u^-urLZN=l<~#7F`(&HI${Li4T4%$IX-<1j$rALylxG+T}Po(>+76y{9pJMN{49F9bTOkK-I zf3ZYTdba2K)~pLnxmgWfvLt@mK^K-)t%%08qEO67{AimjIE2Qv{(iqqB4YwDSqLVD2e!p^ zj0w%z2C9mr!t$JkCju;gv&GNpA_jGJ9f>%Md0HAKLm&{5?;@O6inZ{QpFv>eqmTu1a$F%}fr)s!O+3S|t5T{6LO53?`Uv_+0!#4`)ITbgE zR>p(zQBK}S&bEdZ|3AHSIx1xzXW^AB1NDE0@au;*ae{|otAeK5w|klIimu0qa`rO6 zw2YCuxRTB@6s=UN%IW;}2ta5t&9+|V?oI>EzJ%@f)*pYGhm;EQH-sEKmI$+}AK)&vJQ zMv>R4%_4*l=6>c$dJ+EHl^#Sr7+9SE9lzIu zt1rAI;Gc5opsngqJK@AoNoEZH@2 zp&1?Fr8ZJyLt*c%54=x}d+jk1+P6=T7KN#F0BR50Mj_VQ7f;j`*s8*t^1W`HSUcIV z8v9<}a#PI}$seIU_UI}fZ)G%R&?>5Rr~(56 zC$qMYiRAg)%L-eqGBJ70QYXqh2|CQzcCy$`1_qx6>pXtu^o})3$GWl8@Af0;WnZIv zU!(SnvL;TrNJDvLGph069M$d&r-J3ek%fPKqgh+sUi(ZKT+)=ANJHSDC)bXAYTkva zeOu$UKvCeUa1ZrIHk%SB6&ldHN#?U}2wAN+w3o*k=2G#f6B0hi`}1I`x2^f1?4G?X zi9t&I%ty5<$S|jT>49qI7ZSr@?$0`q%A126^FRM1t$y7G@5F9)fs0kwh$ccYV5FGIdKaTy$Ut7eAHszNl6;m{hi zQw%1Vxn*@9`NFYHv`c;Y_l_G9;(q8EF1xA8Dg~>Y%g8y68h_n#q+AM|Eq)!PVF#2x zm7wGlYLGbk8O4|7f1>GD#a|*2K)6*tt<~sh*9~!){U)zLq_-nmGQiZnZ0&AmntttfS|j>7E_< zl8_to*VjU1P6Byz^T_NTS{3+~(u!UV{vfkLZ*i-^{mG~c>b`|*N%!%|XvkXcTf&lL zT=zvZ8hd7Ie+}~6z;=Fju`?M9xiZ`R%Ae8Ep9@2-SP9Bx7~}-se)Vwu!iCic;ynNo zU-)2F7tj>)?m!~gw|#e*kV><=r50Q!;)|(?Y#&YOkUL4Dbt}N9U7D_6I(*in`d8O+ z_k>#Zie-sxAJ(N?{9naw%W(x+_w3p$z$X&C7{cSYvVQOo^fj`PK{#Ot^Kqdp zj%xokp>n@A7y2lEPF$lEF_DET%V0s#yV)O+HL;Y#^Y&m2rvB#L#)2aDv^e<=shb-^ zJ^Kj?;jpIr-Ae=FTGc|`O-U_Oh_dYJORI?d)*% z7TO-fWiM==#6KG0nfiVN?HL}qaGT)vJei^@(ao=vx3ut$U#bz4`1{DP?r}ra43*a% z>y$+X$krhb2>rFUrp+6W^l9syq7qEG&dKb;T^NrPR(PdFt^NfCjrvD)E z4c@&0<}|Fbp@BxL&-)j|C8@%+lMCG|@re4H{rp-v1-{Y1Hks0EuAoqfcyG7cVlCp`3j z!CNb)0(bLhlWdAQu{4R~f?VmJr4eYzz=aPX7w}BtR%+iv*Ql~XsEH`-bPAPJ@w!SCDh* zK4au4R@OIT3Qd##i+8dyTtUz6jSK&*XX8TZ94283uG8IfCUxF!t*i8G#%y+(a9wgd zDI~YCJ<98iWxU}WTT$Ocf|8)(8(66*6=KD+{aH*TFx4i;>C1QKza&b{ef!&e3*J`J z*SBzwOY&Rgj3=5gy}&_0M>T9WWKf(eN$~IvHI7gFTcziG#@ba&XTItgdsM>prM2gG zme}WQqFdVHb0SQ^n%h+$;_hlE1QjZI#z2PUR7$^=vpZeEFvrt4tp~wmS;ifTo-TB3 z9?jy#A0Y(SMSs=p(TT1g?wW}*OE&Hi4+Bm-F+`Tqaf)DoIObPd1IJF5YGkH;z&jKl zxgK-ZYK(goE@HC=(Tpx_o6}EW_?D2jf-+7TG^l+=%&9P}jp+a1CIkzx8BSuDs_H|l z+vqKE4yX*tEW|HD{p{El7Xm_I986+qV;HF_jIk??QTWSt@5sBIqO!FZHcXzNt999w zHQ3-JoyV)K_)zK>L1jP>v_Gy#POL8Fu=4|#6_S0qQiL$tHru;R;8fb%T1Fv3OY$Tpn)a7*5C~z~9xRvopoF1F6*zsl+Gg{9HLYhXdoQ9)vgr^$^2U1q zde5cQhqiBa{Nv$!w@st$iEmkg%QTTbv*HUC7O`O^>ZegciX@JD-FQ`7Na#(U+E@&c zh)OX$M;(f0Od^GFy<4fCWidGiz-_hGDDzj{tWuQx=C6QP-Jy%oAKL^;Ur0U{bhhXI zqsiAU4$EXkWfC<^Z>LxI-8-Cqm?SD)1G+7pnm_Vs-!Pu)xF8oay!1FeWY(YGFm)5= zIOprypu9yjOX-NV4u_y7NjNVc#i15xD0L z2h>5c7rD0qtR|ZOsGAL_wgQvRqp4uSJAAKawBMdjfH!;_v=G$rX=?%T{N4xJM3w>2 z$OHW_5YNgh-m$$ss0MZc`ajyaMleX@{^AquEo^9`M@$q5-5!r7gQZPZ$iQ%;cCN0X zUZc~e^-CbhJ21?77|1}*18{%HO0t;^EVrH_Z!*=1&LhB!`jl^srhLNTLq$;?5@PJG zpT3GR2Qf?*`*vx)rQO^Oq4L=sFxgV#u09ma_r{t$65UEb1`Em(buSQhM_;9P7HN68 zKuJ>F(!c^cF(Pva(Q`);dAD_Lmcs^K#vOMv@3Sanm^Vy1nZg(3H=%zL4iAUNGRt>Y z`~bmdaJZN_P5`eO-UP#?fVd3{!!PmhG;G)(>cuiT=y-m0#7yf;N{my$okuZ0eVC#W zkU6f>BjZD5UpG$qvS=+iH?UgaJ^D&*w0T3zY?GS`3lut4`#fo2k3<3sem(qkpdcM^ zJMb5^`x395yYVIQXsvx{XR?}Cl=-az;at{Mw*wL){CfODz*)kmZLTgsC-szK?IlmZ zE5&iQli0yFR5#1dy5#Z-vmk6+lrWlMRK5MT(&g+#e7GPM;161G8n=@AqWpCNZ_4ba zsyoDyUC>lRPez6acPuf1O3+0H^34)U%E7XDG0~x|i$qrA&jiGgvU`jf(Oq$w5>?DB zmMM|m@TQ1*^2AFlP16NIftEy1O(HaQO1(|A)8q^I5dvfZas|_ok+UX6*RD;J%DNEJ zF;o1pkCEretM9i1S~QV$RbqFLu{?{jfDQohb<|~lGNHe?jr}VnLltiS`N5{@|hi;kuo>=it%{GtBX3BwvK#Ic4l)Y5Fzk^1OA&1kAn2Ywlj^9C`t`)`?Vj2q| z4HbbXDt&03Ibg?pl#1R<2Tpwqqm=2wcfI%^w)XO|YW^ab6LXkbk_~Uu*-u*P3xS(t z3l>$Ho6dH8I+-5CWKBr~yt4g)m#cQ8aMC@6h{8!>z$y5`D41o6%Ie34Bep2-#Tsui z0@cC79pynWKzA@35# z-DEB;c_x+HqrJ36Bs+_hVwNjajybf774#(SI%#~7UhcoYJUaKCJ^a505AQ@ox01ma zqX5xz_G!07R@bua7wz*;G*7QRunib)Ta*$Fg1A7K^5RvYQmt?y5t*a`y%b4Cx@p2? z`_(N?Kkf*latE=D4h;>niFYq$q2lOtWNYR315jVo+;eg%(qD4QcF4@OjO>N*s^FHRxDOI!7aZI8*I2glW$x#(d8IEe{*DNqjbvnQb zBm?AH+mg|V0sPY?@Jr>q?SDOohR~hG$@-(s)4>OaZgSS>3MQU0BuTG|IfXPSK9&R# z);wp4U9zovXK}tu(wC&AKA=r++yvb$7R{j$Y#bqG3LZLBnoQvV%qbR8<7lU%=_9JL z$ZGnf6DINU)R)6)c5pckI6JgUG-8`$na8M={nM#v`H^+tUDdPOBNj>dsGWLUKJv{z!z23>YOyQsn}DwT*?Dx*R9OaUTd zT6E6LJ7VJ|D_e};zfs@@n> zo7Z@w^>M{G!LzCCXlAY+5eeGN7Kcy@h@UAmR31!ZknCUzPXBIrxtH|L?P93i)*Lwu z31GT_61#MhjmcULmQy*gqiiBfkjj{lFBM^PD1;yPa=Jnj+Fy}~jz?>Dpl6qQ395s* z7RRCrEY^`aJcP>(i+f0?V)1_G@-?~GV~AxZB?*9_Yker{2^@J3w=vUh>9WF9S`u9l z00Jo~FVn(!X3in)(CJM&RdUOj9SdLHeTR$D+Dts`Xw(ufm&*H+5I$C^Y_Dim2l#Ka zvVSjkOT;KNQq$A$HOPGwp`(4aDZmT74I4fK1`?ZGD%Df(;cvLtD(WoB0yI9uJ6Mn% zLM3u)-(iMyQfe7;uv5lKq*u*|1&FPFW1!I@{~_P)mZ6CA-Ao-qFqIV>%j6Q3cXS$7 zY2yf|G&)Hj)jl#^=C=;01&od-wdLHSXGQ9WR)8b*F=G^A_&q*rZS174#uM@mq1@vG zS!FhrfUN(SNQP5ngf8DJnN||(+K#EtpAP}zM+w2esYn>^;CJVlYGQV>vxYUrXL^_) z!H1&FT$IU+y(_@IkU(Fx3ZZ}&l9*$d!a%nIVGwEpl}#Vuflg725{qSRl=piTVS4&# z;YOY~O{r%e>b2kdb9Du1jm20zc>4?8o&Cu0ELn+p7Lk7txZuM38>)Xwr|BF?@s&bK z%|cra8Oo9I2x(gctSOZ((q?wlC^+{?Is-7(%&O0Y0jPJ4AFAzX z`mEtD;^^Ydb~Qwe1)MAvW=$iXFi%45_J5x!`*BoMD@H!U_U~$>BvVfYBom6kzGuFa zWf_81$SHvgN?m`Ti6Jj5j=Vl8(+fEQ)CcHSOKTcW8-&0USUbC0f4Q~ppHUmhOC~5$ zOP~e`EYvT>mplb%r1C1f2w{gtwmigoD}+LH3OtM7L5VMA7slDM^e@n}JX9Tb?D$r~ zcv9@?r=MBWRmTlv+FpI0*7nl$LHs2D>H-nR&oZJl4Q8a6ibGf2bU4dO`u`rQm8_!V ztv_w5NE^ohti#WD!u_tFMsLQ77bkl-Lq`}BoSQ}!kvy*URZuKzK1$NW)SR0=jVrZPZv%&mrz>DtlM3Mg;2f>M1rD6Y)z^%8x)-OhB-!kGmG13Kui?={ztsXY zA0)mmzo%In@(2y9fzJW}s`$K)ESVm*K#%TH&JzlZvJ|IPXKyazd$%fD z8~wp}jSh9lzIgPMCYWWu>sgE}#T{Q&U9s-MHl1Chq#khk`V=Qdwqpt^xWz3Y=lZ<7 z`HeSRMlc)sB~Avi^nlWcdH*fc&h&cm=SiuXSCCDOKIzEX=+(~7dSUduZBvwFtFwP8 zZRXku%bY`6a0>UW8mEunH6<@jTFZcu3s$~^oiNk5(Zl?PmKhDL22J^V z(Xhpu^>1WDvy_kt)1|2fi$6P`j*L3*#d5mxK1z7&$U_@-`A~_a7SIb93MRDb?w?tQ zS$DRCj}{B6;W`62kLD1X8zX&B77NzRYlfl9z|@vY4O4S+-f`&pvU6AD&u$TWo{DPK zS*?g}#ebmU{0cLAlc|2#OU5F`>?RxNu3!O-X*{`ZKZrYWGI=oBnsZM^G{okzRRAz} z?{>>L|FpgQ#6MaBUrbMHScw}ropGVl3#EvP##uLM?g>T3Fc<{1*C(o*ck4v3 z@Z{roEcPF>T_?er*5g~^lw}5?s?sJs#FxFCI)eJf!jmu4r=Y9R%vDfJTt2o{@|!T#&n@u_a$xs$LR>fxjM|>I!kX z-KVAKi`D<}FEPZ^t$c(N+`4&O|M4|(NeiF2Dbf` za9-c+G*PYnIfdq19ufVWK!GY?;9`iX|;$7!o~G10$1seMOOX z#DAzaYzTkb!tlQr`;a*karO=6vtE(z#7MI&Wfi-y=Z7sJ`Q|QPF;ppN^K$Ak&`_pl zRdo^;@Va=@lMj=>=~4OsOn9UX&NzSp+{8~$9%1y{5_5MipaY-;?BvmG5|(oVYd^T- zgTmI$YqwyukUv%uFsZ>IDN6NjLUk#u1uL2V^|IHVm7)0rJ6s70GU5U|7+En=B1XXA(vWo4MNXdig*N`#21o{r?a* zfM54FfOi_V5Hqv$*9&o~rD&SB;@e~X^#VTlRO=K*v;F$E9hd(%^QA3+j%(@yoT}F; zs{S9vXWCZ5Ps6~4s{-#AyRToBpMhzzA&HOMTia4QSGZ}350k~ObxE)nx<#XA1GTHh zZ@x7#++__*^&dSI9&ib<6ZmJG96lBv0HM%tudj+`W`ABTK#~s+nP3=n%l_uMK+COY z5*VBu&vSHXI;;`Ye>)FM^;Fu=a8lO+N;)_BIp$nQ|FKDI_fXZae z