From 659b5e68d60b916cdf89ed720549c60146a91c71 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Sun, 20 Apr 2025 10:57:13 +0000 Subject: [PATCH] Python wrapper update --- AMR.egg-info/PKG-INFO | 212 +++++++++ AMR.egg-info/SOURCES.txt | 10 + AMR.egg-info/dependency_links.txt | 1 + AMR.egg-info/requires.txt | 3 + AMR.egg-info/top_level.txt | 1 + AMR/__init__.py | 213 +++++++++ AMR/datasets.py | 77 ++++ AMR/functions.py | 665 +++++++++++++++++++++++++++ README.md | 184 ++++++++ dist/amr-2.1.1.9247-py3-none-any.whl | Bin 0 -> 10186 bytes dist/amr-2.1.1.9247.tar.gz | Bin 0 -> 10048 bytes setup.py | 27 ++ 12 files changed, 1393 insertions(+) create mode 100644 AMR.egg-info/PKG-INFO create mode 100644 AMR.egg-info/SOURCES.txt create mode 100644 AMR.egg-info/dependency_links.txt create mode 100644 AMR.egg-info/requires.txt create mode 100644 AMR.egg-info/top_level.txt create mode 100644 AMR/__init__.py create mode 100644 AMR/datasets.py create mode 100644 AMR/functions.py create mode 100755 README.md create mode 100644 dist/amr-2.1.1.9247-py3-none-any.whl create mode 100644 dist/amr-2.1.1.9247.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..e05a263e0 --- /dev/null +++ b/AMR.egg-info/PKG-INFO @@ -0,0 +1,212 @@ +Metadata-Version: 2.4 +Name: AMR +Version: 2.1.1.9247 +Summary: A Python wrapper for the AMR R package +Home-page: https://github.com/msberends/AMR +Author: Matthijs Berends +Author-email: m.s.berends@umcg.nl +License: GPL 2 +Project-URL: Bug Tracker, https://github.com/msberends/AMR/issues +Classifier: Programming Language :: Python :: 3 +Classifier: Operating System :: OS Independent +Requires-Python: >=3.6 +Description-Content-Type: text/markdown +Requires-Dist: rpy2 +Requires-Dist: numpy +Requires-Dist: pandas +Dynamic: author +Dynamic: author-email +Dynamic: classifier +Dynamic: description +Dynamic: description-content-type +Dynamic: home-page +Dynamic: license +Dynamic: project-url +Dynamic: requires-dist +Dynamic: requires-python +Dynamic: summary + + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/AMR.egg-info/SOURCES.txt b/AMR.egg-info/SOURCES.txt new file mode 100644 index 000000000..f37c14848 --- /dev/null +++ b/AMR.egg-info/SOURCES.txt @@ -0,0 +1,10 @@ +README.md +setup.py +AMR/__init__.py +AMR/datasets.py +AMR/functions.py +AMR.egg-info/PKG-INFO +AMR.egg-info/SOURCES.txt +AMR.egg-info/dependency_links.txt +AMR.egg-info/requires.txt +AMR.egg-info/top_level.txt \ No newline at end of file diff --git a/AMR.egg-info/dependency_links.txt b/AMR.egg-info/dependency_links.txt new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/AMR.egg-info/dependency_links.txt @@ -0,0 +1 @@ + diff --git a/AMR.egg-info/requires.txt b/AMR.egg-info/requires.txt new file mode 100644 index 000000000..fb2bcf682 --- /dev/null +++ b/AMR.egg-info/requires.txt @@ -0,0 +1,3 @@ +rpy2 +numpy +pandas diff --git a/AMR.egg-info/top_level.txt b/AMR.egg-info/top_level.txt new file mode 100644 index 000000000..18f3926f7 --- /dev/null +++ b/AMR.egg-info/top_level.txt @@ -0,0 +1 @@ +AMR diff --git a/AMR/__init__.py b/AMR/__init__.py new file mode 100644 index 000000000..0dd6e1f18 --- /dev/null +++ b/AMR/__init__.py @@ -0,0 +1,213 @@ +from .datasets import example_isolates +from .datasets import microorganisms +from .datasets import antimicrobials +from .datasets import clinical_breakpoints +from .functions import ab_class +from .functions import ab_selector +from .functions import ab_from_text +from .functions import ab_name +from .functions import ab_cid +from .functions import ab_synonyms +from .functions import ab_tradenames +from .functions import ab_group +from .functions import ab_atc +from .functions import ab_atc_group1 +from .functions import ab_atc_group2 +from .functions import ab_loinc +from .functions import ab_ddd +from .functions import ab_ddd_units +from .functions import ab_info +from .functions import ab_url +from .functions import ab_property +from .functions import add_custom_antimicrobials +from .functions import clear_custom_antimicrobials +from .functions import add_custom_microorganisms +from .functions import clear_custom_microorganisms +from .functions import age +from .functions import age_groups +from .functions import antibiogram +from .functions import wisca +from .functions import retrieve_wisca_parameters +from .functions import aminoglycosides +from .functions import aminopenicillins +from .functions import antifungals +from .functions import antimycobacterials +from .functions import betalactams +from .functions import betalactams_with_inhibitor +from .functions import carbapenems +from .functions import cephalosporins +from .functions import cephalosporins_1st +from .functions import cephalosporins_2nd +from .functions import cephalosporins_3rd +from .functions import cephalosporins_4th +from .functions import cephalosporins_5th +from .functions import fluoroquinolones +from .functions import glycopeptides +from .functions import isoxazolylpenicillins +from .functions import lincosamides +from .functions import lipoglycopeptides +from .functions import macrolides +from .functions import monobactams +from .functions import nitrofurans +from .functions import oxazolidinones +from .functions import penicillins +from .functions import phenicols +from .functions import polymyxins +from .functions import quinolones +from .functions import rifamycins +from .functions import streptogramins +from .functions import sulfonamides +from .functions import tetracyclines +from .functions import trimethoprims +from .functions import ureidopenicillins +from .functions import amr_class +from .functions import amr_selector +from .functions import administrable_per_os +from .functions import administrable_iv +from .functions import not_intrinsic_resistant +from .functions import as_ab +from .functions import is_ab +from .functions import ab_reset_session +from .functions import as_av +from .functions import is_av +from .functions import as_disk +from .functions import is_disk +from .functions import as_mic +from .functions import is_mic +from .functions import rescale_mic +from .functions import mic_p50 +from .functions import mic_p90 +from .functions import as_mo +from .functions import is_mo +from .functions import mo_uncertainties +from .functions import mo_renamed +from .functions import mo_failures +from .functions import mo_reset_session +from .functions import mo_cleaning_regex +from .functions import as_sir +from .functions import is_sir +from .functions import is_sir_eligible +from .functions import sir_interpretation_history +from .functions import atc_online_property +from .functions import atc_online_groups +from .functions import atc_online_ddd +from .functions import atc_online_ddd_units +from .functions import av_from_text +from .functions import av_name +from .functions import av_cid +from .functions import av_synonyms +from .functions import av_tradenames +from .functions import av_group +from .functions import av_atc +from .functions import av_loinc +from .functions import av_ddd +from .functions import av_ddd_units +from .functions import av_info +from .functions import av_url +from .functions import av_property +from .functions import availability +from .functions import bug_drug_combinations +from .functions import count_resistant +from .functions import count_susceptible +from .functions import count_S +from .functions import count_SI +from .functions import count_I +from .functions import count_IR +from .functions import count_R +from .functions import count_all +from .functions import n_sir +from .functions import count_df +from .functions import custom_eucast_rules +from .functions import eucast_rules +from .functions import eucast_dosage +from .functions import export_ncbi_biosample +from .functions import first_isolate +from .functions import filter_first_isolate +from .functions import g_test +from .functions import is_new_episode +from .functions import ggplot_pca +from .functions import ggplot_sir +from .functions import geom_sir +from .functions import guess_ab_col +from .functions import italicise_taxonomy +from .functions import italicize_taxonomy +from .functions import inner_join_microorganisms +from .functions import left_join_microorganisms +from .functions import right_join_microorganisms +from .functions import full_join_microorganisms +from .functions import semi_join_microorganisms +from .functions import anti_join_microorganisms +from .functions import key_antimicrobials +from .functions import all_antimicrobials +from .functions import kurtosis +from .functions import like +from .functions import mdro +from .functions import custom_mdro_guideline +from .functions import brmo +from .functions import mrgn +from .functions import mdr_tb +from .functions import mdr_cmi2012 +from .functions import eucast_exceptional_phenotypes +from .functions import mean_amr_distance +from .functions import amr_distance_from_row +from .functions import mo_matching_score +from .functions import mo_name +from .functions import mo_fullname +from .functions import mo_shortname +from .functions import mo_subspecies +from .functions import mo_species +from .functions import mo_genus +from .functions import mo_family +from .functions import mo_order +from .functions import mo_class +from .functions import mo_phylum +from .functions import mo_kingdom +from .functions import mo_domain +from .functions import mo_type +from .functions import mo_status +from .functions import mo_pathogenicity +from .functions import mo_gramstain +from .functions import mo_is_gram_negative +from .functions import mo_is_gram_positive +from .functions import mo_is_yeast +from .functions import mo_is_intrinsic_resistant +from .functions import mo_oxygen_tolerance +from .functions import mo_is_anaerobic +from .functions import mo_snomed +from .functions import mo_ref +from .functions import mo_authors +from .functions import mo_year +from .functions import mo_lpsn +from .functions import mo_mycobank +from .functions import mo_gbif +from .functions import mo_rank +from .functions import mo_taxonomy +from .functions import mo_synonyms +from .functions import mo_current +from .functions import mo_group_members +from .functions import mo_info +from .functions import mo_url +from .functions import mo_property +from .functions import pca +from .functions import theme_sir +from .functions import labels_sir_count +from .functions import resistance +from .functions import susceptibility +from .functions import sir_confidence_interval +from .functions import proportion_R +from .functions import proportion_IR +from .functions import proportion_I +from .functions import proportion_SI +from .functions import proportion_S +from .functions import proportion_df +from .functions import sir_df +from .functions import random_mic +from .functions import random_disk +from .functions import random_sir +from .functions import resistance_predict +from .functions import sir_predict +from .functions import ggplot_sir_predict +from .functions import skewness +from .functions import top_n_microorganisms +from .functions import reset_AMR_locale +from .functions import translate_AMR diff --git a/AMR/datasets.py b/AMR/datasets.py new file mode 100644 index 000000000..8b1dbb67d --- /dev/null +++ b/AMR/datasets.py @@ -0,0 +1,77 @@ +import os +import sys +import pandas as pd +import importlib.metadata as metadata + +# Get the path to the virtual environment +venv_path = sys.prefix +r_lib_path = os.path.join(venv_path, "R_libs") +os.makedirs(r_lib_path, exist_ok=True) + +# Set environment variable before importing rpy2 +os.environ['R_LIBS_SITE'] = r_lib_path + +from rpy2 import robjects +from rpy2.robjects import pandas2ri +from rpy2.robjects.packages import importr, isinstalled + +# Import base and utils +base = importr('base') +utils = importr('utils') + +base.options(warn=-1) + +# Ensure library paths explicitly +base._libPaths(r_lib_path) + +# Check if the AMR package is installed in R +if not isinstalled('AMR', lib_loc=r_lib_path): + print(f"AMR: Installing latest AMR R package to {r_lib_path}...", flush=True) + utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) + +# # Retrieve Python AMR version +# try: +# python_amr_version = metadata.version('AMR') +# except metadata.PackageNotFoundError: +# python_amr_version = '' +# +# # Retrieve R AMR version +# r_amr_version = robjects.r(f'as.character(packageVersion("AMR", lib.loc = "{r_lib_path}"))') +# r_amr_version = str(r_amr_version[0]) +# +# # Compare R and Python package versions +# if r_amr_version != python_amr_version: +# try: +# print(f"AMR: Updating AMR package in {r_lib_path}...", flush=True) +# utils.install_packages('AMR', repos='beta.amr-for-r.org', quiet=True) +# except Exception as e: +# print(f"AMR: Could not update: {e}", flush=True) + +print(f"AMR: Setting up R environment and AMR datasets...", flush=True) + +# Activate the automatic conversion between R and pandas DataFrames +pandas2ri.activate() + +# example_isolates +example_isolates = pandas2ri.rpy2py(robjects.r(''' +df <- AMR::example_isolates +df[] <- lapply(df, function(x) { + if (inherits(x, c("Date", "POSIXt", "factor"))) { + as.character(x) + } else { + x + } +}) +df <- df[, !sapply(df, is.list)] +df +''')) +example_isolates['date'] = pd.to_datetime(example_isolates['date']) + +# microorganisms +microorganisms = pandas2ri.rpy2py(robjects.r('AMR::microorganisms[, !sapply(AMR::microorganisms, is.list)]')) +antimicrobials = pandas2ri.rpy2py(robjects.r('AMR::antimicrobials[, !sapply(AMR::antimicrobials, is.list)]')) +clinical_breakpoints = pandas2ri.rpy2py(robjects.r('AMR::clinical_breakpoints[, !sapply(AMR::clinical_breakpoints, is.list)]')) + +base.options(warn = 0) + +print(f"AMR: Done.", flush=True) diff --git a/AMR/functions.py b/AMR/functions.py new file mode 100644 index 000000000..e0146c94a --- /dev/null +++ b/AMR/functions.py @@ -0,0 +1,665 @@ +import rpy2.robjects as robjects +from rpy2.robjects.packages import importr +from rpy2.robjects.vectors import StrVector, FactorVector, IntVector, FloatVector, DataFrame +from rpy2.robjects import pandas2ri +import pandas as pd +import numpy as np + +# Activate automatic conversion between R data frames and pandas data frames +pandas2ri.activate() + +# Import the AMR R package +amr_r = importr('AMR') + +def convert_to_python(r_output): + # Check if it's a StrVector (R character vector) + if isinstance(r_output, StrVector): + return list(r_output) # Convert to a Python list of strings + + # Check if it's a FactorVector (R factor) + elif isinstance(r_output, FactorVector): + return list(r_output) # Convert to a list of integers (factor levels) + + # Check if it's an IntVector or FloatVector (numeric R vectors) + elif isinstance(r_output, (IntVector, FloatVector)): + return list(r_output) # Convert to a Python list of integers or floats + + # Check if it's a pandas-compatible R data frame + elif isinstance(r_output, pd.DataFrame): + return r_output # Return as pandas DataFrame (already converted by pandas2ri) + elif isinstance(r_output, DataFrame): + return pandas2ri.rpy2py(r_output) # Return as pandas DataFrame + + # Check if the input is a NumPy array and has a string data type + if isinstance(r_output, np.ndarray) and np.issubdtype(r_output.dtype, np.str_): + return r_output.tolist() # Convert to a regular Python list + + # Fall-back + return r_output +def ab_class(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_class(*args, **kwargs)) +def ab_selector(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_selector(*args, **kwargs)) +def ab_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_from_text(text, *args, **kwargs)) +def ab_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_name(x, *args, **kwargs)) +def ab_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_cid(x, *args, **kwargs)) +def ab_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_synonyms(x, *args, **kwargs)) +def ab_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_tradenames(x, *args, **kwargs)) +def ab_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_group(x, *args, **kwargs)) +def ab_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_atc(x, *args, **kwargs)) +def ab_atc_group1(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_atc_group1(x, *args, **kwargs)) +def ab_atc_group2(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_atc_group2(x, *args, **kwargs)) +def ab_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_loinc(x, *args, **kwargs)) +def ab_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_ddd(x, *args, **kwargs)) +def ab_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_ddd_units(x, *args, **kwargs)) +def ab_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_info(x, *args, **kwargs)) +def ab_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_url(x, *args, **kwargs)) +def ab_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_property(x, *args, **kwargs)) +def add_custom_antimicrobials(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.add_custom_antimicrobials(x)) +def clear_custom_antimicrobials(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.clear_custom_antimicrobials(*args, **kwargs)) +def add_custom_microorganisms(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.add_custom_microorganisms(x)) +def clear_custom_microorganisms(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.clear_custom_microorganisms(*args, **kwargs)) +def age(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.age(x, *args, **kwargs)) +def age_groups(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.age_groups(x, *args, **kwargs)) +def antibiogram(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.antibiogram(x, *args, **kwargs)) +def wisca(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.wisca(x, *args, **kwargs)) +def retrieve_wisca_parameters(wisca_model, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.retrieve_wisca_parameters(wisca_model, *args, **kwargs)) +def aminoglycosides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.aminoglycosides(only_sir_columns = False, *args, **kwargs)) +def aminopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.aminopenicillins(only_sir_columns = False, *args, **kwargs)) +def antifungals(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.antifungals(only_sir_columns = False, *args, **kwargs)) +def antimycobacterials(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.antimycobacterials(only_sir_columns = False, *args, **kwargs)) +def betalactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.betalactams(only_sir_columns = False, *args, **kwargs)) +def betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.betalactams_with_inhibitor(only_sir_columns = False, *args, **kwargs)) +def carbapenems(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.carbapenems(only_sir_columns = False, *args, **kwargs)) +def cephalosporins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_1st(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_1st(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_2nd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_2nd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_3rd(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_3rd(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_4th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_4th(only_sir_columns = False, *args, **kwargs)) +def cephalosporins_5th(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.cephalosporins_5th(only_sir_columns = False, *args, **kwargs)) +def fluoroquinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.fluoroquinolones(only_sir_columns = False, *args, **kwargs)) +def glycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.glycopeptides(only_sir_columns = False, *args, **kwargs)) +def isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.isoxazolylpenicillins(only_sir_columns = False, *args, **kwargs)) +def lincosamides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.lincosamides(only_sir_columns = False, *args, **kwargs)) +def lipoglycopeptides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.lipoglycopeptides(only_sir_columns = False, *args, **kwargs)) +def macrolides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.macrolides(only_sir_columns = False, *args, **kwargs)) +def monobactams(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.monobactams(only_sir_columns = False, *args, **kwargs)) +def nitrofurans(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.nitrofurans(only_sir_columns = False, *args, **kwargs)) +def oxazolidinones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.oxazolidinones(only_sir_columns = False, *args, **kwargs)) +def penicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.penicillins(only_sir_columns = False, *args, **kwargs)) +def phenicols(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.phenicols(only_sir_columns = False, *args, **kwargs)) +def polymyxins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.polymyxins(only_sir_columns = False, *args, **kwargs)) +def quinolones(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.quinolones(only_sir_columns = False, *args, **kwargs)) +def rifamycins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.rifamycins(only_sir_columns = False, *args, **kwargs)) +def streptogramins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.streptogramins(only_sir_columns = False, *args, **kwargs)) +def sulfonamides(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sulfonamides(only_sir_columns = False, *args, **kwargs)) +def tetracyclines(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.tetracyclines(only_sir_columns = False, *args, **kwargs)) +def trimethoprims(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.trimethoprims(only_sir_columns = False, *args, **kwargs)) +def ureidopenicillins(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ureidopenicillins(only_sir_columns = False, *args, **kwargs)) +def amr_class(amr_class, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.amr_class(amr_class, *args, **kwargs)) +def amr_selector(filter, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.amr_selector(filter, *args, **kwargs)) +def administrable_per_os(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.administrable_per_os(only_sir_columns = False, *args, **kwargs)) +def administrable_iv(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.administrable_iv(only_sir_columns = False, *args, **kwargs)) +def not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.not_intrinsic_resistant(only_sir_columns = False, *args, **kwargs)) +def as_ab(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_ab(x, *args, **kwargs)) +def is_ab(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_ab(x)) +def ab_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ab_reset_session(*args, **kwargs)) +def as_av(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_av(x, *args, **kwargs)) +def is_av(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_av(x)) +def as_disk(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_disk(x, *args, **kwargs)) +def is_disk(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_disk(x)) +def as_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_mic(x, *args, **kwargs)) +def is_mic(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_mic(x)) +def rescale_mic(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.rescale_mic(x, *args, **kwargs)) +def mic_p50(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mic_p50(x, *args, **kwargs)) +def mic_p90(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mic_p90(x, *args, **kwargs)) +def as_mo(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_mo(x, *args, **kwargs)) +def is_mo(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_mo(x)) +def mo_uncertainties(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_uncertainties(*args, **kwargs)) +def mo_renamed(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_renamed(*args, **kwargs)) +def mo_failures(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_failures(*args, **kwargs)) +def mo_reset_session(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_reset_session(*args, **kwargs)) +def mo_cleaning_regex(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_cleaning_regex(*args, **kwargs)) +def as_sir(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.as_sir(x, *args, **kwargs)) +def is_sir(x): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_sir(x)) +def is_sir_eligible(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_sir_eligible(x, *args, **kwargs)) +def sir_interpretation_history(clean): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_interpretation_history(clean)) +def atc_online_property(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_property(atc_code, *args, **kwargs)) +def atc_online_groups(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_groups(atc_code, *args, **kwargs)) +def atc_online_ddd(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_ddd(atc_code, *args, **kwargs)) +def atc_online_ddd_units(atc_code, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.atc_online_ddd_units(atc_code, *args, **kwargs)) +def av_from_text(text, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_from_text(text, *args, **kwargs)) +def av_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_name(x, *args, **kwargs)) +def av_cid(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_cid(x, *args, **kwargs)) +def av_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_synonyms(x, *args, **kwargs)) +def av_tradenames(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_tradenames(x, *args, **kwargs)) +def av_group(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_group(x, *args, **kwargs)) +def av_atc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_atc(x, *args, **kwargs)) +def av_loinc(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_loinc(x, *args, **kwargs)) +def av_ddd(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_ddd(x, *args, **kwargs)) +def av_ddd_units(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_ddd_units(x, *args, **kwargs)) +def av_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_info(x, *args, **kwargs)) +def av_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_url(x, *args, **kwargs)) +def av_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.av_property(x, *args, **kwargs)) +def availability(tbl, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.availability(tbl, *args, **kwargs)) +def bug_drug_combinations(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.bug_drug_combinations(x, *args, **kwargs)) +def count_resistant(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_resistant(*args, **kwargs)) +def count_susceptible(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_susceptible(*args, **kwargs)) +def count_S(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_S(*args, **kwargs)) +def count_SI(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_SI(*args, **kwargs)) +def count_I(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_I(*args, **kwargs)) +def count_IR(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_IR(*args, **kwargs)) +def count_R(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_R(*args, **kwargs)) +def count_all(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_all(*args, **kwargs)) +def n_sir(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.n_sir(*args, **kwargs)) +def count_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.count_df(data, *args, **kwargs)) +def custom_eucast_rules(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.custom_eucast_rules(*args, **kwargs)) +def eucast_rules(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.eucast_rules(x, *args, **kwargs)) +def eucast_dosage(ab, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.eucast_dosage(ab, *args, **kwargs)) +def export_ncbi_biosample(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.export_ncbi_biosample(x, *args, **kwargs)) +def first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.first_isolate(x = None, *args, **kwargs)) +def filter_first_isolate(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.filter_first_isolate(x = None, *args, **kwargs)) +def g_test(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.g_test(x, *args, **kwargs)) +def is_new_episode(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.is_new_episode(x, *args, **kwargs)) +def ggplot_pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ggplot_pca(x, *args, **kwargs)) +def ggplot_sir(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ggplot_sir(data, *args, **kwargs)) +def geom_sir(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.geom_sir(position = None, *args, **kwargs)) +def guess_ab_col(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.guess_ab_col(x = None, *args, **kwargs)) +def italicise_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.italicise_taxonomy(string, *args, **kwargs)) +def italicize_taxonomy(string, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.italicize_taxonomy(string, *args, **kwargs)) +def inner_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.inner_join_microorganisms(x, *args, **kwargs)) +def left_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.left_join_microorganisms(x, *args, **kwargs)) +def right_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.right_join_microorganisms(x, *args, **kwargs)) +def full_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.full_join_microorganisms(x, *args, **kwargs)) +def semi_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.semi_join_microorganisms(x, *args, **kwargs)) +def anti_join_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.anti_join_microorganisms(x, *args, **kwargs)) +def key_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.key_antimicrobials(x = None, *args, **kwargs)) +def all_antimicrobials(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.all_antimicrobials(x = None, *args, **kwargs)) +def kurtosis(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.kurtosis(x, *args, **kwargs)) +def like(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.like(x, *args, **kwargs)) +def mdro(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mdro(x = None, *args, **kwargs)) +def custom_mdro_guideline(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.custom_mdro_guideline(*args, **kwargs)) +def brmo(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.brmo(x = None, *args, **kwargs)) +def mrgn(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mrgn(x = None, *args, **kwargs)) +def mdr_tb(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mdr_tb(x = None, *args, **kwargs)) +def mdr_cmi2012(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mdr_cmi2012(x = None, *args, **kwargs)) +def eucast_exceptional_phenotypes(x = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.eucast_exceptional_phenotypes(x = None, *args, **kwargs)) +def mean_amr_distance(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mean_amr_distance(x, *args, **kwargs)) +def amr_distance_from_row(amr_distance, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.amr_distance_from_row(amr_distance, *args, **kwargs)) +def mo_matching_score(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_matching_score(x, *args, **kwargs)) +def mo_name(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_name(x, *args, **kwargs)) +def mo_fullname(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_fullname(x, *args, **kwargs)) +def mo_shortname(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_shortname(x, *args, **kwargs)) +def mo_subspecies(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_subspecies(x, *args, **kwargs)) +def mo_species(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_species(x, *args, **kwargs)) +def mo_genus(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_genus(x, *args, **kwargs)) +def mo_family(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_family(x, *args, **kwargs)) +def mo_order(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_order(x, *args, **kwargs)) +def mo_class(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_class(x, *args, **kwargs)) +def mo_phylum(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_phylum(x, *args, **kwargs)) +def mo_kingdom(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_kingdom(x, *args, **kwargs)) +def mo_domain(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_domain(x, *args, **kwargs)) +def mo_type(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_type(x, *args, **kwargs)) +def mo_status(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_status(x, *args, **kwargs)) +def mo_pathogenicity(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_pathogenicity(x, *args, **kwargs)) +def mo_gramstain(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_gramstain(x, *args, **kwargs)) +def mo_is_gram_negative(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_gram_negative(x, *args, **kwargs)) +def mo_is_gram_positive(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_gram_positive(x, *args, **kwargs)) +def mo_is_yeast(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_yeast(x, *args, **kwargs)) +def mo_is_intrinsic_resistant(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_intrinsic_resistant(x, *args, **kwargs)) +def mo_oxygen_tolerance(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_oxygen_tolerance(x, *args, **kwargs)) +def mo_is_anaerobic(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_is_anaerobic(x, *args, **kwargs)) +def mo_snomed(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_snomed(x, *args, **kwargs)) +def mo_ref(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_ref(x, *args, **kwargs)) +def mo_authors(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_authors(x, *args, **kwargs)) +def mo_year(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_year(x, *args, **kwargs)) +def mo_lpsn(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_lpsn(x, *args, **kwargs)) +def mo_mycobank(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_mycobank(x, *args, **kwargs)) +def mo_gbif(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_gbif(x, *args, **kwargs)) +def mo_rank(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_rank(x, *args, **kwargs)) +def mo_taxonomy(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_taxonomy(x, *args, **kwargs)) +def mo_synonyms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_synonyms(x, *args, **kwargs)) +def mo_current(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_current(x, *args, **kwargs)) +def mo_group_members(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_group_members(x, *args, **kwargs)) +def mo_info(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_info(x, *args, **kwargs)) +def mo_url(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_url(x, *args, **kwargs)) +def mo_property(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.mo_property(x, *args, **kwargs)) +def pca(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.pca(x, *args, **kwargs)) +def theme_sir(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.theme_sir(*args, **kwargs)) +def labels_sir_count(position = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.labels_sir_count(position = None, *args, **kwargs)) +def resistance(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.resistance(*args, **kwargs)) +def susceptibility(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.susceptibility(*args, **kwargs)) +def sir_confidence_interval(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_confidence_interval(*args, **kwargs)) +def proportion_R(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_R(*args, **kwargs)) +def proportion_IR(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_IR(*args, **kwargs)) +def proportion_I(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_I(*args, **kwargs)) +def proportion_SI(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_SI(*args, **kwargs)) +def proportion_S(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_S(*args, **kwargs)) +def proportion_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.proportion_df(data, *args, **kwargs)) +def sir_df(data, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_df(data, *args, **kwargs)) +def random_mic(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.random_mic(size = None, *args, **kwargs)) +def random_disk(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.random_disk(size = None, *args, **kwargs)) +def random_sir(size = None, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.random_sir(size = None, *args, **kwargs)) +def resistance_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.resistance_predict(x, *args, **kwargs)) +def sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.sir_predict(x, *args, **kwargs)) +def ggplot_sir_predict(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.ggplot_sir_predict(x, *args, **kwargs)) +def skewness(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.skewness(x, *args, **kwargs)) +def top_n_microorganisms(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.top_n_microorganisms(x, *args, **kwargs)) +def reset_AMR_locale(*args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.reset_AMR_locale(*args, **kwargs)) +def translate_AMR(x, *args, **kwargs): + """See our website of the R package for the manual: https://amr-for-r.org/index.html""" + return convert_to_python(amr_r.translate_AMR(x, *args, **kwargs)) diff --git a/README.md b/README.md new file mode 100755 index 000000000..43aa015bd --- /dev/null +++ b/README.md @@ -0,0 +1,184 @@ + +The `AMR` package for R is a powerful tool for antimicrobial resistance (AMR) analysis. It provides extensive features for handling microbial and antimicrobial data. However, for those who work primarily in Python, we now have a more intuitive option available: the [`AMR` Python package](https://pypi.org/project/AMR/). + +This Python package is a wrapper around the `AMR` R package. It uses the `rpy2` package internally. Despite the need to have R installed, Python users can now easily work with AMR data directly through Python code. + +# Prerequisites + +This package was only tested with a [virtual environment (venv)](https://docs.python.org/3/library/venv.html). You can set up such an environment by running: + +```python +# linux and macOS: +python -m venv /path/to/new/virtual/environment + +# Windows: +python -m venv C:\path\to\new\virtual\environment +``` + +Then you can [activate the environment](https://docs.python.org/3/library/venv.html#how-venvs-work), after which the venv is ready to work with. + +# Install AMR + +1. Since the Python package is available on the official [Python Package Index](https://pypi.org/project/AMR/), you can just run: + + ```bash + pip install AMR + ``` + +2. Make sure you have R installed. There is **no need to install the `AMR` R package**, as it will be installed automatically. + + For Linux: + + ```bash + # Ubuntu / Debian + sudo apt install r-base + # Fedora: + sudo dnf install R + # CentOS/RHEL + sudo yum install R + ``` + + For macOS (using [Homebrew](https://brew.sh)): + + ```bash + brew install r + ``` + + For Windows, visit the [CRAN download page](https://cran.r-project.org) to download and install R. + +# Examples of Usage + +## Cleaning Taxonomy + +Here’s an example that demonstrates how to clean microorganism and drug names using the `AMR` Python package: + +```python +import pandas as pd +import AMR + +# Sample data +data = { + "MOs": ['E. coli', 'ESCCOL', 'esco', 'Esche coli'], + "Drug": ['Cipro', 'CIP', 'J01MA02', 'Ciproxin'] +} +df = pd.DataFrame(data) + +# Use AMR functions to clean microorganism and drug names +df['MO_clean'] = AMR.mo_name(df['MOs']) +df['Drug_clean'] = AMR.ab_name(df['Drug']) + +# Display the results +print(df) +``` + +| MOs | Drug | MO_clean | Drug_clean | +|-------------|-----------|--------------------|---------------| +| E. coli | Cipro | Escherichia coli | Ciprofloxacin | +| ESCCOL | CIP | Escherichia coli | Ciprofloxacin | +| esco | J01MA02 | Escherichia coli | Ciprofloxacin | +| Esche coli | Ciproxin | Escherichia coli | Ciprofloxacin | + +### Explanation + +* **mo_name:** This function standardises microorganism names. Here, different variations of *Escherichia coli* (such as "E. coli", "ESCCOL", "esco", and "Esche coli") are all converted into the correct, standardised form, "Escherichia coli". + +* **ab_name**: Similarly, this function standardises antimicrobial names. The different representations of ciprofloxacin (e.g., "Cipro", "CIP", "J01MA02", and "Ciproxin") are all converted to the standard name, "Ciprofloxacin". + +## Calculating AMR + +```python +import AMR +import pandas as pd + +df = AMR.example_isolates +result = AMR.resistance(df["AMX"]) +print(result) +``` + +``` +[0.59555556] +``` + +## Generating Antibiograms + +One of the core functions of the `AMR` package is generating an antibiogram, a table that summarises the antimicrobial susceptibility of bacterial isolates. Here’s how you can generate an antibiogram from Python: + +```python +result2a = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]]) +print(result2a) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|-----------------|-----------------|-----------------|--------------------------| +| CoNS | 7% (10/142) | 73% (183/252) | 30% (10/33) | +| E. coli | 50% (196/392) | 88% (399/456) | 94% (393/416) | +| K. pneumoniae | 0% (0/58) | 96% (53/55) | 89% (47/53) | +| P. aeruginosa | 0% (0/30) | 100% (30/30) | None | +| P. mirabilis | None | 94% (34/36) | None | +| S. aureus | 6% (8/131) | 90% (171/191) | None | +| S. epidermidis | 1% (1/91) | 64% (87/136) | None | +| S. hominis | None | 80% (56/70) | None | +| S. pneumoniae | 100% (112/112) | None | 100% (112/112) | + + +```python +result2b = AMR.antibiogram(df[["mo", "AMX", "CIP", "TZP"]], mo_transform = "gramstain") +print(result2b) +``` + +| Pathogen | Amoxicillin | Ciprofloxacin | Piperacillin/tazobactam | +|----------------|-----------------|------------------|--------------------------| +| Gram-negative | 36% (226/631) | 91% (621/684) | 88% (565/641) | +| Gram-positive | 43% (305/703) | 77% (560/724) | 86% (296/345) | + + +In this example, we generate an antibiogram by selecting various antibiotics. + +## Taxonomic Data Sets Now in Python! + +As a Python user, you might like that the most important data sets of the `AMR` R package, `microorganisms`, `antimicrobials`, `clinical_breakpoints`, and `example_isolates`, are now available as regular Python data frames: + +```python +AMR.microorganisms +``` + +| mo | fullname | status | kingdom | gbif | gbif_parent | gbif_renamed_to | prevalence | +|--------------|------------------------------------|----------|----------|-----------|-------------|-----------------|------------| +| B_GRAMN | (unknown Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_GRAMP | (unknown Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-NEG | (unknown anaerobic Gram-negatives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER-POS | (unknown anaerobic Gram-positives) | unknown | Bacteria | None | None | None | 2.0 | +| B_ANAER | (unknown anaerobic bacteria) | unknown | Bacteria | None | None | None | 2.0 | +| ... | ... | ... | ... | ... | ... | ... | ... | +| B_ZYMMN_POMC | Zymomonas pomaceae | accepted | Bacteria | 10744418 | 3221412 | None | 2.0 | +| B_ZYMPH | Zymophilus | synonym | Bacteria | None | 9475166 | None | 2.0 | +| B_ZYMPH_PCVR | Zymophilus paucivorans | synonym | Bacteria | None | None | None | 2.0 | +| B_ZYMPH_RFFN | Zymophilus raffinosivorans | synonym | Bacteria | None | None | None | 2.0 | +| F_ZYZYG | Zyzygomyces | unknown | Fungi | None | 7581 | None | 2.0 | + +```python +AMR.antimicrobials +``` + +| ab | cid | name | group | oral_ddd | oral_units | iv_ddd | iv_units | +|-----|-------------|----------------------|----------------------------|----------|------------|--------|----------| +| AMA | 4649.0 | 4-aminosalicylic acid| Antimycobacterials | 12.00 | g | NaN | None | +| ACM | 6450012.0 | Acetylmidecamycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ASP | 49787020.0 | Acetylspiramycin | Macrolides/lincosamides | NaN | None | NaN | None | +| ALS | 8954.0 | Aldesulfone sodium | Other antibacterials | 0.33 | g | NaN | None | +| AMK | 37768.0 | Amikacin | Aminoglycosides | NaN | None | 1.0 | g | +| ... | ... | ... | ... | ... | ... | ... | ... | +| VIR | 11979535.0 | Virginiamycine | Other antibacterials | NaN | None | NaN | None | +| VOR | 71616.0 | Voriconazole | Antifungals/antimycotics | 0.40 | g | 0.4 | g | +| XBR | 72144.0 | Xibornol | Other antibacterials | NaN | None | NaN | None | +| ZID | 77846445.0 | Zidebactam | Other antibacterials | NaN | None | NaN | None | +| ZFD | NaN | Zoliflodacin | None | NaN | None | NaN | None | + + +# Conclusion + +With the `AMR` Python package, Python users can now effortlessly call R functions from the `AMR` R package. This eliminates the need for complex `rpy2` configurations and provides a clean, easy-to-use interface for antimicrobial resistance analysis. The examples provided above demonstrate how this can be applied to typical workflows, such as standardising microorganism and antimicrobial names or calculating resistance. + +By just running `import AMR`, users can seamlessly integrate the robust features of the R `AMR` package into Python workflows. + +Whether you're cleaning data or analysing resistance patterns, the `AMR` Python package makes it easy to work with AMR data in Python. diff --git a/dist/amr-2.1.1.9247-py3-none-any.whl b/dist/amr-2.1.1.9247-py3-none-any.whl new file mode 100644 index 0000000000000000000000000000000000000000..661f33df2da68e594105a7cfd6ebdbb7ef36f9a7 GIT binary patch literal 10186 zcmaKS1CVCRn(be<-DTVEvhBZY+wQWuY}>ZgWp&whmu;h`&z(1M=AL+ScSgp}of&Jz z7m<4>I9|=v|_bbLoT}4Q}u?0jp>|zaM#m#s3_|lm*iI92TnzdL10swHcHkFw1 z&Rhv?+kCC9n*^hpt7Eg&{ZWVTEj1beIe}pMbEhcJmVj}R0GqNOU{Ec3pxn~|*$-wv zO=_u~%JlQ+zvvubZ&Bby-L+Ue3g_rVYX-1Imb+BKQmlkD>0Xyz>=GEYF|Kh~w~#iA zvCU-dWuSLf%eNA+dUJujmihAr7F4svWN;d=TN|)f;FXl6EuUjpk1;FNxT6Fjv^4`o zKSFU{dO)TUC#MlSHTFW)MfCSJka@t`wq{y^Ro>(?ilLYuMKz;?5VaD>f5Q(ek{31d=Yp zDc^%a(IgM8@@ixSC*`ShXb{46Q%QVan)0L9EBb`KV-I>g5-Wr_MG#3$+- z$Na8>ZjKd_|IVk2T3lfY|8;)SH~jNbp$Nf7Qjjd2CI1Lrq56l0j!G?w(aOAn6dkZ1 zuasTebAIH-Be)aYJe$j>gH1MxQ8*Ac^-V6lfUs#Iaj044kcxev(d%MXu`<_aMnqL9 zq^gs1D$k##kWJU9zZ6=F^~R&(nyy{sE8w^x28Gi6xeswi?O2V1rg|S`JTpzQzJO}c z?P(=l7Q$E&bjUKYKFGTiom7j?tTaL;1vIE7uuXd@3Y*)hoyM4*RlG2OCJ2KT5%N;% z3phn0f0z1XPxxUAcl=tNnGT6XB3ONW7>hMK)UG8^neIeTHib`FFLz%wD!_Vz+#!wG zpd{1jvj3OQ4w{-sj`=V?G8`n61Hu8glTqfVjsuiYN;=Vs9elONz0@9VlStK;{}-fB z$i>}(b(rvm6I4?b^0B2%Hihd)NkfEjNc!bt5#Bj8XCcy~M=xGq zo=C)>_P6*bcX=zH+yjpH;mhrUzvaUxj(2`YZXc)6JN&2gQ{y!L$}{)A>m++Y&gic* z8nZnXvw9CdA8wGr30gLhvuY!hDcH%e#tFA!n~I;2nTz!AHy=TyhA&!C{)l)D;?uqK#n4{_wDlhuFCfnz&joKECz}fn0>6FRI5o2E7f9 z*(|TP1$2X~P>RZ(wq` z%}cBuzrA-un2IRu<@haxYS#~rwjoN~%?PyV!i~s2tCMFnSr2q{vtrmpetz|X@AyeT zK%}IVlf`lBF=;bcYT)ypQSsk~VRmQnr5-QFCPzJR-+p6NtHZzHXB~%ah2GHNjD&L6fu}>*{UMmG_aqSok3(PHZl^&gqDcmFn@) zH&)t^vQ@Yo&RCkYeOcJa2$u1GeOV~=GUHl@&cmfj4oJaCja@k2!_94b=#E`l&8>WL zU)?;Nm%I0`dle2&5?3WIkQ0nv^A6Zp-AZuNb|E{*9bkMW+VvhG*xldYoyc+;FLsrM zrsB<2HQr)^L%*9{b2OCl&~+1X+}|z?2H$fKu*o9^FOue|DT?l4CQVhZ4btPBTcUzv zVV}Sg;h`U^fS7Ja8=;tib3CI5yAip6z`VsjFtzyI*|XGC971;-4q0=Yk(UUxlVprx zBFT7LOILhxit`ep`fS>r8#;jB#B^Bt4ds5inys`I5C;2ldU%MVlNfgAY3r zws13j50o%Ktj;`*$@*d?|B|ZsLJf?#51DH}Pxs1U-Tz&?J+>lcD4Kcfoy`?J-xc1G zPsp5txU`(j5r;YRP}@x7vUjjr^mhxD53O0gF|`{!skz9cxfCju?7TMK(CpSnWoQwY zXEn`a)X4EjCq|>S)tUV)+L3wI)6gyGZ~63qPxHik&B8k07;!LKKW2WPhTrC48Q!+7 z_Wc8m{nnViVeeXt1<)g9k9Y<`xjUYLiBTliU*Un)(V$3IVvH?ESLPF-EuT?LfgY(m z-6LOjJsQ`_VME3(YfP5Gi(U`}TQ;o)$O)N_BnD{e_FbS#swOc)CmaltG2}dV!uLdkbNg-mNim$; zAqKLek(@I|Sc4JE2F@RII~V%wa+854KKbY!Z)(LL%}G z??Wz#9W!Cy{mGGz1>=+xvQ8WbU&KSN;u(}nS$>~-K-|Rg26bahNB8F&C#;Vp+?>@m zAtc0zK=v|fK*{n#QK00xuQ*Wn)~<1xXxZ9i1IKSNdz~p7qCr~bp9O;7x-wEhOOqL2 zWKVPbwCi6hPlVp{$Yd2(-2YwcWg0jcjc@>fdMyBe{Qs6*X0CR|E|&Ioe~EoDTPQY* z3v=Y^gIe)0?v(08_M1B*E_JAdc)U~EY#HeV29ASL4hM&I<|#$4Z*CtpjVg8o|2}s_ zM<Sw~lo3d>vQp*W=|<-j(l7kTA;?Uhx6KtjT4@B`&j&q8sL z#4~lW!pmgYZ#Ri83jMGTKJQnWsNaDyzXaZe;9m+P#TZTaO|;OIkbP=bCPzUk3mCo| z7nGka5uiRyPBM-jZPbx6vk^zfV=&VxI8ny{Eh)qjlxkQbqzbF2Ps&=tY@*nKXmJ#T=9 z_JFT5f9SAo3X+??B&W8*>eJDAX`K4SN#RK5dFtns_>`^4Y{RaooUMr!fg18aPH=*%OByUuC`rny46>w>gJ7PQgH0)t0l*kZ6& z)-cskO!-*KG^-05>=XT--bPMU*Q^#Q_j)@}gRr2%N5Yr0aP5-EAr7P9TFx0Ech6!0 zEedHunFXcM29VX92%z6^WY5XfAe?Oox|Q%~-{3POYLlyW7cgo4!luIkZ)3Q&2Itbj zh8W|?6WF^3_R#3yJKx^3R0_=I@+#x34W_M1W#CfD15aSJFS7b{%d!dQc51RAG}L*> z=R7w|8IU%Sq~hE>g?K4JGUSI%$|XZoMAB-pZU$ZC6@N`9JnT5M7~Mzg zHN=^aRj*selwLOsyM1Y(c(3D3n~ec(OQP%<*sk)jve@APXQDo8j_(YG-i`X4KApdp zlBf<~dG=4quRINI=j&@E#I?P1SR0_Gutx*XBc}VO@d={tC>nU{hY*$8j_x?=px3(< zd1WTSUM*+i+*!TTWm9s%`oiEjPMW>d1r*eWcR-zpHmtzbJh0y<5M5@`YV?EgX6zwp zPvGU)%q+_`pzh#yG)Y{uUFkCEi%NJCk8jIb<2cuIx$5>CSm?W*-m0RdCutks3?>GvM58sl# z4CeG^6!Rv%jNa(75Q!%7%nWLbm3dHepwzC95Vm7~kCAy4zt(drq@p$Qv3W&(-p#Lf z(pG-ghjy(gz=L@4q463?{#H$*eBa#t1g!|1#-L!f69dP#@t}`s-D~V z(#eelZ&sFS=Fn86Z)RaF4%DW~IJo7hB;@NvvCD95^j~y;zGQ)g>3=~;7DC`6wdIW3 z)4phzZYJ5BoTjshaZr-RTH*a< zeS#&alca>f;0RSeK3Qb2Uf3yzBo-CI;JLShRsFJ_hHtWdJsEB=} za+PQ_1@B`}ORO~b4&XD~lQ*9Pau*V1`;^BtElF|m={7K;E*(LN8uGJ%2;8V((IkAm zqWTqX%Q!33sST3HbesF-=#TubZLG@#P;I*CMph18*nQ~7VXocB|8@F11rJKRXeFO8zc>vEv#S9$2I2X z7#?|W^9T$X|MZUNz2m7xA{v6O#sD*atTx!{IJZ=w<8dRn2T5Vv+VBo3jvg_HDCNOw zw>LS4=kQ$As?RX{+>vCZlx`7NiJ-uI!aCNu3> zL8iMi;cO%IV^53Nf$ORVZYTm~3M~oq?I0ptk#M8<@D>ff$WrV5DVVBSxw@Fc3 zzb}TPfxcGyk)fII)-aECeqRa+&i6u#?zT1vy*M}^Ch$?8?LaXY@ML?f32?3KwHPXh zcSktKcH{iwx!n7BOJM2shzRvV_f@s2=Ce0v55)tcy0T9k2fJ;T?I-dE^7T2&QI$2~ zMD-m*(x8nboHr#Wt?gQqjfT)g2VYYwEf&+Jh_-5eO)3PxxlRRoni$>n3uZzFd~+0e zzmlY0{hPkPhOv5Ml&6zG7Qg#+aWN5ZGfHofPdel2rz34!rIfU&6)R1e*EaKTj5)>u z_J@h&BBO%ZttBU4gyJ@)MNfML35CE)w#?U5Sj&&<{QJO}8VsbmXl+EpmM~4hu<6Jd zsB(BS453~n@x+siL->=RHL-prXeSI>vLqmz1;j+ZoExfo)Sgc8m!dn+A{wfx>`LOc zQA8u$H+bsLKeJvf61}}cHzW4|iNVuW9iDB$-jX_u%afhmJ^q-&4$-|u9BJ+FYC zGUOv5PzGj>TnWxw1tm3*>sNA9f*T$Mf9noE5vx4L*1FIcS8202c>d!J$`oH7E%rzZ zP!jhJx;)CWLkd{Pr}m1&7AyZnvUVoM=&!h*xtivCxjB%gt)tz3u#9kQm0oN;&^m~t z>+ax&M&pRAe>++cpAKrfKUx`H-L88?D)&d;UhyD9`BS zFw8j$cY>LmlLn%twl>zW_5H&u*~e5IX+*>MO0Rfi)#w20k#8n3lGvC}&h4RjyhV8d z^BGsy8Vb@-+67_Gl3K6rJLl>B_vS`Ac+Um^D34~5Ge&)8@JPMn3Xq&G8%}FfUUQ<0 zmLILzod$gpTiuvLVO}Fv*PUYClf#i0qa!~jOjNYnEqvP-GH^5v|CTL#e4E`XU4V{& zP3)&BlUaUYw$bW#<4h*ElHwZ?ABrWDr`K(Os}*JVtFDLT-TX-?vse1$$_V&vSka9x zu}--wh06uej@EcNdK}b(84QvL&g2Rd!6ZxBz_773K*yE#d4vf{0p`snUj+qq_y)&| z@P!1D5T&?TL%>N1hwF{>FWrisnC6u=zoU1ME~iGozjX|{pw_QB8T0`rj4k<8SSq zxo0qK-GNF-=&}P98Ea}h0RsoMG7L$K!{69=r5wk+ zz5`{H4Njv1Xh3jHm7Et>7QPR1Y<;~KPq~62XunqK<)Tx&}RY!*A3c)#w^FJ z1E@?1Cqwhfv8E@Wk3IX}SU<-rfJP8%?DBGoptOXrcVDa|g<;jZ09l;jpwe8*cua&= zDmrLdbL4z-%HY2h%g8X^ZKqMs*M)jY257y4+(v*u!eb(e?2oWuK+>av4gza%@i6+p zgoxh1V}OFAP4W`pph4G+ats4GC9PEgepXCKSa?w96gx|DWv)Nu+(O)c3z)#92xQYZ z6IP<#L|B#;YtkSJ|Hxu9KU!vyVttkqZBteXBQob%ZmUc!xlb<5<|T_3>$D@Hg!wf~ zE^40hU1-y=r+k7cAHoKm)P#>Ij3$^8F2zJC82ihzRcdOgSXz(ZlIUu6cuAbsi20t@ zXE3{nI9(dxihUeJ7cZ4MAmnrfcR>YQ>N^K!T5U475!LV-GQOo&PxsQq%`JD-6CCMWKDvrnFN zX`iarJm<2?mvj9HAU5-0z8q9mUy}(A_B{i5(uof^oluV&IZ=)%3dbnWxDkJ* z+1*2(k1dgzmc?4ws-9<8BNIpfw5T0UOScXpn^bPaVBAq)6^8s_*}@1N-j zDK}mV_GbjUTz>|Cz85a?Z`ixS2NP_LS-fdqY_t2pmegPU0Da?3TN*@!QKmfMKk=r? zHj9_=Q4*LGCGza{@$fceYV8T&4dcr12!nUMQ?&Q1#N|zJM@UqVmi;DM76+NAfp;Ck z%m*1lC+UiS&o3RIF%5Ty4`yoS=N_fDZcU49YzEMx&Kl#dhUHj=5N`-y^`B9h)2-S-renfz| z1+zL6B{{;CMhAhzJIq8hwb$V!Bl9!R$To8VCgha%Z`o?G!34C1rIJlSac}3_xQ2hCAYd<~76 z9>Ju8NDoamAdHB&k>lsUmJ5TGyqhS^b0qtvO-5PWu~;%e5^mXmtu1|O9P@OmFdB); zJc}~FFZb$ei`g$k{iPMOi8ffLBz7|aQ8G{LWRoVXrxaqTI5erwH@s1~7s3eO_noJT z%R{R-bje~w!m`4~WGy6^?|!B{7b)wPuBVuD6X~`t6D%xCeV*5Gq2f@WjD`qNM$otRsOz)fAOKF? zH+{Fqx;R0LI9=W{i+CNe|4j8P${DqB=Pl9+7npq=GCTM@%JBx7z7V5|6j}YM_TsHp zj~kc0(l1n_tdim3eDgA(MF%f}44;dftePX5#O=iEl+)9X zkRn0DOn8>3mKr^#(k5f&B0$={{e0=`B;o4`>Fc7V-}2-haAFzpX^zf=B2x1CODFIf zLakwyC}LxI^KMXHT_g;$Bu`L2?lacgGTI_6YFb(eT{WYn`~`WLiFk;UuPHp|bW&fs zf%M-#*b|!9-lz!SBlIi~D+p*F6CvhFdbxyc!%B#gEhGK2%cppp>!A_|3RiQo!-1p? zc4Gr|JquQEE_lsOUz4teM7T3c>EhJISPKy`Y0f9_I1uGuxZ^1jlI7bsggIACO;hGm z{ec~M0Ulu>Yts4#>Z7$rAxxxPa#X2jDj7WWSl*f5?OsekLJvKRN4A!}g-WP}WYcv7wijB#o=ATfVnU@d zMpBn3_g5U)s5qW+RWI(3g>bFX1@}q;5kG^S+iSnij zm8^;gpjV0&6^K2D@rZXB_V8izs)R)*22Gc$5*y`s-fGPf-PjQ4;HR}Cm)dXPsfI{C zyGZX{br1;%hH)bQ8n?HXaeuE*D|grphx$+&jp5W}OFXM$;=O-bQ@}K;9#PG#x^VOs zKI1*9Ra{-!pQ%7i9zq&L41&b!zFHrrOGpE`O#8u**G6R^rt+qT_6`2s!kyM$4JGgF zbC*BbBxvhr28_ELK?c4OQ5VD~F>|q>c?{SNee;H2Eu;*tnH>g)W^*5kfR=OA?l%Vu z4(t!L%Ir5NCWWF%z#Gc0V_iMkHF2mH=r^!aqt6>6RSUh)8fAUw_aL2VdCAUM2m6)N zrm*UR3S*nq6xrV~M zfVTPiDugs|5+F!?*a17ztSI9=$x=F+1Y7Kwb3B_2;UR@HMpy02S3D zd7Vqj^b8JfNg^$-`kZR(t|n@i$}_vO54T9tr#D=WD&FHm(O{N)YbRx z*f`(>ou^080-r9;d~2XODStUv@)-OQW*GpL9q`#Y+&f@Jj8n*K}`6=M# zOfVs9A=h6R52}F+OMkG*kiB+#m+jlA#LKw7I!*0Qj;u@8hW;^_Z`ACM*Nj-> zoWBl>4^2JuV!9ko2TE+kP80?2&G?3i!?FYzXR? z-(YL=gYV60@w_g&FItz@D9A!uzw~%G2xVB3}#yzRMOXS^oaV7ZmT?{sW%FvV2y?KN*x+Y5Yd)KYgss;3L43KD)Donnk$r^-NM8^g%Q z+uF23=2V5%$$Xd;hT!CHnD7fwW=)0a{ z7P!FCI3O)YgG3DC%rpE(?}E{CmcnobU=3k{z>;w8U9TtO!^<_{w2zPa{W^}e{-$< sC$4`J(my%>DWd=3YziPF`w#K`x1$LCu}q*m*d({|#XtK0yu-b2pgFz`t($0*lw+ z+VcKSo|B8|wOwo=&w#U>X@=YN>4YiO#;)uPm}%bZQs--%rHR( z1O}T?s%H2ji#Xe`K4(7CE$TH}?~OcYXEF8;uYKe0I+1YagvMhVhyvrzy?guo$-l?u z;Lkcf`FG+47)t2Hx#*kao=oNthu{963PDlf)8viv^6;f?gZ*qV$UXKM!q~ePHbnRw zdn}K01v*xO3%N}E@)^?Q?WTEl--By>9*X4kcOLpTkeRWh`~oU@(a8gE>o>Xu;Q0Yf z{9*(Oc7m>61gn9dz$HkZkN?&y?R)T-zv5R(&F@hAi(shL76iNbJs9urj%f=t+)FP9 z0$hivF=jf*rYV3-gL)ysJmk7-(Cv2QckzDj=g;AB+wu=SB8sDmNP*R118n-1h?i1(-%+vyV#R)r#x`hD-sWOY}AbsL2*vQ_W2K=MmuOW4jn@U@cAtfS{zZ z&Q6rS60pfQRInPc2#=y(T&vUFr?6GNVW=+QdI||4kGt>I&C2lUZY@xf#{p{q*3O*B3SC=>ZHY;(}ct;$Sg{oTYlcC}w zd4rf_FwTe@2ve|Ou%Zs>MP!)0Qwf4kYqIWkYBFd>4>X%`@$NJy1U+#)(74xpJ>jO_ zj)Ww!x8+^I?1D75MxDV~>yeZ3E)- zjck2j({Lt@(LER?T^!^Gjf5&oV#|x>FghHJ)VOV&$rZnvjx_@C;5fMqs6Blc7O2wy zwke5t(Ia?MyDz0_NU-?4;=ySXXQ%f=GtdUgad75*o5?1uLb?5jCmQqXSrw8&3 z>e=N3xnLiEDalnM*GE`IhY%S(nWKuT(awDft)XM^)B^A{e~VI{=NgoUuML@@FXfB+ zhGK<@$n)d0_%gb&OrcDCOT++Ojh$prBFKA-I-a%)mA(GU2y8@6iZ(V)U6#;vHcw@{ z734G0{BOu-uQ*bu$sUqy+q5|kC-NTLH>U4w-Z~8UIQ+U|_xGjWI07ke@lI~3e3xs^X^Tid5J3l;tl(*ZL)yKc(BEqXq}?V+u+fbz!zfW;GH>#+~ebqY5r+8MMteoQ*gK+!S3-5w+EsGgf5=< zJv1br_bs*vt2INaMMMoup})@`AK!rGLW_VIb2?AT%=JoaEG$e^@OjQ@%R#b}3J5En zxe6__{5Ww`@IYjg!ZK`tv7HngV2-Gv>@;XBbZ?Bj1wjPw;<9w~N4E}CW*cB9n!#n1 zuYPXFuyM-mwf`nao)Yfx3k};4v(WW~qFq{YZQA8C?FFnTFxK1q))J?QaIX{AIPy3R z5tA*TL$S>92vOM;N%9ja*qVx!aG44V$RutY)9anM~!=glT^c!wvPa%~eY ztlj9)_Ry5j29Le_x~)ek8oqVE4piX`5V}h82<#>p3xSzi0YI+?dcM>1MCxEb5+-jkbq-Z7wT3%Q{+%0`D!uIh((^^a{`Zn zN%m}Aq?vUZOwcGh=F4DJ8P38S9D~3JtV@GHGx4Ucditwm^@xFftr&t1+t17cf~W5B_R$!AJVYHWIumosWB=M^R+Jc5}W!a zyRYOSoOo^UWR^6U14U1sbf zQYr6qBwT*LY2M6Df%+yW=N15UY-Ys*hBb5EdV3sy^6si2G|fa4z6!P>6>6$X^;m}z zM9xIhS@2=Qe1aDyH}2`{0Q*PS@W#alO0+C>-7r61IRqiLs1-10 zF<^#i8Uu4s6l~2SE(&SCW_1f=G%ccB73ZJ*43Yt z$Dp4etG9h(5TiY)qw}-73XJ?d)FfE+ELm?KDrp)FeN4X%7FI@7Q^6b2m95B;Ckl}C zkn_by6u)Qva)9}qzi0|@PA6ESoC&hR+SgrZw%Q&{qzH}$8226Yt-RC)gjtS$UMZ$B zYBxR|H~DsrGIeVUAD&uB9M1%6GGxUIOZziK1Q5Z6L+ShdU@Rpj06nFJfC8?;$R+}5)DmCf=#Mxb-h_SXOcY-R z0j}aqXUP#%+L#u`EwuXz!l!}fhftU3Rq31`W3cEXDs;P_>cnC;H z9fUks=UKMSD_1K88GfTgg+I-E7Lnv19@hFRegcWuE4?w%am=m0ey8wK{E}LU*d3AQ z!f-^VVjm84ZzcONyLk;l+h@}-_XjtlKuNklt2{)))U0WQZCCK5-GhDy7 z+3G|zGBxhAx>J8cRC|DQiAxH z&*U}8w$(vm`C*9mjuja>`43GSNA9H4H0iz&@D=48LRNTqIN4|n5%NL4iZr@oIRJ&N z;A3_u?H)mNCwI%-gwu!DKfdK!KQB-8>n12S+EOf~^JIn2N0W0Vy%-vG(L~?x!uSN)6@!_ff^1qk7XN6iGoN^r5l!aR(pB$ zi!^7w$v8~2cegl}zq7rJSWC~|UyXYA%&FHuPl@+mO4Jb4$L-qGa>cQpNT*osz)#w6 z$;VPYb-tN{fvNrbX6TtpzG%;J=VP=x!$ORyo2EzJGJP5_fvcOAuoqE5B``<>V(4aq z4`hg33C_>@FkMAE%pnUV=w=Tnur){dTTD+-gr|sCO+!%N9=M?&zg4gdW&5AV1|Lft zH<$(Q|##%I-&%kr}{P4R;p+b^Uh|LF|qIO`nzG5djfR+BTsapOpZXO+(xw;D9O#K zl4S#hGOvi%-Qx`*vwKwIwRUR2eH@Q=JkM9d*51`wlb(}z_ZLCb0mBO*jMpH?-u{dT z-K9_>KXI68bYL0Msx3*X;#%Mg8FftRBGmEePo-8JmqZv4jl$KY|1yE@ zSSCUcj9|gpgS&I|yRVs1lTY$$+cckb-bw(TW4{wAbI^KgswA_xX}yZIQzJh*lDv4N zDKjkSg|UvC*o`$4nvcr+Mr$w#SB7ShD5CtJY=h2#&%BaskO{J}ObkS#s>_U{g z?JRUd1~KY!A(~(;(|q{Z+uPub4b8A4({zVA-mTJhHt6;AIP_Qp@W~`J|VXTbY`wy`C2MQGI8@~P%CjSX7 z|KjZ5>g9i+BDc*}Bd5)_$a%Y1R%N?5^2|4$(CCo;U#Wip@PB~4e*kpAZm2$0Ht`KO zV{6Yk@r6R>_SRFhAPW{ecavLrxM(GaL16UF;n!Ztr_F`78(ov0>mz#@!u9bdqSoxH zgmG#@gAR?1P%_~QCF}2|ilMCWT}V$YjqSkF{)`d!XcZ?To!y+mSXrxp4TGLYb24*+ zQm5IUS%oGez>dQg1bl`3PlRNA5j1SAIssH|nBx(7c(HMHY83r=WMxDaSYn@a0Jx|! z1C#L1y*%F&EBUhxU-BA&C;q=`Q{t47bz#8qwa}l~2Vvd!#tciOj;MUr=z9KYPcdD2 zH*qqU_?x}D3hXsenLR0<>+cb-{neEh=`wZvUqhUxx_FmJMTc>y6hzWKg_y@FprsI@mRmY{7i zh!-rYZYcNI2HBGrY)<*s)_>=E@3Bk=f1wJIU)K@3%~U7%5UzH7!-cT#IHCJxWm1#< zrKodP%L$!TA+es@-*zi&j_MXC z8O8vQKNR?Mx|7Foj}nNJeqTSmRk>?nH}O%;Qoi`x&6PeO@P_!dX9E}a_bo%?Gp&~M z%w)?Lo}O`wEgQ8&SNRR z-m-`1_{tQG!(KHVf?+x;<8zLfGHEOid*nF0G;b4CdJ?~37$Hm-=iY#b?tU~n$)k>1 zcf-(Nxvpd_;>pmN0Q;}YD*OmhbdBVU;eO68zF{4(zIg|gQixRT0p$SPuE^4Drz}&U z2qvR&=~`1d8R7OGB=9E-)o6WaMq&}Ne45@c6>D=|vsWmLLI zk%$jwqfrEIgRxUbe2s*YPsvWMb=(;>V(JAfB(t%v& z0s3LDA(M`T6(SVP6tfo98UUVvKr7}=UCo47i8H^fd->m?&3IpFsuz@X9{#-nCwxe6 z5(b=daGaK~j=7EIW(2Jm-IvjmZ>&0NcfN+bt3dzq3yfL>(<=d0c58nZg4WGDX14c2 z)w}f#aUD7d)ZTy_O<@WJ%-#Twk63VJb*oIFdNGjhwSxb&cb?HrhCe#O%kABeP+LWH zDvBpas)`QXX+JXAR17dZooPNy;hZwj+=xb3zVbWp^EI?4s%BHfVPadROs zv3PeHN{&Qq>Z~mW0%gLY=$T@|{u(LV9ujZiA^spE%tBb9! zVlN>v?Bn(Pn(7pqxwh9;e}QQFD6f=I)Yd^1@Eh){Cpk@s`M)-@%K5Ajae9-lVp<8a z_c!Nl#*wv1R`J)XwVtUDUkw=Gnc&Rl3NA+UVnA>+7%=gSoZBX9j@ZvCnmj@2bjse# zrOq*@nm@E>qAI1=>_tIl@r`ECLw@%2H2 z9p)lOym_%PJzfxJP_+`iC>Eql@*7G^gH#0iZHQmyJ(A5m+)@P>vRt(J-^>{V3tfds zIyAk4iA^Ou#B88c$#O4kf|QRh*V_{cm2=N>uC>UdYnRecDy-3c8>@%(ckvkRQhENo zQxb2}Nr|A#r@r7uXDIRpL_GHW8VG{cwSqSw;qQHK=iXz0>+NnR`8(7~sHPtJK48no zu@=mHohbLU9{Rt&W$+Yj+)~b%coWRCr6|+;Q~hnyr;FSW9zHaH7K7d9aFTR51I`at zN}`m%A#Y;njUnh)(?j*6&-p`1fkIPs^&JFTqf4!SgejPE8$&w2#Z0dH3;^iz)7tpr zoNITa?wmB4(UP*I*<%iJz19fZ-t{hs?^_)NgX%GkqHca%*9B3(kLv8ck0zYFl%G@0 zPPE;5X^=%Odp={8X(qlOZ zKk)t{a<6Mw4VFA)_Tg#^{G_K#oR`*b`lJW!XxQh}<9u7@w_EdR@u;*UIi@#&>3kEx z^$7Ys?lT3<7G6vwO2&kx5`UOran|x2=Ui7G7x{{egGtiQ1c%XY z!ji|V6SH9eAN2MRH!hJdm5^L%XwqEsawzV=W|AzLS6 z#69RCXj2~h5(E)3Cst7di|wjJpawudW|}X$m)l=8 z4JNRMU_Ouv2JLPfsPDhe_|mb^jA0FY`GFO*{yVliY3fP@&aGUX*9|H-h3J4+xApf9 zT;TI8PIq14`Yb-O1!ddDRQH*4o6zLC4J9q~)8;b|^`oqZ!7JN4L4^ z-3jgvOX%i!?kndxgPjwZ-_HFpb>9zt+;L>)GBzNlO3!gWv-J%G022t`dW@`HgW2Cl zBd%h}#q|q5kN^WP1&nGq#Xb8%61PiyWww_jIQ;k>F)4O+S;I9M68@*v1ok>0kjh8(8HcGpc(D7?71xSZ z0Kh07C%c$9`aJ&xy@rB!ei+3ZF!oE+5qnTzS0N>-Z3rXL3S%kBrU6`6;1>g5|^|Wzz1_mL< zQ?fnZSnelB35Q3&efvuw3Q-Bk7Q>N8UwHq(X!7rC2D2Bq(gs0fahR9Q46-Z1xm1+Aabh>rmmffwXoh$O_) z4YxhbB4yiyahXX_=ykvr=e2_>S*B|sY&*3=An|1wf|{7&h`eGeiaf=-0R_Lh4{k+j zSE6*rGGg|NM{et^u-2*W?n@Gh!IfJH4EfN}qPw1@CXUuWi<=@o=JMeKsOgc5`LU9A z)29gL)Fp0+TArwnA7OH}i5cgIV*vUXiC7f@!z^$Qu}N{RDjuKm=rj~y2P8%Q7}(z3 zA0Kn&f8zRv^mK<(Rc+OG@dxc`0e3DNJ1dzJaf=xcqG2Dx=r9L@i4#O`ME@8O96|dl zp?sz@#c9AJE|E^5TA3xM@8v?l046<_ zG(c2hs>_6@wr%q@At1*5xr$`Lfa@Lia*{f%p?fv}AZzWeAS~cVlPx8fB7iHJvKBUF1bs#M&0f3R+SpD?xZZ!=clDyW&=-j;i(uG1^($aRdx!pD$-R)6SQPCt1Vivd zpM<7AN^q!&^hg3TbS6qgt~~v0dRBCGcy@RUcJ&$e5Cm=^vj&_tU<8f)q(9tDwU_GK zeo2RhG&DL11+)twvjd?Sl$j-$3}_*ookVV_>{?m%V z3w6ABk@h7Rwd6dEZvmfwAUF8(Bn+jc`WE9%L+2J630vG?kW+Mj+x{bm7=Uqit3A_8J1qvu%Gc} z__HHLo2o!Qbv&jZE?3_t&Qz}agOAuPi}%JbFvR7ni)w$*n@oSAkvdtQw1Hkgtegw| zTeHf%<`O_1*q0aJ{l0hEl^*%+Vmq{b%Z&(4=_&dbpX*!gjfEm(jpM8UNn22t(S*u5Ea zX<>J2qeCz?C$RaI7A#(F%*eKfe_H zql!M(#9Ndc%fCE;@9f!s$Rzmh5e$yrPI)QHU|-9HP&!HVfrGz-doJc!$@auV5;db9 zXK*h^_>G;TJ~}ox4su}iUef}ntp$rha3y%K;6E1%3b)F2A2=r1y@)@*;o zPqH#!W7Ux9U-f0cU$rwSV>(!^G}8w}-keL#U$jhn4`GowCgnGf>qyuPH*k`s*K5YoGW{{4am6s7B{^78M8SR}qKbQOUyjoXr7j_5FLAZr5$O6gM7i zSVJnd6-oJ{*)wjOFW>I{1J2sL7eyxM!A(T^NEq&Y{sOFu#QB2o=ZM(n>I?B)PdJyK zE}ZT4+IuAjgQ1z?1W^O#Ps@EqTAZ$*{bgecQdUhlOmDd^KVXcg%fAq*XY!H0OQ{9k zSNW*%*h&B+aMsyQ8>~ppSIhT6X@Go({`v9peQ1=+LG`wo4m)Ai4E0@;0r7^C#m%#8 zU`-lvERgB|0f>sdPYC6U25(2|%T9x9Cz2mbeWnUSH_aMvFK0b#T}uf zKN!AmBJP0U$j4+PQk^Po4tany*%T^*oA;kjvYp-DJqY4ITGzwYgAJwowxyGye&E&p zK1!%yA~eVG9zYEJqvs30_KudQ8-p?ldFcHYKE43Qfz{Dnou@WftztzNgpKhV@23Ab_+70}-M??~3)H*c)auAnvJZdaSaNxW9+9_cCN9 zdq=y@w718l$EcCI9i&lJv#zK(;&!d@a~QfOO_%rnY50^@0~I>c#>;FXzd{nnYGLQm z7&tKU=L`uidSnlEXKQ!Qbw~g&tgb#0w!Y)H7}1_8$bG=`jg<;_K>ZM*j#4Z@MXAXq-~P z`87HWjnM44N~a%^$)<0(#lQ2$u^aUT%60rsBeLuuq`2$h3n?od;|V;Grh1!?7JDed V{=ZLesl33!wlG|FFuSlY{{sZ_