From 95644745cbca29b3ae9983ac55d13becdf2e7c0f Mon Sep 17 00:00:00 2001 From: abdibekbolot Date: Wed, 17 Jun 2026 08:17:04 +0900 Subject: [PATCH 01/40] chore(submodule): add rest.mdm-sn-container-runner as git submodule Add the container runner submodule at src/modules/rest.mdm-sn-container-runner pointing to RedTeamSubnet/rest.hb-bot-executer. Remove the empty __init__.py that conflicts with the submodule directory. --- .gitmodules | 3 +++ src/modules/__init__.py | 0 src/modules/rest.mdm-sn-container-runner | 1 + 3 files changed, 4 insertions(+) create mode 100644 .gitmodules delete mode 100644 src/modules/__init__.py create mode 160000 src/modules/rest.mdm-sn-container-runner diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..da79764 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "src/modules/rest.mdm-sn-container-runner"] + path = src/modules/rest.mdm-sn-container-runner + url = git@github.com:RedTeamSubnet/rest.hb-bot-executer.git diff --git a/src/modules/__init__.py b/src/modules/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/src/modules/rest.mdm-sn-container-runner b/src/modules/rest.mdm-sn-container-runner new file mode 160000 index 0000000..d7fb3a0 --- /dev/null +++ b/src/modules/rest.mdm-sn-container-runner @@ -0,0 +1 @@ +Subproject commit d7fb3a063a5f24c3f4c5afa4786a4d623eaff93d From b4d3e8f84f5a5768e72a4d1ebbf49250eb46f598 Mon Sep 17 00:00:00 2001 From: abdibekbolot Date: Wed, 17 Jun 2026 08:17:13 +0900 Subject: [PATCH 02/40] fix(package): update pyproject.toml for bot-virus-challenge project Enable setuptools package discovery under src/ for bv_challenge. Fix version attr to reference __version__ directly and dependencies file to list format. Update all project URLs from challenge-template to bot-virus-challenge. --- pyproject.toml | 22 ++++++++++++---------- 1 file changed, 12 insertions(+), 10 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 2d25dc6..8dcdea4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -32,14 +32,16 @@ classifiers = [ ] dynamic = ["version", "dependencies", "optional-dependencies"] -# [tool.setuptools.packages.find] -# where = ["src"] -# include = ["bv_challenge*"] -# namespaces = false +[tool.setuptools] +include-package-data = true + +[tool.setuptools.packages.find] +where = ["src"] +include = ["bv_challenge*"] [tool.setuptools.dynamic] -version = { attr = "bv_challenge.__version__.__version__" } -dependencies = { file = "./requirements.txt" } +version = { attr = "bv_challenge.__version__" } +dependencies = { file = ["requirements.txt"] } [tool.setuptools.dynamic.optional-dependencies] # Options dependencies for DEVELOPMENT @@ -62,8 +64,8 @@ dev = { file = [ # venv = ".venv" [project.urls] -Homepage = "https://github.com/RedTeamSubnet/challenge-template" +Homepage = "https://github.com/RedTeamSubnet/bot-virus-challenge" Documentation = "https://docs.theredteam.io" -Repository = "https://github.com/RedTeamSubnet/challenge-template.git" -Issues = "https://github.com/RedTeamSubnet/challenge-template/issues" -Changelog = "https://github.com/RedTeamSubnet/challenge-template/blob/main/CHANGELOG.md" +Repository = "https://github.com/RedTeamSubnet/bot-virus-challenge.git" +Issues = "https://github.com/RedTeamSubnet/bot-virus-challenge/issues" +Changelog = "https://github.com/RedTeamSubnet/bot-virus-challenge/blob/main/CHANGELOG.md" From 5282187fe7ab244b5b4ff9559ce0e1c99c39b675 Mon Sep 17 00:00:00 2001 From: abdibekbolot Date: Wed, 17 Jun 2026 08:17:20 +0900 Subject: [PATCH 03/40] fix(scripts): update version scripts for Python module format Change VERSION_FILE_PATH from VERSION.txt to bv_challenge.__version__.py. bump-version.sh now writes '__version__ = "x.y.z"' format. get-version.sh now parses Python __version__ assignment instead of raw text. --- scripts/bump-version.sh | 4 ++-- scripts/get-version.sh | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/scripts/bump-version.sh b/scripts/bump-version.sh index c674dc4..b88bfc9 100755 --- a/scripts/bump-version.sh +++ b/scripts/bump-version.sh @@ -26,7 +26,7 @@ fi ## --- Variables --- ## # Load from environment variables: -VERSION_FILE_PATH="${VERSION_FILE_PATH:-./VERSION.txt}" +VERSION_FILE_PATH="${VERSION_FILE_PATH:-./src/bv_challenge/__version__.py}" _BUMP_TYPE="" @@ -130,7 +130,7 @@ main() echo "[INFO]: Bumping version to '${_new_version}'..." # Update the version file with the new version: - echo "${_new_version}" > "${VERSION_FILE_PATH}" || exit 2 + echo -e "__version__ = \"${_new_version}\"" > "${VERSION_FILE_PATH}" || exit 2 echo "[OK]: New version: '${_new_version}'" ./scripts/sync-versions.sh -a || exit 2 diff --git a/scripts/get-version.sh b/scripts/get-version.sh index 2b59ebe..28bce9c 100755 --- a/scripts/get-version.sh +++ b/scripts/get-version.sh @@ -15,12 +15,12 @@ cd "${_PROJECT_DIR}" || exit 2 ## --- Variables --- ## # Load from environment variables: -VERSION_FILE_PATH="${VERSION_FILE_PATH:-./VERSION.txt}" +VERSION_FILE_PATH="${VERSION_FILE_PATH:-./src/bv_challenge/__version__.py}" ## --- Variables --- ## if [ -n "${VERSION_FILE_PATH}" ] && [ -f "${VERSION_FILE_PATH}" ]; then - _current_version=$(cat "${VERSION_FILE_PATH}") || exit 2 + _current_version=$(< "${VERSION_FILE_PATH}" grep "__version__ = " | awk -F' = ' '{print $2}' | tr -d '"') || exit 2 else _current_version="0.0.0" fi From 321979886d363a700942b0a55b282c6d08405ab7 Mon Sep 17 00:00:00 2001 From: abdibekbolot Date: Wed, 17 Jun 2026 08:17:29 +0900 Subject: [PATCH 04/40] feat(bot): add WebUI automation bot module Add src/bot/ package with Selenium-based WebUI automation: - main.py: entrypoint with config loading, internet check, session loop - core/bot.py: automation logic with failed-challenge detection - driver.py: Chromium driver setup with stealth options - constants.py: environment-based configuration - Dockerfile + Dockerfile.base: multi-stage container builds - compose.yml: standalone bot compose stack - Scripts: build-base.sh, build.sh, docker-entrypoint.sh, run.sh --- src/bot/.dockerignore | 499 +++++++++++++++++++++++++++ src/bot/Dockerfile | 35 ++ src/bot/Dockerfile.base | 20 ++ src/bot/compose.yml | 17 + src/bot/requirements.txt | 3 + src/bot/scripts/build-base.sh | 22 ++ src/bot/scripts/build.sh | 21 ++ src/bot/scripts/docker-entrypoint.sh | 18 + src/bot/scripts/run.sh | 28 ++ src/bot/src/constants.py | 17 + src/bot/src/core/__init__.py | 1 + src/bot/src/core/bot.py | 141 ++++++++ src/bot/src/driver.py | 136 ++++++++ src/bot/src/main.py | 80 +++++ 14 files changed, 1038 insertions(+) create mode 100644 src/bot/.dockerignore create mode 100644 src/bot/Dockerfile create mode 100644 src/bot/Dockerfile.base create mode 100644 src/bot/compose.yml create mode 100644 src/bot/requirements.txt create mode 100755 src/bot/scripts/build-base.sh create mode 100755 src/bot/scripts/build.sh create mode 100644 src/bot/scripts/docker-entrypoint.sh create mode 100755 src/bot/scripts/run.sh create mode 100644 src/bot/src/constants.py create mode 100644 src/bot/src/core/__init__.py create mode 100644 src/bot/src/core/bot.py create mode 100644 src/bot/src/driver.py create mode 100644 src/bot/src/main.py diff --git a/src/bot/.dockerignore b/src/bot/.dockerignore new file mode 100644 index 0000000..907e7bf --- /dev/null +++ b/src/bot/.dockerignore @@ -0,0 +1,499 @@ +# File created using '.gitignore Generator' for Visual Studio Code: https://bit.ly/vscode-gig +# Created by https://www.toptal.com/developers/gitignore/api/zsh,xcode,windows,visualstudiocode,vim,sublimetext,python,macos,linux,jetbrains+all +# Edit at https://www.toptal.com/developers/gitignore?templates=zsh,xcode,windows,visualstudiocode,vim,sublimetext,python,macos,linux,jetbrains+all + +### JetBrains+all ### +# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider +# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839 + +# User-specific stuff +.idea/**/workspace.xml +.idea/**/tasks.xml +.idea/**/usage.statistics.xml +.idea/**/dictionaries +.idea/**/shelf + +# AWS User-specific +.idea/**/aws.xml + +# Generated files +.idea/**/contentModel.xml + +# Sensitive or high-churn files +.idea/**/dataSources/ +.idea/**/dataSources.ids +.idea/**/dataSources.local.xml +.idea/**/sqlDataSources.xml +.idea/**/dynamic.xml +.idea/**/uiDesigner.xml +.idea/**/dbnavigator.xml + +# Gradle +.idea/**/gradle.xml +.idea/**/libraries + +# Gradle and Maven with auto-import +# When using Gradle or Maven with auto-import, you should exclude module files, +# since they will be recreated, and may cause churn. Uncomment if using +# auto-import. +# .idea/artifacts +# .idea/compiler.xml +# .idea/jarRepositories.xml +# .idea/modules.xml +# .idea/*.iml +# .idea/modules +# *.iml +# *.ipr + +# CMake +cmake-build-*/ + +# Mongo Explorer plugin +.idea/**/mongoSettings.xml + +# File-based project format +*.iws + +# IntelliJ +out/ + +# mpeltonen/sbt-idea plugin +.idea_modules/ + +# JIRA plugin +atlassian-ide-plugin.xml + +# Cursive Clojure plugin +.idea/replstate.xml + +# SonarLint plugin +.idea/sonarlint/ + +# Crashlytics plugin (for Android Studio and IntelliJ) +com_crashlytics_export_strings.xml +crashlytics.properties +crashlytics-build.properties +fabric.properties + +# Editor-based Rest Client +.idea/httpRequests + +# Android studio 3.1+ serialized cache file +.idea/caches/build_file_checksums.ser + +### JetBrains+all Patch ### +# Ignore everything but code style settings and run configurations +# that are supposed to be shared within teams. + +.idea/* + +!.idea/codeStyles +!.idea/runConfigurations + +### Linux ### +*~ + +# temporary files which can be created if a process still has a handle open of a deleted file +.fuse_hidden* + +# KDE directory preferences +.directory + +# Linux trash folder which might appear on any partition or disk +.Trash-* + +# .nfs files are created when an open file is removed but is still being accessed +.nfs* + +### macOS ### +# General +.DS_Store +.AppleDouble +.LSOverride + +# Icon must end with two \r +Icon + + +# Thumbnails +._* + +# Files that might appear in the root of a volume +.DocumentRevisions-V100 +.fseventsd +.Spotlight-V100 +.TemporaryItems +.Trashes +.VolumeIcon.icns +.com.apple.timemachine.donotpresent + +# Directories potentially created on remote AFP share +.AppleDB +.AppleDesktop +Network Trash Folder +Temporary Items +.apdisk + +### macOS Patch ### +# iCloud generated files +*.icloud + +### Python ### +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +*.py,cover +.hypothesis/ +.pytest_cache/ +cover/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 +db.sqlite3-journal + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +.pybuilder/ +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +# For a library or package, you might want to ignore these files since the code is +# intended to run in multiple environments; otherwise, check them in: +# .python-version + +# pipenv +# According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. +# However, in case of collaboration, if having platform-specific dependencies or dependencies +# having no cross-platform support, pipenv may install dependencies that don't work, or not +# install all needed dependencies. +#Pipfile.lock + +# poetry +# Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +# https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control +#poetry.lock + +# pdm +# Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +#pdm.lock +# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it +# in version control. +# https://pdm.fming.dev/#use-with-ide +.pdm.toml + +# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm +__pypackages__/ + +# Celery stuff +celerybeat-schedule +celerybeat.pid + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ + +# pytype static type analyzer +.pytype/ + +# Cython debug symbols +cython_debug/ + +# PyCharm +# JetBrains specific template is maintained in a separate JetBrains.gitignore that can +# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore +# and can be added to the global gitignore or merged into this file. For a more nuclear +# option (not recommended) you can uncomment the following to ignore the entire idea folder. +#.idea/ + +### Python Patch ### +# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration +poetry.toml + +# ruff +.ruff_cache/ + +# LSP config files +pyrightconfig.json + +### SublimeText ### +# Cache files for Sublime Text +*.tmlanguage.cache +*.tmPreferences.cache +*.stTheme.cache + +# Workspace files are user-specific +*.sublime-workspace + +# Project files should be checked into the repository, unless a significant +# proportion of contributors will probably not be using Sublime Text +# *.sublime-project + +# SFTP configuration file +sftp-config.json +sftp-config-alt*.json + +# Package control specific files +Package Control.last-run +Package Control.ca-list +Package Control.ca-bundle +Package Control.system-ca-bundle +Package Control.cache/ +Package Control.ca-certs/ +Package Control.merged-ca-bundle +Package Control.user-ca-bundle +oscrypto-ca-bundle.crt +bh_unicode_properties.cache + +# Sublime-github package stores a github token in this file +# https://packagecontrol.io/packages/sublime-github +GitHub.sublime-settings + +### Vim ### +# Swap +[._]*.s[a-v][a-z] +!*.svg # comment out if you don't need vector files +[._]*.sw[a-p] +[._]s[a-rt-v][a-z] +[._]ss[a-gi-z] +[._]sw[a-p] + +# Session +Session.vim +Sessionx.vim + +# Temporary +.netrwhist +# Auto-generated tag files +tags +# Persistent undo +[._]*.un~ + +### VisualStudioCode ### +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +!.vscode/*.code-snippets + +# Local History for Visual Studio Code +.history/ + +# Built Visual Studio Code Extensions +*.vsix + +### VisualStudioCode Patch ### +# Ignore all local history of files +.history +.ionide + +### Windows ### +# Windows thumbnail cache files +Thumbs.db +Thumbs.db:encryptable +ehthumbs.db +ehthumbs_vista.db + +# Dump file +*.stackdump + +# Folder config file +[Dd]esktop.ini + +# Recycle Bin used on file shares +$RECYCLE.BIN/ + +# Windows Installer files +*.cab +*.msi +*.msix +*.msm +*.msp + +# Windows shortcuts +*.lnk + +### Xcode ### +## User settings +xcuserdata/ + +## Xcode 8 and earlier +*.xcscmblueprint +*.xccheckout + +### Xcode Patch ### +*.xcodeproj/* +!*.xcodeproj/project.pbxproj +!*.xcodeproj/xcshareddata/ +!*.xcodeproj/project.xcworkspace/ +!*.xcworkspace/contents.xcworkspacedata +/*.gcno +**/xcshareddata/WorkspaceSettings.xcsettings + +### Zsh ### +# Zsh compiled script + zrecompile backup +*.zwc +*.zwc.old + +# Zsh completion-optimization dumpfile +*zcompdump* + +# Zsh history +.zsh_history + +# Zsh sessions +.zsh_sessions + +# Zsh zcalc history +.zcalc_history + +# A popular plugin manager's files +._zinit +.zinit_lstupd + +# zdharma/zshelldoc tool's files +zsdoc/data + +# robbyrussell/oh-my-zsh/plugins/per-directory-history plugin's files +# (when set-up to store the history in the local directory) +.directory_history + +# MichaelAquilina/zsh-autoswitch-virtualenv plugin's files +# (for Zsh plugins using Python) + +# Zunit tests' output +/tests/_output/* +!/tests/_output/.gitkeep + +# End of https://www.toptal.com/developers/gitignore/api/zsh,xcode,windows,visualstudiocode,vim,sublimetext,python,macos,linux,jetbrains+all + +# Custom rules (everything added below won't be overriden by 'Generate .gitignore File' if you use 'Update' option) + + +# Directories: +.git +.github + +# Files: +.gitignore +.gitkeep +.gitmodules + +**/*.git +**/*.gitignore +**/*.gitkeep +**/*.gitmodules +**/*.github +**/*__pycache__ +**/*.pytest_cache +**/*.benchmarks +**/*.coverage +**/*.DS_Store +**/*.Thumbs.db +**/*.pyc +**/*.pyo +**/*.pyd +**/*.env +**/*.venv +**/*.lock +**/*.bak +**/*.log +**/logs +**/tmp +**/data +**/modules diff --git a/src/bot/Dockerfile b/src/bot/Dockerfile new file mode 100644 index 0000000..68d8896 --- /dev/null +++ b/src/bot/Dockerfile @@ -0,0 +1,35 @@ +# syntax=docker/dockerfile:1 + +FROM redteamsubnet61/bv-bot-base:latest + +USER root + +WORKDIR /app + +ARG DEBIAN_FRONTEND=noninteractive +ARG APT_PACKAGES="" + +RUN set -eux; \ + if [ -n "${APT_PACKAGES:-}" ]; then \ + apt-get update --fix-missing; \ + apt-get install -y --no-install-recommends ${APT_PACKAGES}; \ + rm -rf /var/lib/apt/lists/*; \ + fi + +COPY requirements.txt /app/requirements.txt + +RUN chmod 644 /app/requirements.txt && \ + ls -lah /app && \ + ls -lah /app/requirements.txt && \ + cat /app/requirements.txt + +RUN python3 -m pip install --no-cache-dir --upgrade pip setuptools wheel && \ + python3 -m pip install --no-cache-dir -r /app/requirements.txt + +COPY ./src /app + +RUN chown -R seluser:seluser /app + +USER seluser + +ENTRYPOINT ["docker-entrypoint.sh"] \ No newline at end of file diff --git a/src/bot/Dockerfile.base b/src/bot/Dockerfile.base new file mode 100644 index 0000000..7938e17 --- /dev/null +++ b/src/bot/Dockerfile.base @@ -0,0 +1,20 @@ +# syntax=docker/dockerfile:1 + +FROM selenium/standalone-chrome:4.31.0-20250414 + +ARG DEBIAN_FRONTEND=noninteractive + +# Install python3 and pip +RUN _BUILD_TARGET_ARCH=$(uname -m) && \ + echo "BUILDING TARGET ARCHITECTURE: ${_BUILD_TARGET_ARCH}" && \ + sudo rm -rfv /var/lib/apt/lists/* /var/cache/apt/archives/* /tmp/* && \ + sudo apt-get clean -y && \ + sudo apt-get update --fix-missing -o Acquire::CompressionTypes::Order::=gz && \ + sudo apt-get install -y --no-install-recommends \ + python3 \ + python3-pip \ + python3-venv \ + iproute2 && \ + sudo rm -rfv /var/lib/apt/lists/* /var/cache/apt/archives/* /tmp/* + +WORKDIR /app diff --git a/src/bot/compose.yml b/src/bot/compose.yml new file mode 100644 index 0000000..4c6cabe --- /dev/null +++ b/src/bot/compose.yml @@ -0,0 +1,17 @@ +services: + bot: + image: bot:latest + build: + context: . + platforms: + - linux/amd64 + environment: + TERM: ${TERM:-xterm} + TZ: UTC + BV_WEB_URL: ${BV_WEB_URL:-https://172.17.0.1:10001/_web} + BV_ACTION_LIST: ${BV_ACTION_LIST} + BV_SESSION_COUNT: ${BV_SESSION_COUNT} + env_file: + - path: .env + required: false + tty: true diff --git a/src/bot/requirements.txt b/src/bot/requirements.txt new file mode 100644 index 0000000..170ef60 --- /dev/null +++ b/src/bot/requirements.txt @@ -0,0 +1,3 @@ +pydantic[email,timezone]>=2.0.0,<3.0.0 +selenium>=4.16.0,<5.0.0 +requests>=2.31.0,<3.0.0 diff --git a/src/bot/scripts/build-base.sh b/src/bot/scripts/build-base.sh new file mode 100755 index 0000000..a441109 --- /dev/null +++ b/src/bot/scripts/build-base.sh @@ -0,0 +1,22 @@ +#!/bin/bash +set -euo pipefail + + +# Getting path of this script file: +_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)" +_PROJECT_DIR="$(cd "${_SCRIPT_DIR}/.." >/dev/null 2>&1 && pwd)" +cd "${_PROJECT_DIR}" || exit 2 + +# Loading .env file (if exists): +if [ -f ".env" ]; then + # shellcheck disable=SC1091 + source .env +fi + + +DOCKER_BUILDKIT=1 docker build \ + --progress plain \ + --platform linux/amd64 \ + -t redteamsubnet61/bv-bot-base:latest \ + -f Dockerfile.base \ + . || exit 2 diff --git a/src/bot/scripts/build.sh b/src/bot/scripts/build.sh new file mode 100755 index 0000000..57584a3 --- /dev/null +++ b/src/bot/scripts/build.sh @@ -0,0 +1,21 @@ +#!/bin/bash +set -euo pipefail + + +# Getting path of this script file: +_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)" +_PROJECT_DIR="$(cd "${_SCRIPT_DIR}/.." >/dev/null 2>&1 && pwd)" +cd "${_PROJECT_DIR}" || exit 2 + +# Loading .env file (if exists): +if [ -f ".env" ]; then + # shellcheck disable=SC1091 + source .env +fi + + +DOCKER_BUILDKIT=1 docker build \ + --progress plain \ + --platform linux/amd64 \ + -t bot:latest \ + . diff --git a/src/bot/scripts/docker-entrypoint.sh b/src/bot/scripts/docker-entrypoint.sh new file mode 100644 index 0000000..4901019 --- /dev/null +++ b/src/bot/scripts/docker-entrypoint.sh @@ -0,0 +1,18 @@ +#!/bin/bash +set -euo pipefail + +echo "INFO: Running bot docker-entrypoint.sh..." + +# Activate virtual environment and run the bot script +cd /app + +# Add current directory to PYTHONPATH to fix imports +export PYTHONPATH="/app:${PYTHONPATH:-}" + +echo "INFO: PYTHONPATH=${PYTHONPATH}" +echo "INFO: Python version: $(python --version)" +echo "INFO: Current directory: $(pwd)" +echo "INFO: Directory contents:" +ls -la + +exec python -u main.py diff --git a/src/bot/scripts/run.sh b/src/bot/scripts/run.sh new file mode 100755 index 0000000..59b2b91 --- /dev/null +++ b/src/bot/scripts/run.sh @@ -0,0 +1,28 @@ +#!/bin/bash +set -euo pipefail + + +# Getting path of this script file: +_SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)" +_PROJECT_DIR="$(cd "${_SCRIPT_DIR}/.." >/dev/null 2>&1 && pwd)" +cd "${_PROJECT_DIR}" || exit 2 + +# Loading .env file (if exists): +if [ -f ".env" ]; then + # shellcheck disable=SC1091 + source .env +fi + + +docker run \ + --rm \ + -it \ + --platform linux/amd64 \ + --name bot_container \ + -e BV_WEB_URL="${BV_WEB_URL:-http://172.17.0.1:10001/_web}" \ + -e BV_ACTION_LIST="${BV_ACTION_LIST:-}" \ + -e BV_SESSION_COUNT="${BV_SESSION_COUNT:-}" \ + bot:latest + + # --network bot-virus-challenge_default \ + # -e BV_WEB_URL="${BV_WEB_URL:-http://challenger-api:10001/_web}" \ diff --git a/src/bot/src/constants.py b/src/bot/src/constants.py new file mode 100644 index 0000000..68784e8 --- /dev/null +++ b/src/bot/src/constants.py @@ -0,0 +1,17 @@ +# -*- coding: utf-8 -*- +from pydantic import Field +from pydantic_settings import SettingsConfigDict, BaseSettings +ENV_PREFIX = "BV_" +class Config(BaseSettings): + WEB_URL: str = Field("http://challenge-api:10001/_web") + SESSION_COUNT: int = Field(2) + + model_config = SettingsConfigDict( + # validate_assignment=True, + env_file=".env", + env_prefix=ENV_PREFIX, + env_nested_delimiter="__", + extra="ignore", + ) + +__all__ = ["Config", "ENV_PREFIX"] diff --git a/src/bot/src/core/__init__.py b/src/bot/src/core/__init__.py new file mode 100644 index 0000000..40a96af --- /dev/null +++ b/src/bot/src/core/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/bot/src/core/bot.py b/src/bot/src/core/bot.py new file mode 100644 index 0000000..94a7cc5 --- /dev/null +++ b/src/bot/src/core/bot.py @@ -0,0 +1,141 @@ +import logging +import time +import json + +from selenium.webdriver.common.by import By +from selenium.webdriver.common.actions.action_builder import ActionBuilder +from selenium.webdriver.common.actions.pointer_input import PointerInput + +from selenium.webdriver.remote.webdriver import WebDriver +from selenium.webdriver.support import expected_conditions as EC +from selenium.webdriver.support.ui import WebDriverWait + +logger = logging.getLogger(__name__) + + +def run_bot( + driver: WebDriver, +) -> bool: + """Run bot to automate login. + + Args: + driver (WebDriver, required): Selenium WebDriver instance. + + Returns: + bool: True if login is successful, False otherwise. + """ + + try: + _wait = WebDriverWait(driver, 15) + + mouse = PointerInput(kind="mouse", name="mouse") + + # Execute JavaScript to get ACTIONS_LIST + actions_list = json.loads(driver.execute_script("return window.ACTIONS_LIST;")) + if actions_list: + logger.info("Retrieved config from window.ACTIONS_LIST") + else: + logger.error("window.ACTIONS_LIST is empty or doesn't exist") + return False + + # Handle nested list structure - if actions_list is a list of lists, flatten it + if isinstance(actions_list, list) and len(actions_list) > 0 and isinstance(actions_list[0], list): + logger.info("Detected nested actions_list structure, flattening...") + actions_list = actions_list[0] + + # Perform configured actions + for i, _action in enumerate(actions_list): + if _action["type"] == "click": + x = _action["args"]["location"]["x"] + y = _action["args"]["location"]["y"] + + logger.info(f"Action {i+1}: Clicking at ({x}, {y})") + + try: + actions = ActionBuilder(driver, mouse=mouse) + actions.pointer_action.move_to_location(x, y) + actions.pointer_action.click() + actions.perform() + + time.sleep(0.5) + + except Exception as e: + logger.error(f"Failed to perform action {i+1}: {e}") + continue + + if _action["type"] == "input": + _selector = _action["selector"] + _args = _action["args"] + + logger.info( + f"Action {i+1}: Inputting '{_args['text']}' to '{_selector}'" + ) + + try: + _element = driver.find_element(By.ID, _selector["id"]) + _element.clear() + _element.send_keys(_args["text"]) + except Exception as e: + logger.error(f"Failed to perform action {i+1}: {e}") + continue + + # Click login button without scrolling + _login_button = _wait.until( + EC.presence_of_element_located((By.ID, "login-button")) + ) + _login_button.click() + + logger.info("Scrolling to find end-session button") + + lenOfPage = driver.execute_script( + "window.scrollTo(0, document.body.scrollHeight);var lenOfPage=document.body.scrollHeight;return lenOfPage;" + ) + logger.info(f"Initial page length: {lenOfPage}") + match = False + while match == False: + lastCount = lenOfPage + time.sleep(3) + lenOfPage = driver.execute_script( + "window.scrollTo(0, document.body.scrollHeight);var lenOfPage=document.body.scrollHeight;return lenOfPage;" + ) + if lastCount == lenOfPage: + logger.info("Reached bottom of page") + match = True + + _end_session_button = _wait.until( + EC.presence_of_element_located((By.CLASS_NAME, "end-session")) + ) + + driver.execute_script( + "arguments[0].scrollIntoView({behavior: 'smooth', block: 'center'});", + _end_session_button, + ) + time.sleep(1) # Give time for smooth scrolling to complete + + _end_session_button.click() + logger.info("Clicked end-session button") + + # Give the browser a moment to flush console messages + time.sleep(1) + + # Attempt to read browser console logs (may not be supported by all drivers) + try: + console_logs = driver.get_log("browser") + if console_logs: + logger.info("Browser console logs:") + for entry in console_logs: + level = entry.get("level") + msg = entry.get("message") + source = entry.get("source") or entry.get("sourceURL") or "" + ts = entry.get("timestamp") + logger.info(f"[console][{level}] {ts} {source} - {msg}") + else: + logger.info("No browser console logs available.") + except Exception as e: + logger.warning(f"Could not retrieve browser console logs: {e}") + + return True + + except Exception as err: + logger.error(f"Login failed: {err}") + return False diff --git a/src/bot/src/driver.py b/src/bot/src/driver.py new file mode 100644 index 0000000..2372d06 --- /dev/null +++ b/src/bot/src/driver.py @@ -0,0 +1,136 @@ +# -*- coding: utf-8 -*- + +import time +import logging +from typing import Union, Any, Dict + +from pydantic import HttpUrl +from selenium import webdriver +from selenium.common.exceptions import WebDriverException +from selenium.webdriver.common.by import By +from selenium.webdriver.remote.webdriver import WebDriver +from selenium.webdriver.support import expected_conditions as EC +from selenium.webdriver.support.ui import WebDriverWait + +from core.bot import run_bot + + +logger = logging.getLogger(__name__) + + +class WebUIAutomate: + """Class to handle web UI automation tasks.""" + + _VIEWPORT_WIDTH = 1440 + _VIEWPORT_HEIGHT = 900 + + def __init__(self, web_url: HttpUrl): + """ + Initialize WebUI automation. + + Args: + web_url (str , required): URL to automate. + """ + + self.web_url = web_url + self.driver: Union[WebDriver, None] = None + + def setup_driver(self) -> None: + """Initialize Chrome WebDriver.""" + + try: + _options = webdriver.ChromeOptions() + _options.add_argument("--headless") + _options.add_argument("--no-sandbox") + _options.add_argument("--disable-gpu") + # _options.add_argument("--disable-dev-shm-usage") + _options.add_argument("--ignore-certificate-errors") + _options.add_argument( + f"--unsafely-treat-insecure-origin-as-secure={self.web_url}" + ) + _options.add_argument( + f"--window-size={self._VIEWPORT_WIDTH},{self._VIEWPORT_HEIGHT}" + ) + + self.driver = webdriver.Chrome(options=_options) + self.driver.get(str(self.web_url)) + _wait = WebDriverWait(self.driver, 15) + + ## Ensure the page has fully loaded + _wait.until( + EC.presence_of_element_located( + (By.CSS_SELECTOR, 'input[placeholder="Username"]') + ) + ) + + except WebDriverException as err: + logger.error(f"WebDriver setup failed: {err}") + raise + + return + + def get_local_storage_data(self) -> Union[str, None]: + """ + Get local storage data. + + Returns: + Union[str, None]: Data + """ + + try: + _data = self.driver.execute_script( + "return window.localStorage.getItem('data');" + ) + if not _data: + return None + + return _data + except Exception as err: + logger.error(f"Failed to get local storage: {err}") + return None + + def cleanup(self) -> None: + """Cleanup resources.""" + + if self.driver: + self.driver.delete_all_cookies() + self.driver.execute_script("window.localStorage.clear();") + self.driver.quit() + + return + + def __call__(self) -> Union[str, None]: + """ + Run automation process with given URL. + + Args: + web_url (str, optional): URL to automate. + + Returns: + Union[str, None]: Data + """ + + if not self.web_url: + raise RuntimeError("Web URL is empty, cannot proceed!") + + try: + self.setup_driver() + + if not run_bot(driver=self.driver): + return None + + time.sleep(3) + _data = self.get_local_storage_data() + if not _data: + return None + + return + + except Exception as err: + logger.error(f"Automation failed: {err}") + return None + finally: + self.cleanup() + + +__all__ = ["WebUIAutomate"] diff --git a/src/bot/src/main.py b/src/bot/src/main.py new file mode 100644 index 0000000..3f52f49 --- /dev/null +++ b/src/bot/src/main.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +## Standard libraries +import os +import sys +import logging +import subprocess + +import requests + +## Internal modules +from constants import Config +from driver import WebUIAutomate +logger = logging.getLogger(__name__) + + +def check_internet(url: str = "https://www.google.com", timeout: float = 3.0) -> bool: + try: + response = requests.head(url, timeout=timeout, allow_redirects=True) + return response.ok + except requests.RequestException as err: + logger.warning(f"Internet check failed for {url}: {err}") + return False + + +def main() -> None: + logging.basicConfig( + stream=sys.stdout, + level=logging.INFO, + datefmt="%Y-%m-%d %H:%M:%S %z", + format="[%(asctime)s | %(levelname)s | %(filename)s:%(lineno)d]: %(message)s", + ) + + logger.info("Starting WebUI automation bot...") + + # Get web URL from environment variable + try: + container_config = Config() + _web_url = container_config.WEB_URL + except Exception as e: + logger.error(f"Failed to load config: {e}") + logger.info("Falling back to environment variables directly...") + _web_url = os.getenv("BV_WEB_URL") + + if not _web_url: + # Fallback: try to get host gateway IP + _command = "ip route | awk '/default/ { print $3 }'" + try: + _host = subprocess.check_output(_command, shell=True, text=True).strip() + except Exception: + _host = "challenge-api" + _web_url = f"http://{_host}:10001/_web" + logger.warning(f"BV_WEB_URL not set, using fallback: {_web_url}") + + logger.info(f"Challenge web URL: {_web_url}") + + if check_internet(): + logger.info("Internet check: OK (https://www.google.com reachable)") + else: + logger.warning("Internet check: FAILED (no HTTPS egress from container)") + + # Get session count + try: + _session_count = container_config.SESSION_COUNT + except Exception: + _session_count = int(os.getenv("BV_SESSION_COUNT", "2")) + + logger.info(f"Running {_session_count} session(s)") + + for _ in range(int(_session_count) if _session_count else 2): + _webui_automate = WebUIAutomate(web_url=_web_url) + _webui_automate() + + logger.info("Done!\n") + return + + +if __name__ == "__main__": + main() From 297166223231923d173cb2c280015c9a095f54b5 Mon Sep 17 00:00:00 2001 From: abdibekbolot Date: Wed, 17 Jun 2026 08:17:37 +0900 Subject: [PATCH 05/40] feat(infra): add bot-runner service with hardened networking Add bot-runner service that runs the WebUI automation bot container with Docker socket access and privileged mode. Introduce two bridge networks: bot-virus-challenge-net (external) and bot-executor-net (internal, isolated). Harden existing challenge service with explicit linux/amd64 platform, privileged mode, and nofile ulimit (32768). Add named volumes for bot-runner logs and data persistence. --- compose.yml | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/compose.yml b/compose.yml index 4d997da..562ba30 100644 --- a/compose.yml +++ b/compose.yml @@ -3,7 +3,16 @@ services: image: redteamsubnet61/rest-bv-challenge:0.0.0 build: context: ./src/bv_challenge/challenge + platforms: + - linux/amd64 restart: unless-stopped + networks: + - bot-virus-challenge-net + - bot-executor-net + platform: linux/amd64 + privileged: true + ulimits: + nofile: 32768 environment: TERM: ${TERM:-xterm} TZ: ${TZ:-Asia/Seoul} @@ -18,3 +27,45 @@ services: ports: - "${BV_CHALLENGE_API_PORT:-10001}:${BV_CHALLENGE_API_PORT:-10001}" tty: true + + bot-runner: + image: redteamsubnet61/bot_virus_bot_runner:latest + build: + context: ./src/modules/rest.mdm-sn-container-runner + platforms: + - linux/amd64 + restart: unless-stopped + networks: + - bot-virus-challenge-net + - bot-executor-net + privileged: true + user: "0:0" + environment: + TERM: ${TERM:-xterm} + TZ: ${TZ:-UTC} + VM_RUNNER_API_PORT: ${VM_RUNNER_API_PORT:-8000} + env_file: + - path: .env + required: false + volumes: + - "bot-runner-logs:${VM_RUNNER_API_LOGS_DIR:-/var/log/rest.vm-runner}" + - "bot-runner-data:${VM_RUNNER_API_DATA_DIR:-/var/lib/rest.vm-runner}" + - "/var/run/docker.sock:/var/run/docker.sock" + ports: + - "${VM_RUNNER_API_PORT:-8000}:${VM_RUNNER_API_PORT:-8000}" + tty: true + +networks: + bot-virus-challenge-net: + name: bot-virus-challenge-net + driver: bridge + driver_opts: + com.docker.network.driver.mtu: 1400 + bot-executor-net: + name: bot-executor-net + driver: bridge + internal: true + +volumes: + bot-runner-logs: + bot-runner-data: From 48354c0eece33bb5a0522045338cc3aa60a4819c Mon Sep 17 00:00:00 2001 From: abdibekbolot Date: Wed, 17 Jun 2026 10:30:21 +0900 Subject: [PATCH 06/40] chore: pin bot-virus runner adaptation --- src/modules/rest.mdm-sn-container-runner | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/modules/rest.mdm-sn-container-runner b/src/modules/rest.mdm-sn-container-runner index d7fb3a0..2191184 160000 --- a/src/modules/rest.mdm-sn-container-runner +++ b/src/modules/rest.mdm-sn-container-runner @@ -1 +1 @@ -Subproject commit d7fb3a063a5f24c3f4c5afa4786a4d623eaff93d +Subproject commit 219118407758c5452ec67d039812463b3885ed46 From c44277c3f251bf2d810c61821a16df68d4911342 Mon Sep 17 00:00:00 2001 From: abdibekbolot Date: Wed, 17 Jun 2026 14:35:47 +0900 Subject: [PATCH 07/40] feat(api): port humanize challenge API to bot-virus --- compose.yml | 3 + src/bv_challenge/challenge/Dockerfile | 2 + src/bv_challenge/challenge/api/__init__.py | 3 + src/bv_challenge/challenge/api/__main__.py | 23 +- src/bv_challenge/challenge/api/__version__.py | 2 +- src/bv_challenge/challenge/api/bootstrap.py | 51 +- src/bv_challenge/challenge/api/config.py | 54 +- .../challenge/api/configs/api.yml | 18 + .../challenge/api/configs/challenge.yml | 47 ++ .../challenge/api/configs/docs.yml | 15 + .../challenge/api/configs/logger.yml | 52 ++ .../challenge/api/configs/paths.yml | 8 + .../challenge/api/configs/security.yml | 25 + .../challenge/api/core/configs/__init__.py | 2 +- .../challenge/api/core/configs/_api.py | 194 +++--- .../challenge/api/core/configs/_base.py | 61 +- .../challenge/api/core/configs/_challenge.py | 45 ++ .../challenge/api/core/configs/_dev.py | 37 ++ .../challenge/api/core/configs/_docs.py | 115 ++-- .../challenge/api/core/configs/_logger.py | 42 -- .../challenge/api/core/configs/_main.py | 115 +++- .../challenge/api/core/configs/_paths.py | 71 +- .../challenge/api/core/configs/_security.py | 128 ++-- .../challenge/api/core/configs/_uvicorn.py | 53 -- .../challenge/api/core/constants/__init__.py | 2 +- .../challenge/api/core/constants/_base.py | 60 +- .../api/core/constants/_error_code.py | 16 +- .../challenge/api/core/constants/_regex.py | 48 +- .../api/core/dependencies/__init__.py | 1 + .../challenge/api/core/dependencies/auth.py | 53 +- .../challenge/api/core/exceptions/__init__.py | 2 +- .../challenge/api/core/exceptions/_base.py | 38 +- .../challenge/api/core/handlers/__init__.py | 2 +- .../api/core/handlers/_http_exception.py | 29 +- .../api/core/handlers/_method_not_allowed.py | 8 +- .../challenge/api/core/handlers/_not_found.py | 13 +- .../api/core/handlers/_server_error.py | 21 +- .../api/core/handlers/_validation_error.py | 10 +- .../api/core/middlewares/__init__.py | 2 +- .../api/core/middlewares/_process_time.py | 4 +- .../api/core/middlewares/_request_id.py | 8 +- .../challenge/api/core/models/__init__.py | 1 + .../challenge/api/core/responses/__init__.py | 2 +- .../challenge/api/core/responses/_base.py | 70 +- .../challenge/api/core/routers/__init__.py | 1 + .../challenge/api/core/routers/default.py | 4 + .../challenge/api/core/routers/utils.py | 29 +- .../challenge/api/core/schemas/__init__.py | 2 +- .../challenge/api/core/schemas/_base.py | 17 +- .../api/core/schemas/_error_responses.py | 22 +- .../challenge/api/core/schemas/_responses.py | 89 ++- .../challenge/api/core/services/__init__.py | 1 + .../challenge/api/core/utils/__init__.py | 8 +- .../challenge/api/core/utils/_base.py | 127 +++- .../challenge/api/core/utils/_dt.py | 245 +++++++ .../challenge/api/core/utils/_http.py | 128 ++++ .../challenge/api/core/utils/_io.py | 461 +++++++++++++ .../challenge/api/core/utils/_sanitizer.py | 86 +++ .../challenge/api/core/utils/_secure.py | 75 +++ .../challenge/api/core/utils/_validator.py | 152 +++++ .../challenge/api/databases/__init__.py | 0 .../api/endpoints/challenge/__init__.py | 0 .../api/endpoints/challenge/router.py | 180 ++++- .../api/endpoints/challenge/schemas.py | 182 ++++- .../api/endpoints/challenge/service.py | 333 +++++++++- .../api/endpoints/challenge/utils.py | 215 ++++++ src/bv_challenge/challenge/api/exception.py | 4 +- .../challenge/api/helpers/__init__.py | 1 + .../challenge/api/helpers/crypto/__init__.py | 1 + .../api/helpers/crypto/asymmetric.py | 626 ++++++++++++++++++ .../challenge/api/helpers/crypto/ssl.py | 301 +++++++++ .../challenge/api/helpers/crypto/symmetric.py | 87 +++ src/bv_challenge/challenge/api/lifespan.py | 51 +- src/bv_challenge/challenge/api/logger.py | 121 +++- src/bv_challenge/challenge/api/main.py | 24 +- src/bv_challenge/challenge/api/middleware.py | 23 +- src/bv_challenge/challenge/api/mount.py | 15 +- src/bv_challenge/challenge/api/router.py | 8 +- .../challenge/api/static/css/.gitkeep | 0 .../challenge/api/static/fonts/.gitkeep | 0 .../challenge/api/static/images/favicon.ico | Bin 15406 -> 0 bytes .../challenge/api/static/index.html | 0 .../challenge/api/static/js/.gitkeep | 0 .../challenge/api/static/media/.gitkeep | 0 .../challenge/api/templates/html/.gitkeep | 0 .../challenge/api/templates/mail/.gitkeep | 0 src/bv_challenge/challenge/requirements.txt | 20 +- ...0.1.0-cp310-abi3-manylinux_2_34_x86_64.whl | Bin 0 -> 3076190 bytes .../templates/html/asset-manifest.json | 11 + .../challenge/templates/html/index.html | 1 + .../challenge/templates/html/robots.txt | 3 + .../html/static/css/main.963c38ad.css | 1 + .../templates/html/static/js/main.b9668575.js | 2 + .../static/js/main.b9668575.js.LICENSE.txt | 39 ++ 94 files changed, 4370 insertions(+), 882 deletions(-) create mode 100644 src/bv_challenge/challenge/api/configs/api.yml create mode 100644 src/bv_challenge/challenge/api/configs/challenge.yml create mode 100644 src/bv_challenge/challenge/api/configs/docs.yml create mode 100644 src/bv_challenge/challenge/api/configs/logger.yml create mode 100644 src/bv_challenge/challenge/api/configs/paths.yml create mode 100644 src/bv_challenge/challenge/api/configs/security.yml create mode 100644 src/bv_challenge/challenge/api/core/configs/_challenge.py create mode 100644 src/bv_challenge/challenge/api/core/configs/_dev.py delete mode 100644 src/bv_challenge/challenge/api/core/configs/_logger.py delete mode 100644 src/bv_challenge/challenge/api/core/configs/_uvicorn.py create mode 100644 src/bv_challenge/challenge/api/core/utils/_dt.py create mode 100644 src/bv_challenge/challenge/api/core/utils/_http.py create mode 100644 src/bv_challenge/challenge/api/core/utils/_io.py create mode 100644 src/bv_challenge/challenge/api/core/utils/_sanitizer.py create mode 100644 src/bv_challenge/challenge/api/core/utils/_secure.py create mode 100644 src/bv_challenge/challenge/api/core/utils/_validator.py delete mode 100644 src/bv_challenge/challenge/api/databases/__init__.py delete mode 100644 src/bv_challenge/challenge/api/endpoints/challenge/__init__.py create mode 100644 src/bv_challenge/challenge/api/endpoints/challenge/utils.py create mode 100644 src/bv_challenge/challenge/api/helpers/crypto/__init__.py create mode 100644 src/bv_challenge/challenge/api/helpers/crypto/asymmetric.py create mode 100644 src/bv_challenge/challenge/api/helpers/crypto/ssl.py create mode 100644 src/bv_challenge/challenge/api/helpers/crypto/symmetric.py delete mode 100644 src/bv_challenge/challenge/api/static/css/.gitkeep delete mode 100644 src/bv_challenge/challenge/api/static/fonts/.gitkeep delete mode 100644 src/bv_challenge/challenge/api/static/images/favicon.ico delete mode 100644 src/bv_challenge/challenge/api/static/index.html delete mode 100644 src/bv_challenge/challenge/api/static/js/.gitkeep delete mode 100644 src/bv_challenge/challenge/api/static/media/.gitkeep delete mode 100644 src/bv_challenge/challenge/api/templates/html/.gitkeep delete mode 100644 src/bv_challenge/challenge/api/templates/mail/.gitkeep create mode 100644 src/bv_challenge/challenge/requirements/vault_unlock-0.1.0-cp310-abi3-manylinux_2_34_x86_64.whl create mode 100644 src/bv_challenge/challenge/templates/html/asset-manifest.json create mode 100644 src/bv_challenge/challenge/templates/html/index.html create mode 100644 src/bv_challenge/challenge/templates/html/robots.txt create mode 100644 src/bv_challenge/challenge/templates/html/static/css/main.963c38ad.css create mode 100644 src/bv_challenge/challenge/templates/html/static/js/main.b9668575.js create mode 100644 src/bv_challenge/challenge/templates/html/static/js/main.b9668575.js.LICENSE.txt diff --git a/compose.yml b/compose.yml index 562ba30..bd843a0 100644 --- a/compose.yml +++ b/compose.yml @@ -17,6 +17,9 @@ services: TERM: ${TERM:-xterm} TZ: ${TZ:-Asia/Seoul} BV_CHALLENGE_API_PORT: ${BV_CHALLENGE_API_PORT:-10001} + BV_CHALLENGE_API_BOT_RUNNER__URL: ${BV_CHALLENGE_API_BOT_RUNNER__URL:-http://bot-runner:8000} + BV_CHALLENGE_API_BOT_RUNNER__SESSION_COUNT: ${BV_CHALLENGE_API_BOT_RUNNER__SESSION_COUNT:-2} + BV_CHALLENGE_API_BOT_RUNNER__REQUEST_TIMEOUT_SEC: ${BV_CHALLENGE_API_BOT_RUNNER__REQUEST_TIMEOUT_SEC:-900} env_file: - path: .env required: false diff --git a/src/bv_challenge/challenge/Dockerfile b/src/bv_challenge/challenge/Dockerfile index c61f2c4..8018397 100644 --- a/src/bv_challenge/challenge/Dockerfile +++ b/src/bv_challenge/challenge/Dockerfile @@ -29,6 +29,7 @@ RUN --mount=type=cache,target=/root/.cache,sharing=locked \ # COPY ./requirements* ./ RUN --mount=type=cache,target=/root/.cache,sharing=locked \ --mount=type=bind,source=requirements.txt,target=requirements.txt \ + --mount=type=bind,source=requirements,target=requirements \ python3 -m uv pip install --prefix=/install -r ./requirements.txt @@ -140,6 +141,7 @@ FROM base AS app WORKDIR "${BV_CHALLENGE_API_DIR}" COPY --chown=${UID}:${GID} ./api ${BV_CHALLENGE_API_DIR}/api +COPY --chown=${UID}:${GID} ./templates ${BV_CHALLENGE_API_DIR}/templates COPY --chown=${UID}:${GID} --chmod=770 ./scripts/*.sh /usr/local/bin/ # VOLUME ["${BV_CHALLENGE_API_DATA_DIR}"] diff --git a/src/bv_challenge/challenge/api/__init__.py b/src/bv_challenge/challenge/api/__init__.py index 29c6809..5d91ce4 100644 --- a/src/bv_challenge/challenge/api/__init__.py +++ b/src/bv_challenge/challenge/api/__init__.py @@ -1,3 +1,6 @@ +# -*- coding: utf-8 -*- + from api.__version__ import __version__ + __all__ = ["__version__"] diff --git a/src/bv_challenge/challenge/api/__main__.py b/src/bv_challenge/challenge/api/__main__.py index 4b0807c..4b27dc0 100644 --- a/src/bv_challenge/challenge/api/__main__.py +++ b/src/bv_challenge/challenge/api/__main__.py @@ -1,6 +1,25 @@ +# -*- coding: utf-8 -*- + +## Third-party libraries +from fastapi import FastAPI + +## Internal modules +from api.bootstrap import create_app, run_server from api.logger import logger -from api.main import main + + +app: FastAPI = create_app() + + +def main() -> None: + """Main function.""" + + run_server(app="api.__main__:app") + return + if __name__ == "__main__": - logger.info("Starting server from '__main__.py'...") + logger.info(f"Starting server from '__main__.py'...") main() + +__all__ = ["app"] diff --git a/src/bv_challenge/challenge/api/__version__.py b/src/bv_challenge/challenge/api/__version__.py index 6c8e6b9..a0235ce 100644 --- a/src/bv_challenge/challenge/api/__version__.py +++ b/src/bv_challenge/challenge/api/__version__.py @@ -1 +1 @@ -__version__ = "0.0.0" +__version__ = "0.0.2" \ No newline at end of file diff --git a/src/bv_challenge/challenge/api/bootstrap.py b/src/bv_challenge/challenge/api/bootstrap.py index ec71d87..436e770 100644 --- a/src/bv_challenge/challenge/api/bootstrap.py +++ b/src/bv_challenge/challenge/api/bootstrap.py @@ -1,17 +1,16 @@ -# Standard libraries -from typing import Any -from collections.abc import Callable +# -*- coding: utf-8 -*- -# Third-party libraries +## Standard libraries +import os +from typing import Union + +## Third-party libraries import uvicorn from uvicorn._types import ASGIApplication from pydantic import validate_call from fastapi import FastAPI -from beans_logging_fastapi import add_logger - -# Internal modules -from api.__version__ import __version__ +## Internal modules from api.config import config from api.lifespan import lifespan, pre_init from api.middleware import add_middlewares @@ -31,19 +30,13 @@ def create_app() -> FastAPI: pre_init() app = FastAPI( - title=config.api.title, - version=__version__, + title=config.api.name, + version=config.version, lifespan=lifespan, default_response_class=BaseResponse, **config.api.docs.model_dump(exclude={"enabled"}), ) - add_logger( - app=app, - config=config.api.logger, - has_proxy_headers=config.api.uvicorn.proxy_headers, - ) - add_middlewares(app=app) add_routers(app=app) add_mounts(app=app) @@ -53,21 +46,35 @@ def create_app() -> FastAPI: @validate_call(config={"arbitrary_types_allowed": True}) -def run_server(app: FastAPI | ASGIApplication | Callable[..., Any] | str) -> None: +def run_server(app: Union[ASGIApplication, str] = "main:app") -> None: """Run uvicorn server. Args: - app (FastAPI | - ASGIApplication | - Callable[..., Any] | - str , required): FastAPI application instance or ASGI application or import string. + app (Union[ASGIApplication, str], optional): ASGI application instance or module path. """ + _ssl_keyfile: Union[str, None] = None + _ssl_certfile: Union[str, None] = None + + if config.api.security.ssl.enabled: + _ssl_keyfile = os.path.join( + config.api.paths.ssl_dir, config.api.security.ssl.key_fname + ) + _ssl_certfile = os.path.join( + config.api.paths.ssl_dir, config.api.security.ssl.cert_fname + ) + uvicorn.run( app=app, host=config.api.bind_host, port=config.api.port, - **config.api.uvicorn.model_dump(), + access_log=False, + server_header=False, + proxy_headers=config.api.behind_proxy, + forwarded_allow_ips=config.api.security.forwarded_allow_ips, + ssl_keyfile=_ssl_keyfile, + ssl_certfile=_ssl_certfile, + **config.api.dev.model_dump(), ) return diff --git a/src/bv_challenge/challenge/api/config.py b/src/bv_challenge/challenge/api/config.py index 50e5cb6..c4045d4 100644 --- a/src/bv_challenge/challenge/api/config.py +++ b/src/bv_challenge/challenge/api/config.py @@ -1,46 +1,24 @@ -import os -from typing import TypeVar, Any +# -*- coding: utf-8 -*- -from pydantic import validate_call +import pathlib -from potato_util.io import read_all_configs +from onion_config import ConfigLoader +from beans_logging import logger -from api.core.constants import ENV_PREFIX_API, API_SLUG from api.core.configs import MainConfig -from api.logger import logger -ConfigType = TypeVar("ConfigType", bound=MainConfig) +config: MainConfig +try: + _parent_dir = pathlib.Path(__file__).parent.resolve() + _config_loader = ConfigLoader( + config_schema=MainConfig, configs_dirs=[str(_parent_dir / "configs")] + ) + # Main config object: + config: MainConfig = _config_loader.load() +except Exception: + logger.exception("Failed to load config:") + raise SystemExit(1) -@validate_call -def load_config( - configs_dir: str = os.path.join("/etc", API_SLUG), - env_name: str = f"{ENV_PREFIX_API}CONFIGS_DIR", - config_schema: type[ConfigType] = MainConfig, -) -> ConfigType: - _configs_dir_env = os.getenv(env_name, "") - if _configs_dir_env: - configs_dir = _configs_dir_env - _config_dict: dict[str, Any] = {} - if os.path.isdir(configs_dir): - _config_dict = read_all_configs(configs_dir=configs_dir) - - _config: ConfigType | None = None - try: - _config = config_schema(**_config_dict) - except Exception: - logger.exception("Failed to load config:") - raise SystemExit(1) - - return _config - - -config = load_config() - - -__all__ = [ - "MainConfig", - "load_config", - "config", -] +__all__ = ["config"] diff --git a/src/bv_challenge/challenge/api/configs/api.yml b/src/bv_challenge/challenge/api/configs/api.yml new file mode 100644 index 0000000..36b9eba --- /dev/null +++ b/src/bv_challenge/challenge/api/configs/api.yml @@ -0,0 +1,18 @@ +env: "LOCAL" +debug: false + +api: + name: "Bot Virus Challenge" + slug: "rest-bv-challenge" + bind_host: "0.0.0.0" + port: 10001 + version: "1" + prefix: "" + gzip_min_size: 1024 # Bytes (1KB) + behind_proxy: true + behind_cf_proxy: true + dev: + reload: false + reload_includes: [".env", "*.json", "*.yml", "*.yaml", "*.md"] + reload_excludes: + [".*", "~*", ".py[cod]", ".sw.*", "__pycache__", "*.log", "logs"] diff --git a/src/bv_challenge/challenge/api/configs/challenge.yml b/src/bv_challenge/challenge/api/configs/challenge.yml new file mode 100644 index 0000000..c575517 --- /dev/null +++ b/src/bv_challenge/challenge/api/configs/challenge.yml @@ -0,0 +1,47 @@ +challenge: + n_ch_per_epoch: 1 + n_run_per_ch: 10 + docker_ulimit: 32768 + allowed_pip_pkg_dt: "2025-01-01T00:00:00Z" + allowed_file_exts: [".py", ".json", ".yaml", ".yml", ".txt", ".pt"] + bot_timeout: 120 + window_width: 1420 + window_height: 740 + n_checkboxes: 5 + cb_min_distance: 300 + cb_gen_max_factor: 20 + cb_size: 50 + cb_exclude_areas: [{ "x1": 500, "y1": 400, "x2": 950, "y2": 700 }] + cb_pre_action_list: + [ + { + "id": 0, + "type": "click", + "args": { "location": { "x": 510, "y": 58 } }, + }, + { + "id": 1, + "type": "click", + "args": { "location": { "x": 1079, "y": 92 } }, + }, + { + "id": 2, + "type": "click", + "args": { "location": { "x": 288, "y": 449 } }, + }, + { + "id": 3, + "type": "click", + "args": { "location": { "x": 909, "y": 350 } }, + }, + { + "id": 4, + "type": "click", + "args": { "location": { "x": 1314, "y": 289 } }, + }, + ] + + # VM configuration for remote Docker build/run + vm_endpoint: "http://bot-runner:8000" + vm_timeout: 120 + vm_ssl_verify: false diff --git a/src/bv_challenge/challenge/api/configs/docs.yml b/src/bv_challenge/challenge/api/configs/docs.yml new file mode 100644 index 0000000..b7fe3a1 --- /dev/null +++ b/src/bv_challenge/challenge/api/configs/docs.yml @@ -0,0 +1,15 @@ +api: + docs: + enabled: true + openapi_url: "{api_prefix}/openapi.json" + docs_url: "{api_prefix}/docs" + redoc_url: "{api_prefix}/redoc" + swagger_ui_oauth2_redirect_url: "{api_prefix}/docs/oauth2-redirect" + summary: "This is the API documentation for the Bot Virus Challenge API." + openapi_tags: + - name: "Utils" + description: "Useful utility endpoints." + - name: "Challenge" + description: "Endpoints for challenge." + swagger_ui_parameters: + syntaxHighlight.theme: "nord" diff --git a/src/bv_challenge/challenge/api/configs/logger.yml b/src/bv_challenge/challenge/api/configs/logger.yml new file mode 100644 index 0000000..e74f4ee --- /dev/null +++ b/src/bv_challenge/challenge/api/configs/logger.yml @@ -0,0 +1,52 @@ +logger: + app_name: "{api_slug}" + level: "INFO" + use_diagnose: false + stream: + format_str: "[{time:YYYY-MM-DD HH:mm:ss.SSS Z} | {level_short:<5} | {name}:{line}]: {message}" + # format_str: "[{time:YYYY-MM-DD HH:mm:ss.SSS Z:!UTC} | {level_short:<5} | {name}:{line}]: {message}" + std_handler: + enabled: true + file: + logs_dir: "../logs" + rotate_size: 10000000 # 10MB + rotate_time: "00:00:00" + backup_count: 90 + log_handlers: + enabled: true + format_str: "[{time:YYYY-MM-DD HH:mm:ss.SSS Z} | {level_short:<5} | {name}:{line}]: {message}" + # format_str: "[{time:YYYY-MM-DD HH:mm:ss.SSS Z:!UTC} | {level_short:<5} | {name}:{line}]: {message}" + log_path: "{app_name}.std.all.log" + err_path: "{app_name}.std.err.log" + json_handlers: + enabled: true + use_custom: false + log_path: "json/{app_name}.json.all.log" + err_path: "json/{app_name}.json.err.log" + intercept: + auto_load: + enabled: true + only_base: false + ignore_modules: [] + include_modules: [] + mute_modules: [ + "uvicorn.access", + # "uvicorn.error", + "multipart", + "watchfiles", + "watchfiles.main", + "watchfiles.watcher", + ] + extra: + http_std_msg_format: '[{request_id}] {client_host} {user_id} "{method} {url_path} HTTP/{http_version}" {status_code} {content_length}B {response_time}ms' + http_std_error_format: '[{request_id}] {client_host} {user_id} "{method} {url_path} HTTP/{http_version}" {status_code}' + http_std_debug_format: '[{request_id}] {client_host} {user_id} "{method} {url_path} HTTP/{http_version}"' + http_file_enabled: true + http_file_format: '{client_host} {request_id} {user_id} [{datetime}] "{method} {url_path} HTTP/{http_version}" {status_code} {content_length} "{h_referer}" "{h_user_agent}" {response_time}' + http_file_tz: "localtime" + # http_file_tz: "UTC" + http_log_path: "http/{app_name}.http.access.log" + http_err_path: "http/{app_name}.http.err.log" + http_json_enabled: true + http_json_path: "json.http/{app_name}.json.http.access.log" + http_json_err_path: "json.http/{app_name}.json.http.err.log" diff --git a/src/bv_challenge/challenge/api/configs/paths.yml b/src/bv_challenge/challenge/api/configs/paths.yml new file mode 100644 index 0000000..ea8c232 --- /dev/null +++ b/src/bv_challenge/challenge/api/configs/paths.yml @@ -0,0 +1,8 @@ +api: + paths: + tmp_dir: "../tmp" + uploads_dir: "{tmp_dir}/uploads" + data_dir: "../data" + security_dir: "{data_dir}/security" + ssl_dir: "{data_dir}/security/ssl" + asymmetric_keys_dir: "{data_dir}/security/asymmetric_keys" diff --git a/src/bv_challenge/challenge/api/configs/security.yml b/src/bv_challenge/challenge/api/configs/security.yml new file mode 100644 index 0000000..57c6f72 --- /dev/null +++ b/src/bv_challenge/challenge/api/configs/security.yml @@ -0,0 +1,25 @@ +api: + security: + allowed_hosts: ["*"] + forwarded_allow_ips: ["*"] + cors: + allow_origins: ["*"] + allow_origin_regex: null + allow_headers: ["*"] + allow_methods: + ["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS", "CONNECT"] + allow_credentials: false + expose_headers: [] + max_age: 600 # Seconds (10 minutes) + ssl: + enabled: false + generate: false + key_size: 2048 + key_fname: "key.pem" + cert_fname: "cert.pem" + asymmetric: + generate: false + algorithm: "RS256" + key_size: 2048 + private_key_fname: "private_key.pem" + public_key_fname: "public_key.pem" diff --git a/src/bv_challenge/challenge/api/core/configs/__init__.py b/src/bv_challenge/challenge/api/core/configs/__init__.py index 1c79b70..52c8168 100644 --- a/src/bv_challenge/challenge/api/core/configs/__init__.py +++ b/src/bv_challenge/challenge/api/core/configs/__init__.py @@ -1,4 +1,4 @@ -# flake8: noqa +# -*- coding: utf-8 -*- from ._base import * from ._main import * diff --git a/src/bv_challenge/challenge/api/core/configs/_api.py b/src/bv_challenge/challenge/api/core/configs/_api.py index 330dc39..03bab1d 100644 --- a/src/bv_challenge/challenge/api/core/configs/_api.py +++ b/src/bv_challenge/challenge/api/core/configs/_api.py @@ -1,148 +1,142 @@ +# -*- coding: utf-8 -*- + import sys -from typing import Any +from typing import Any, Dict -from pydantic import Field, field_validator, ValidationInfo, model_validator +from pydantic import Field, constr, field_validator, ValidationInfo, model_validator from pydantic_settings import SettingsConfigDict -from potato_util.constants import HTTPSchemeEnum - -from api.core.constants import ENV_PREFIX_API, API_SLUG -from api.core import utils - -from ._base import BaseConfig, FrozenBaseConfig -from ._uvicorn import UvicornConfig +from api.core.constants import ENV_PREFIX_API, HTTPSchemeEnum +from ._base import BaseConfig +from ._dev import DevConfig from ._security import SecurityConfig from ._docs import DocsConfig, FrozenDocsConfig from ._paths import PathsConfig, FrozenPathsConfig -from ._logger import LoggerConfigPM, FrozenLoggerConfigPM - - -class GZipConfig(FrozenBaseConfig): - minimum_size: int = Field(default=1024, ge=0, le=10_485_760) - compresslevel: int = Field(default=9, ge=1, le=9) - - model_config = SettingsConfigDict(env_prefix=f"{ENV_PREFIX_API}GZIP_") class ApiConfig(BaseConfig): - title: str = Field( - default="Bot Virus Challenge", min_length=2, max_length=128 - ) - slug: str = Field(default=API_SLUG, min_length=2, max_length=128) + name: constr(strip_whitespace=True) = Field(..., min_length=2, max_length=128) # type: ignore + slug: constr(strip_whitespace=True) = Field(..., min_length=2, max_length=128) # type: ignore http_scheme: HTTPSchemeEnum = Field(default=HTTPSchemeEnum.http) - bind_host: str = Field( - default="0.0.0.0", min_length=2, max_length=128 # nosec B104 - ) - port: int = Field(default=10001, ge=80, lt=65536) - version: str = Field(default="1", min_length=1, max_length=16) - prefix: str = Field(default="", max_length=128) - gzip: GZipConfig = Field(default_factory=GZipConfig) - uvicorn: UvicornConfig = Field(default_factory=UvicornConfig) - security: SecurityConfig = Field(default_factory=SecurityConfig) - docs: DocsConfig = Field(default_factory=DocsConfig) - paths: PathsConfig = Field(default_factory=PathsConfig) - logger: LoggerConfigPM = Field(default_factory=LoggerConfigPM) - - @field_validator("prefix", mode="after") + bind_host: constr(strip_whitespace=True) = Field(..., min_length=2, max_length=128) # type: ignore + port: int = Field(..., ge=80, lt=65536) + version: constr(strip_whitespace=True) = Field(..., min_length=1, max_length=16) # type: ignore + prefix: constr(strip_whitespace=True) = Field(..., max_length=128) # type: ignore + gzip_min_size: int = Field(..., ge=0, le=10_485_760) # 512 bytes + behind_proxy: bool = Field(...) + behind_cf_proxy: bool = Field(...) + dev: DevConfig = Field(...) + security: SecurityConfig = Field(...) + docs: DocsConfig = Field(...) + paths: PathsConfig = Field(...) + + @field_validator("slug") @classmethod - def _check_prefix(cls, val: str, info: ValidationInfo) -> str: - if ("version" in info.data) and val and ("{api_version}" in val): - val = val.format(api_version=info.data["version"]) + def _check_slug(cls, val: str, info: ValidationInfo) -> str: + if (not val) and ("name" in info.data): + val = ( + info.data["name"] + .lower() + .strip() + .replace(" ", "-") + .replace("_", "-") + .replace(".", "-") + ) return val - @field_validator("security", mode="after") + @field_validator("prefix") @classmethod - def _check_security( - cls, val: SecurityConfig, info: ValidationInfo - ) -> SecurityConfig: - if (not utils.is_running_bin()) and val.ssl.enabled: - info.data["http_scheme"] = HTTPSchemeEnum.https + def _check_prefix(cls, val: str, info: ValidationInfo) -> str: + if val and ("{api_version}" in val) and ("version" in info.data): + val = val.format(api_version=info.data["version"]) return val - @field_validator("docs", mode="after") + @field_validator("docs") @classmethod def _check_docs(cls, val: DocsConfig, info: ValidationInfo) -> DocsConfig: - _docs_dict = val.model_dump() - if ("prefix" in info.data) and val.enabled: - for _key, _doc in _docs_dict.items(): - if ( - isinstance(_doc, str) - and _key.endswith("url") - and ("{api_prefix}" in _doc) - ): - _docs_dict[_key] = _doc.format(api_prefix=info.data["prefix"]) - - val = FrozenDocsConfig(**_docs_dict) + if val.enabled and ("prefix" in info.data): + if val.openapi_url and ("{api_prefix}" in val.openapi_url): + val.openapi_url = val.openapi_url.format(api_prefix=info.data["prefix"]) + + if val.docs_url and ("{api_prefix}" in val.docs_url): + val.docs_url = val.docs_url.format(api_prefix=info.data["prefix"]) + + if val.redoc_url and ("{api_prefix}" in val.redoc_url): + val.redoc_url = val.redoc_url.format(api_prefix=info.data["prefix"]) + + if val.swagger_ui_oauth2_redirect_url and ( + "{api_prefix}" in val.swagger_ui_oauth2_redirect_url + ): + val.swagger_ui_oauth2_redirect_url = ( + val.swagger_ui_oauth2_redirect_url.format( + api_prefix=info.data["prefix"] + ) + ) + + val = FrozenDocsConfig(**val.model_dump()) return val - @field_validator("paths", mode="after") + @field_validator("paths") @classmethod def _check_paths(cls, val: PathsConfig, info: ValidationInfo) -> FrozenPathsConfig: - _paths_dict = val.model_dump() if "slug" in info.data: - for _key, _path in _paths_dict.items(): - if isinstance(_path, str) and ("{api_slug}" in _path): - _paths_dict[_key] = _path.format(api_slug=info.data["slug"]) + if "{api_slug}" in val.tmp_dir: + val.tmp_dir = val.tmp_dir.format(api_slug=info.data["slug"]) - val = FrozenPathsConfig(**_paths_dict) - return val + if "{api_slug}" in val.uploads_dir: + val.uploads_dir = val.uploads_dir.format(api_slug=info.data["slug"]) + elif "{tmp_dir}" in val.uploads_dir: + val.uploads_dir = val.uploads_dir.format(tmp_dir=val.tmp_dir) - @field_validator("logger", mode="after") - @classmethod - def _check_logger(cls, val: LoggerConfigPM, info: ValidationInfo) -> LoggerConfigPM: - if "slug" in info.data: - if "{api_slug}" in val.app_name: - val.app_name = val.app_name.format(api_slug=info.data["slug"]) - - if "{api_slug}" in val.file.logs_dir: - val.file.logs_dir = val.file.logs_dir.format(api_slug=info.data["slug"]) + if "{api_slug}" in val.data_dir: + val.data_dir = val.data_dir.format(api_slug=info.data["slug"]) - val = FrozenLoggerConfigPM(**val.model_dump()) + val = FrozenPathsConfig(**val.model_dump()) return val - model_config = SettingsConfigDict(env_prefix=ENV_PREFIX_API) - - -class FrozenApiConfig(ApiConfig): @model_validator(mode="before") @classmethod - def _check_args(cls, data: Any) -> Any: - if isinstance(data, dict) and utils.is_running_bin(): - _has_host_arg = False + def _check_args(cls, values: Dict[str, Any]) -> Dict[str, Any]: + if ( + sys.argv[0].endswith("uvicorn") + or sys.argv[0].endswith("fastapi") + or sys.argv[0].endswith("gunicorn") + ): + _has_host = False for _i, _arg in enumerate(sys.argv): - if ( - _arg.startswith("--ssl") - or _arg.startswith("--keyfile") - or _arg.startswith("--certfile") - ): - data["http_scheme"] = HTTPSchemeEnum.https + if _arg.startswith("--ssl"): + values["http_scheme"] = HTTPSchemeEnum.https if _arg.startswith("--host="): - _has_host_arg = True - data["bind_host"] = _arg.split("=")[1] + _has_host = True + values["bind_host"] = _arg.split("=")[1] elif (_arg == "--host") and (_i + 1 < len(sys.argv)): - _has_host_arg = True - data["bind_host"] = sys.argv[_i + 1] + _has_host = True + values["bind_host"] = sys.argv[_i + 1] if _arg.startswith("--port="): - data["port"] = int(_arg.split("=")[1]) + values["port"] = int(_arg.split("=")[1]) elif (_arg == "--port") and (_i + 1 < len(sys.argv)): - data["port"] = int(sys.argv[_i + 1]) + values["port"] = int(sys.argv[_i + 1]) - if not _has_host_arg: - data["bind_host"] = "127.0.0.1" + if not _has_host: + values["bind_host"] = "127.0.0.1" if sys.argv[0].endswith("fastapi") and sys.argv[1] == "run": - data["bind_host"] = "0.0.0.0" # nosec B104 + values["bind_host"] = "0.0.0.0" - return data + elif values["security"]["ssl"]["enabled"]: + values["http_scheme"] = HTTPSchemeEnum.https + return values + + model_config = SettingsConfigDict(env_prefix=ENV_PREFIX_API) + + +class FrozenApiConfig(ApiConfig): model_config = SettingsConfigDict(frozen=True) -__all__ = [ - "ApiConfig", - "FrozenApiConfig", -] +__all__ = ["ApiConfig", "FrozenApiConfig"] diff --git a/src/bv_challenge/challenge/api/core/configs/_base.py b/src/bv_challenge/challenge/api/core/configs/_base.py index ed31b1f..cb9fb83 100644 --- a/src/bv_challenge/challenge/api/core/configs/_base.py +++ b/src/bv_challenge/challenge/api/core/configs/_base.py @@ -1,70 +1,31 @@ +# -*- coding: utf-8 -*- + +from typing import Type, Tuple + from pydantic_settings import ( BaseSettings, SettingsConfigDict, PydanticBaseSettingsSource, - CliSettingsSource, - NestedSecretsSettingsSource, ) -from api.core import utils - class BaseConfig(BaseSettings): - model_config = SettingsConfigDict( - extra="allow", - env_file=".env", - validate_default=True, - validate_assignment=True, - arbitrary_types_allowed=True, - ) - - -class FrozenBaseConfig(BaseConfig): - model_config = SettingsConfigDict(frozen=True) + model_config = SettingsConfigDict(extra="allow", arbitrary_types_allowed=True) @classmethod def settings_customise_sources( cls, - settings_cls: type[BaseSettings], + settings_cls: Type[BaseSettings], init_settings: PydanticBaseSettingsSource, env_settings: PydanticBaseSettingsSource, dotenv_settings: PydanticBaseSettingsSource, file_secret_settings: PydanticBaseSettingsSource, - ) -> tuple[PydanticBaseSettingsSource, ...]: - return ( - NestedSecretsSettingsSource(file_secret_settings), - dotenv_settings, - env_settings, - init_settings, - ) + ) -> Tuple[PydanticBaseSettingsSource, ...]: + return dotenv_settings, env_settings, init_settings, file_secret_settings -class BaseMainConfig(FrozenBaseConfig): - @classmethod - def settings_customise_sources( - cls, - settings_cls: type[BaseSettings], - init_settings: PydanticBaseSettingsSource, - env_settings: PydanticBaseSettingsSource, - dotenv_settings: PydanticBaseSettingsSource, - file_secret_settings: PydanticBaseSettingsSource, - ) -> tuple[PydanticBaseSettingsSource, ...]: - _sources = [] - if not utils.is_running_bin(): - _sources.append(CliSettingsSource(settings_cls, cli_parse_args=True)) - _sources.extend( - [ - NestedSecretsSettingsSource(file_secret_settings), - dotenv_settings, - env_settings, - init_settings, - ] - ) - return tuple(_sources) +class FrozenBaseConfig(BaseConfig): + model_config = SettingsConfigDict(frozen=True) -__all__ = [ - "BaseConfig", - "FrozenBaseConfig", - "BaseMainConfig", -] +__all__ = ["BaseConfig", "FrozenBaseConfig"] diff --git a/src/bv_challenge/challenge/api/core/configs/_challenge.py b/src/bv_challenge/challenge/api/core/configs/_challenge.py new file mode 100644 index 0000000..4b5d403 --- /dev/null +++ b/src/bv_challenge/challenge/api/core/configs/_challenge.py @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- + +from datetime import datetime +from typing import List, Optional, Dict, Union + +from pydantic import Field, constr +from pydantic_settings import SettingsConfigDict + +from api.core.constants import ALPHANUM_HOST_REGEX, ENV_PREFIX +from ._base import FrozenBaseConfig + + +class ChallengeConfig(FrozenBaseConfig): + n_ch_per_epoch: int = Field(...) + n_run_per_ch: int = Field(...) + docker_ulimit: int = Field(...) + allowed_pip_pkg_dt: datetime = Field(...) + allowed_file_exts: List[ + constr( + strip_whitespace=True, + min_length=2, + max_length=16, + pattern=ALPHANUM_HOST_REGEX, + ) # type: ignore + ] = Field(..., min_length=1) + bot_timeout: int = Field(..., ge=1) + window_width: int = Field(..., ge=20, le=12000) + window_height: int = Field(..., ge=20, le=12000) + n_checkboxes: int = Field(..., ge=2, le=100) + cb_min_distance: int = Field(..., ge=1, le=1000) + cb_gen_max_factor: int = Field(..., ge=2, le=100) + cb_size: int = Field(..., ge=10, le=100) + cb_exclude_areas: Optional[List[Dict[str, int]]] = Field(default=None) + cb_pre_action_list: Optional[ + List[Dict[str, Union[int, str, Dict[str, Dict[str, int]]]]] + ] = Field(default=None) + # VM configuration for remote Docker build/run + vm_endpoint: str = Field(...) + vm_timeout: int = Field(default=120, ge=1) + vm_ssl_verify: bool = Field(default=True) + + model_config = SettingsConfigDict(env_prefix=f"{ENV_PREFIX}CHALLENGE_") + + +__all__ = ["ChallengeConfig"] diff --git a/src/bv_challenge/challenge/api/core/configs/_dev.py b/src/bv_challenge/challenge/api/core/configs/_dev.py new file mode 100644 index 0000000..2012d55 --- /dev/null +++ b/src/bv_challenge/challenge/api/core/configs/_dev.py @@ -0,0 +1,37 @@ +# -*- coding: utf-8 -*- + +from typing import Any, Dict, List, Optional + +from pydantic import Field, constr, model_validator +from pydantic_settings import SettingsConfigDict + +from api.core.constants import ENV_PREFIX_API +from ._base import BaseConfig + + +class DevConfig(BaseConfig): + reload: bool = Field(...) + reload_includes: Optional[ + List[constr(strip_whitespace=True, min_length=1, max_length=256)] # type: ignore + ] = Field(default=None) + reload_excludes: Optional[ + List[constr(strip_whitespace=True, min_length=1, max_length=256)] # type: ignore + ] = Field(default=None) + + model_config = SettingsConfigDict(env_prefix=f"{ENV_PREFIX_API}DEV_") + + +class FrozenDevConfig(DevConfig): + @model_validator(mode="before") + @classmethod + def _check_all(cls, values: Dict[str, Any]) -> Dict[str, Any]: + if not values["reload"]: + values["reload_includes"] = None + values["reload_excludes"] = None + + return values + + model_config = SettingsConfigDict(frozen=True) + + +__all__ = ["DevConfig", "FrozenDevConfig"] diff --git a/src/bv_challenge/challenge/api/core/configs/_docs.py b/src/bv_challenge/challenge/api/core/configs/_docs.py index 1fa3484..1db5ba5 100644 --- a/src/bv_challenge/challenge/api/core/configs/_docs.py +++ b/src/bv_challenge/challenge/api/core/configs/_docs.py @@ -1,84 +1,69 @@ -from typing import Any +# -*- coding: utf-8 -*- -from pydantic import Field, model_validator -from pydantic_settings import SettingsConfigDict +from typing import Any, Dict, List, Optional -from potato_util import validator +from pydantic import Field, constr, model_validator +from pydantic_settings import SettingsConfigDict from api.core.constants import ENV_PREFIX_API - +from api.core.utils import validator from ._base import BaseConfig class DocsConfig(BaseConfig): - enabled: bool = Field(default=True) - openapi_url: str | None = Field(default="{api_prefix}/openapi.json") - docs_url: str | None = Field(default="{api_prefix}/docs") - redoc_url: str | None = Field(default="{api_prefix}/redoc") - swagger_ui_oauth2_redirect_url: str | None = Field( - default="{api_prefix}/docs/oauth2-redirect" - ) - summary: str | None = Field(default="This is a RedTeam Subnet's bot virus challenge repository.") + enabled: bool = Field(...) + openapi_url: Optional[ + constr(strip_whitespace=True, max_length=128) # type: ignore + ] = Field(default=None) + docs_url: Optional[ + constr(strip_whitespace=True, max_length=128) # type: ignore + ] = Field(default=None) + redoc_url: Optional[ + constr(strip_whitespace=True, max_length=128) # type: ignore + ] = Field(default=None) + swagger_ui_oauth2_redirect_url: Optional[ + constr(strip_whitespace=True, max_length=128) # type: ignore + ] = Field(default=None) + summary: Optional[ + constr(strip_whitespace=True, min_length=2, max_length=128) # type: ignore + ] = Field(default=None) description: str = Field(default="", max_length=8192) - terms_of_service: str | None = Field( - default="https://theredteam.io/terms" - ) - contact: dict[str, Any] | None = Field( - default={ - "name": "Support Team", - "email": "support@theredteam.io", - "url": "https://theredteam.io/contact", - } - ) - license_info: dict[str, Any] | None = Field( - default={ - "name": "MIT License", - "url": "https://opensource.org/licenses/mit", - } - ) - openapi_tags: list[dict[str, Any]] | None = Field( - default=[ - {"name": "Utils", "description": "Useful utility endpoints."}, - {"name": "Challenge", "description": "Endpoints for challenge."}, - {"name": "Default", "description": "Redirection of default endpoints."}, - ] - ) - swagger_ui_parameters: dict[str, Any] | None = Field( - default={"syntaxHighlight": {"theme": "nord"}} - ) + terms_of_service: Optional[ + constr(strip_whitespace=True, min_length=1, max_length=256) # type: ignore + ] = Field(default=None) + contact: Optional[Dict[str, Any]] = Field(default=None) + license_info: Optional[Dict[str, Any]] = Field(default=None) + openapi_tags: Optional[List[Dict[str, Any]]] = Field(default=None) + swagger_ui_parameters: Optional[Dict[str, Any]] = Field(default=None) model_config = SettingsConfigDict(env_prefix=f"{ENV_PREFIX_API}DOCS_") class FrozenDocsConfig(DocsConfig): + @model_validator(mode="before") @classmethod - def _check_all(cls, data: Any) -> Any: - if isinstance(data, dict): - if ("openapi_url" in data) and (data["openapi_url"] == ""): - data["openapi_url"] = None - - if ("docs_url" in data) and (data["docs_url"] == ""): - data["docs_url"] = None - - if ("redoc_url" in data) and (data["redoc_url"] == ""): - data["redoc_url"] = None - - if ("swagger_ui_oauth2_redirect_url" in data) and ( - data["swagger_ui_oauth2_redirect_url"] == "" - ): - data["swagger_ui_oauth2_redirect_url"] = None - - try: - if ("enabled" in data) and validator.is_falsy(data["enabled"]): - data["openapi_url"] = None - data["docs_url"] = None - data["redoc_url"] = None - data["swagger_ui_oauth2_redirect_url"] = None - except ValueError: - pass - - return data + def _check_all(cls, values: Dict[str, Any]) -> Dict[str, Any]: + + if values["openapi_url"] == "": + values["openapi_url"] = None + + if values["docs_url"] == "": + values["docs_url"] = None + + if values["redoc_url"] == "": + values["redoc_url"] = None + + if values["swagger_ui_oauth2_redirect_url"] == "": + values["swagger_ui_oauth2_redirect_url"] = None + + if validator.is_falsy(values["enabled"]): + values["openapi_url"] = None + values["docs_url"] = None + values["redoc_url"] = None + values["swagger_ui_oauth2_redirect_url"] = None + + return values model_config = SettingsConfigDict(frozen=True) diff --git a/src/bv_challenge/challenge/api/core/configs/_logger.py b/src/bv_challenge/challenge/api/core/configs/_logger.py deleted file mode 100644 index 603e579..0000000 --- a/src/bv_challenge/challenge/api/core/configs/_logger.py +++ /dev/null @@ -1,42 +0,0 @@ -import os - -from pydantic import Field, field_validator -from pydantic_settings import SettingsConfigDict - -from beans_logging.config import FileConfigPM as BaseFileConfigPM -from beans_logging_fastapi import LoggerConfigPM as BaseLoggerConfigPM - -from api.core.constants import ENV_PREFIX_API - -from ._base import BaseConfig - - -class FileConfigPM(BaseFileConfigPM, BaseConfig): - logs_dir: str = Field(default="./logs", min_length=2, max_length=1024) - - @field_validator("logs_dir", mode="after") - @classmethod - def _check_logger(cls, val: str) -> str: - _logs_dir = os.getenv(f"{ENV_PREFIX_API}LOGS_DIR", "") - if _logs_dir: - val = _logs_dir - - return val - - -class LoggerConfigPM(BaseLoggerConfigPM, BaseConfig): - app_name: str = Field(default="{api_slug}", min_length=1, max_length=128) - file: FileConfigPM = Field(default_factory=FileConfigPM) # type: ignore - - model_config = SettingsConfigDict(env_prefix=f"{ENV_PREFIX_API}LOGGER_") - - -class FrozenLoggerConfigPM(LoggerConfigPM): - model_config = SettingsConfigDict(frozen=True) - - -__all__ = [ - "FileConfigPM", - "LoggerConfigPM", - "FrozenLoggerConfigPM", -] diff --git a/src/bv_challenge/challenge/api/core/configs/_main.py b/src/bv_challenge/challenge/api/core/configs/_main.py index c699916..0f33538 100644 --- a/src/bv_challenge/challenge/api/core/configs/_main.py +++ b/src/bv_challenge/challenge/api/core/configs/_main.py @@ -1,56 +1,99 @@ +# -*- coding: utf-8 -*- + import os +from typing_extensions import Self -from pydantic import Field, field_validator, ValidationInfo +from pydantic import Field, constr, field_validator, ValidationInfo, model_validator from pydantic_settings import SettingsConfigDict -from potato_util.constants import EnvEnum - -from api.core.constants import ENV_PREFIX +from beans_logging import LoggerConfigPM -from ._base import BaseMainConfig -from ._uvicorn import UvicornConfig, FrozenUvicornConfig +from api.__version__ import __version__ +from api.core.constants import EnvEnum, ENV_PREFIX, ENV_PREFIX_API +from ._base import FrozenBaseConfig +from ._dev import DevConfig, FrozenDevConfig from ._api import ApiConfig, FrozenApiConfig +from ._challenge import ChallengeConfig # Main config schema: -class MainConfig(BaseMainConfig): - env: EnvEnum = Field(default=EnvEnum.LOCAL, alias="env") - debug: bool = Field(default=False, alias="debug") - api: ApiConfig = Field(default_factory=ApiConfig) +class MainConfig(FrozenBaseConfig): + env: EnvEnum = Field(...) + debug: bool = Field(...) + version: constr(strip_whitespace=True) = Field( # type: ignore + default=__version__, min_length=3, max_length=32 + ) + api: ApiConfig = Field(...) + challenge: ChallengeConfig = Field(...) + logger: LoggerConfigPM = Field(default_factory=LoggerConfigPM) + + @field_validator("env") + @classmethod + def _check_env(cls, val: EnvEnum) -> EnvEnum: + _env = "ENV" + if _env in os.environ: + _env = os.getenv(_env).upper() + val = EnvEnum(_env) + + return val + + @field_validator("debug") + @classmethod + def _check_debug(cls, val: str) -> str: + _debug_env = "DEBUG" + if _debug_env in os.environ: + val = os.getenv(_debug_env) + + return val - @field_validator("api", mode="after") + @field_validator("version") + @classmethod + def _check_version(cls, val: str) -> str: + val = __version__ + return val + + @field_validator("api") @classmethod def _check_api(cls, val: ApiConfig, info: ValidationInfo) -> FrozenApiConfig: - _uvicorn: UvicornConfig = val.uvicorn + _dev: DevConfig = val.dev if ("env" in info.data) and (info.data["env"] == EnvEnum.DEVELOPMENT): - _uvicorn.reload = True + _dev.reload = True - if val.security.ssl.enabled: - if not _uvicorn.ssl_keyfile: - _uvicorn.ssl_keyfile = os.path.join( - val.paths.ssl_dir, val.security.ssl.key_fname - ) + _dev = FrozenDevConfig(**_dev.model_dump()) + val = FrozenApiConfig(dev=_dev, **val.model_dump(exclude={"dev"})) + return val - if not _uvicorn.ssl_certfile: - _uvicorn.ssl_certfile = os.path.join( - val.paths.ssl_dir, val.security.ssl.cert_fname - ) + @field_validator("logger") + @classmethod + def _check_logger(cls, val: LoggerConfigPM, info: ValidationInfo) -> LoggerConfigPM: + if "api" in info.data: + if not val.app_name: + val.app_name = info.data["api"].slug + elif "{api_slug}" in val.app_name: + val.app_name = val.app_name.format(api_slug=info.data["api"].slug) + + _logs_dir_env = f"{ENV_PREFIX_API}LOGS_DIR" + if _logs_dir_env in os.environ: + val.file.logs_dir = os.getenv(_logs_dir_env) - _uvicorn = FrozenUvicornConfig(**_uvicorn.model_dump()) - val = FrozenApiConfig(uvicorn=_uvicorn, **val.model_dump(exclude={"uvicorn"})) return val - model_config = SettingsConfigDict( - env_prefix=ENV_PREFIX, - env_nested_delimiter="__", - cli_prefix="", - secrets_dir="/run/secrets", - secrets_prefix="", - secrets_nested_delimiter="_", - secrets_dir_missing="ok", # pragma: allowlist secret - ) # type: ignore + @model_validator(mode="after") + def _check_required_envs(self) -> Self: + _required_envs = [ + # f"{ENV_PREFIX_API}SECURITY_JWT_SECRET", + ] + + if (self.env == EnvEnum.STAGING) or (self.env == EnvEnum.PRODUCTION): + for _required_env in _required_envs: + if _required_env not in os.environ: + raise ValueError( + f"Missing required '{_required_env}' environment variable for STAGING/PRODUCTION environment!" + ) + + return self + + model_config = SettingsConfigDict(env_prefix=ENV_PREFIX, env_nested_delimiter="__") -__all__ = [ - "MainConfig", -] +__all__ = ["MainConfig"] diff --git a/src/bv_challenge/challenge/api/core/configs/_paths.py b/src/bv_challenge/challenge/api/core/configs/_paths.py index b880b79..30da454 100644 --- a/src/bv_challenge/challenge/api/core/configs/_paths.py +++ b/src/bv_challenge/challenge/api/core/configs/_paths.py @@ -1,43 +1,50 @@ +# -*- coding: utf-8 -*- + import os -from typing import Any +from typing import Any, Dict -from pydantic import Field, model_validator, field_validator +from pydantic import Field, constr, model_validator, field_validator from pydantic_settings import SettingsConfigDict from api.core.constants import ENV_PREFIX_API - from ._base import BaseConfig class PathsConfig(BaseConfig): - tmp_dir: str = Field(default="./tmp", min_length=2, max_length=1024) # nosec B108 - uploads_dir: str = Field(default="{tmp_dir}/uploads", min_length=2, max_length=1024) - data_dir: str = Field(default="./data", min_length=2, max_length=1024) - security_dir: str = Field( - default="{data_dir}/security", min_length=2, max_length=1024 + tmp_dir: constr(strip_whitespace=True) = Field(..., min_length=2, max_length=1024) # type: ignore + uploads_dir: constr(strip_whitespace=True) = Field( # type: ignore + ..., min_length=2, max_length=1024 ) - ssl_dir: str = Field( - default="{data_dir}/security/ssl", min_length=2, max_length=1024 + data_dir: constr(strip_whitespace=True) = Field( # type: ignore + ..., min_length=2, max_length=1024 ) - asymmetric_keys_dir: str = Field( - default="{data_dir}/security/asymmetric_keys", min_length=2, max_length=1024 + security_dir: constr(strip_whitespace=True) = Field( # type: ignore + ..., min_length=2, max_length=1024 ) + ssl_dir: constr(strip_whitespace=True) = Field(..., min_length=2, max_length=1024) # type: ignore + asymmetric_keys_dir: constr(strip_whitespace=True) = Field( # type: ignore + ..., min_length=2, max_length=1024 + ) + # models_dir: constr(strip_whitespace=True) = Field( # type: ignore + # ..., min_length=2, max_length=1024 + # ) + # model_dir: constr(strip_whitespace=True) = Field(..., min_length=2, max_length=1024) # type: ignore - @field_validator("tmp_dir", mode="after") + @field_validator("data_dir") @classmethod - def _check_tmp_dir(cls, val: str) -> str: - _tmp_dir = os.getenv(f"{ENV_PREFIX_API}TMP_DIR", "") - if _tmp_dir: - val = _tmp_dir + def _check_data_dir(cls, val: str) -> str: + _data_dir_env = f"{ENV_PREFIX_API}DATA_DIR" + if _data_dir_env in os.environ: + val = os.getenv(_data_dir_env) return val - @field_validator("data_dir", mode="after") + @field_validator("tmp_dir") @classmethod - def _check_data_dir(cls, val: str) -> str: - _data_dir = os.getenv(f"{ENV_PREFIX_API}DATA_DIR", "") - if _data_dir: - val = _data_dir + def _check_tmp_dir(cls, val: str) -> str: + _tmp_dir_env = f"{ENV_PREFIX_API}TMP_DIR" + if _tmp_dir_env in os.environ: + val = os.getenv(_tmp_dir_env) return val @@ -47,22 +54,14 @@ def _check_data_dir(cls, val: str) -> str: class FrozenPathsConfig(PathsConfig): @model_validator(mode="before") @classmethod - def _check_all(cls, data: Any) -> Any: - if isinstance(data, dict): - for _key, _val in data.items(): - if isinstance(_val, str): - if ("data_dir" in data) and ("{data_dir}" in _val): - data[_key] = _val.format(data_dir=data["data_dir"]) - - if ("tmp_dir" in data) and ("{tmp_dir}" in _val): - data[_key] = _val.format(tmp_dir=data["tmp_dir"]) + def _check_all(cls, values: Dict[str, Any]) -> Dict[str, Any]: + for _key, _val in values.items(): + if isinstance(_val, str) and ("{data_dir}" in _val): + values[_key] = _val.format(data_dir=values["data_dir"]) - return data + return values model_config = SettingsConfigDict(frozen=True) -__all__ = [ - "PathsConfig", - "FrozenPathsConfig", -] +__all__ = ["PathsConfig", "FrozenPathsConfig"] diff --git a/src/bv_challenge/challenge/api/core/configs/_security.py b/src/bv_challenge/challenge/api/core/configs/_security.py index fdb16b6..f747b28 100644 --- a/src/bv_challenge/challenge/api/core/configs/_security.py +++ b/src/bv_challenge/challenge/api/core/configs/_security.py @@ -1,53 +1,51 @@ -from pydantic import Field, constr, SecretStr +# -*- coding: utf-8 -*- + +from typing import List, Optional + +from pydantic import Field, constr from pydantic_settings import SettingsConfigDict -from potato_util.constants import ( +from api.core.constants import ( + ENV_PREFIX_API, HTTP_METHOD_REGEX, ASYMMETRIC_ALGORITHM_REGEX, - JWT_ALGORITHM_REGEX, ) - -from api.core.constants import ENV_PREFIX, ENV_PREFIX_API - from ._base import FrozenBaseConfig + _ENV_PREFIX_SECURITY = f"{ENV_PREFIX_API}SECURITY_" class CorsConfig(FrozenBaseConfig): - allow_origins: list[str] = Field(default=["*"]) - allow_origin_regex: str | None = Field(default=None) - allow_headers: list[str] = Field(default=["*"]) - allow_methods: list[constr(strip_whitespace=True, pattern=HTTP_METHOD_REGEX)] = ( # type: ignore - Field( - default=[ - "GET", - "POST", - "PUT", - "PATCH", - "DELETE", - "HEAD", - "OPTIONS", - "CONNECT", - ] - ) + allow_origins: List[ + constr(strip_whitespace=True, min_length=1, max_length=256) # type: ignore + ] = Field(...) + allow_origin_regex: Optional[ + constr(strip_whitespace=True, min_length=1, max_length=256) # type: ignore + ] = Field(default=None) + allow_headers: List[ + constr(strip_whitespace=True, min_length=1, max_length=128) # type: ignore + ] = Field(...) + allow_methods: List[constr(strip_whitespace=True, pattern=HTTP_METHOD_REGEX)] = ( # type: ignore + Field(...) ) - allow_credentials: bool = Field(default=False) - allow_private_network: bool = Field(default=False) - expose_headers: list[str] = Field(default=[]) - max_age: int = Field(default=600, ge=0, le=86_400) # Seconds (10 minutes) + allow_credentials: bool = Field(...) + expose_headers: List[ + constr(strip_whitespace=True, min_length=1, max_length=128) # type: ignore + ] = Field(...) + max_age: int = Field(..., ge=0, le=86_400) model_config = SettingsConfigDict(env_prefix=f"{_ENV_PREFIX_SECURITY}CORS_") class X509AttrsConfig(FrozenBaseConfig): - C: str = Field(default="US", min_length=2, max_length=2) - ST: str = Field(default="Washington", min_length=2, max_length=256) - L: str = Field(default="Seattle", min_length=2, max_length=256) - O: str = Field(default="Organization", min_length=2, max_length=256) - OU: str = Field(default="Organization Unit", min_length=2, max_length=256) - CN: str = Field(default="localhost", min_length=2, max_length=256) - DNS: str = Field(default="localhost", min_length=2, max_length=256) + C: constr(strip_whitespace=True, to_upper=True) = Field(default="US", min_length=2, max_length=2) # type: ignore + ST: constr(strip_whitespace=True) = Field(default="Washington", min_length=2, max_length=256) # type: ignore + L: constr(strip_whitespace=True) = Field(default="Seattle", min_length=2, max_length=256) # type: ignore + O: constr(strip_whitespace=True) = Field(default="Organization", min_length=2, max_length=256) # type: ignore + OU: constr(strip_whitespace=True) = Field(default="Organization Unit", min_length=2, max_length=256) # type: ignore + CN: constr(strip_whitespace=True) = Field(default="localhost", min_length=2, max_length=256) # type: ignore + DNS: constr(strip_whitespace=True) = Field(default="localhost", min_length=2, max_length=256) # type: ignore model_config = SettingsConfigDict( env_prefix=f"{_ENV_PREFIX_SECURITY}SSL_X509_ATTRS_" @@ -55,60 +53,40 @@ class X509AttrsConfig(FrozenBaseConfig): class SSLConfig(FrozenBaseConfig): - enabled: bool = Field(default=False) - generate: bool = Field(default=False) - key_size: int = Field(default=2048, ge=2048, le=8192) - key_fname: str = Field(default="key.pem", min_length=2, max_length=256) - cert_fname: str = Field(default="cert.pem", min_length=2, max_length=256) + enabled: bool = Field(...) + generate: bool = Field(...) + key_size: int = Field(..., ge=2048, le=8192) + key_fname: constr(strip_whitespace=True) = Field(..., min_length=2, max_length=256) # type: ignore + cert_fname: constr(strip_whitespace=True) = Field(..., min_length=2, max_length=256) # type: ignore x509_attrs: X509AttrsConfig = Field(default_factory=X509AttrsConfig) model_config = SettingsConfigDict(env_prefix=f"{_ENV_PREFIX_SECURITY}SSL_") class AsymmetricConfig(FrozenBaseConfig): - generate: bool = Field(default=False) - algorithm: str = Field(default="RS256", pattern=ASYMMETRIC_ALGORITHM_REGEX) - key_size: int = Field(default=2048, ge=2048, le=8192) - private_key_fname: str = Field( - default="private_key.pem", min_length=2, max_length=256 + generate: bool = Field(...) + algorithm: constr(strip_whitespace=True) = Field(..., pattern=ASYMMETRIC_ALGORITHM_REGEX) # type: ignore + key_size: int = Field(..., ge=2048, le=8192) + private_key_fname: constr(strip_whitespace=True) = Field( # type: ignore + ..., min_length=2, max_length=256 ) - public_key_fname: str = Field( - default="public_key.pem", min_length=2, max_length=256 + public_key_fname: constr(strip_whitespace=True) = Field( # type: ignore + ..., min_length=2, max_length=256 ) model_config = SettingsConfigDict(env_prefix=f"{_ENV_PREFIX_SECURITY}ASYMMETRIC_") -class JWTConfig(FrozenBaseConfig): - secret: SecretStr = Field( - default_factory=lambda: SecretStr(f"{ENV_PREFIX}JWT_SECRET123"), - min_length=8, - max_length=64, - ) - algorithm: str = Field(default="HS256", pattern=JWT_ALGORITHM_REGEX) - - model_config = SettingsConfigDict(env_prefix=f"{_ENV_PREFIX_SECURITY}JWT_") - - -class PasswordConfig(FrozenBaseConfig): - pepper: SecretStr = Field( - default_factory=lambda: SecretStr(f"{ENV_PREFIX}PASSWORD_PEPPER123"), - min_length=8, - max_length=32, - ) - min_length: int = Field(default=8, ge=8, le=128) - max_length: int = Field(default=128, ge=8, le=128) - - model_config = SettingsConfigDict(env_prefix=f"{_ENV_PREFIX_SECURITY}PASSWORD_") - - class SecurityConfig(FrozenBaseConfig): - allowed_hosts: list[str] = Field(default=["*"]) - cors: CorsConfig = Field(default_factory=CorsConfig) - ssl: SSLConfig = Field(default_factory=SSLConfig) - asymmetric: AsymmetricConfig = Field(default_factory=AsymmetricConfig) - jwt: JWTConfig = Field(default_factory=JWTConfig) - password: PasswordConfig = Field(default_factory=PasswordConfig) + allowed_hosts: List[constr(strip_whitespace=True, min_length=1, max_length=256)] = ( # type: ignore + Field(...) + ) + forwarded_allow_ips: List[ + constr(strip_whitespace=True, min_length=1, max_length=256) # type: ignore + ] = Field(...) + cors: CorsConfig = Field(...) + ssl: SSLConfig = Field(...) + asymmetric: AsymmetricConfig = Field(...) model_config = SettingsConfigDict(env_prefix=_ENV_PREFIX_SECURITY) @@ -119,6 +97,4 @@ class SecurityConfig(FrozenBaseConfig): "X509AttrsConfig", "SSLConfig", "AsymmetricConfig", - "JWTConfig", - "PasswordConfig", ] diff --git a/src/bv_challenge/challenge/api/core/configs/_uvicorn.py b/src/bv_challenge/challenge/api/core/configs/_uvicorn.py deleted file mode 100644 index 223faa7..0000000 --- a/src/bv_challenge/challenge/api/core/configs/_uvicorn.py +++ /dev/null @@ -1,53 +0,0 @@ -import os -from typing import Any - -from pydantic import Field, model_validator -from pydantic_settings import SettingsConfigDict - -from api.core.constants import ENV_PREFIX_API - -from ._base import BaseConfig - - -class UvicornConfig(BaseConfig): - access_log: bool = Field(default=False) - server_header: bool = Field(default=False) - proxy_headers: bool = Field(default=True) - forwarded_allow_ips: list[str] | str | None = Field(default=["*"]) - ssl_keyfile: str | None = Field(default=None) - ssl_certfile: str | None = Field(default=None) - reload: bool = Field(default=False) - reload_dirs: list[str] | str | None = Field(default=None) - reload_includes: list[str] | str | None = Field( - default=["*.json", "*.yml", "*.yaml", "*.toml", "*.md"] - ) - reload_excludes: list[str] | str | None = Field( - default=[".*", "~*", ".py[cod]", ".sw.*", "__pycache__", "*.log", "logs"] - ) - - model_config = SettingsConfigDict(env_prefix=f"{ENV_PREFIX_API}UVICORN_") - - -class FrozenUvicornConfig(UvicornConfig): - @model_validator(mode="before") - @classmethod - def _check_all(cls, data: Any) -> Any: - if isinstance(data, dict): - if "reload" in data: - if data["reload"]: - if (not data.get("reload_dirs")) and os.path.isdir("./src"): - data["reload_dirs"] = ["./src"] - else: - data["reload_includes"] = None - data["reload_excludes"] = None - data["reload_dirs"] = None - - return data - - model_config = SettingsConfigDict(frozen=True) - - -__all__ = [ - "UvicornConfig", - "FrozenUvicornConfig", -] diff --git a/src/bv_challenge/challenge/api/core/constants/__init__.py b/src/bv_challenge/challenge/api/core/constants/__init__.py index f6ecab7..8bd1879 100644 --- a/src/bv_challenge/challenge/api/core/constants/__init__.py +++ b/src/bv_challenge/challenge/api/core/constants/__init__.py @@ -1,4 +1,4 @@ -# flake8: noqa +# -*- coding: utf-8 -*- from ._base import * from ._regex import * diff --git a/src/bv_challenge/challenge/api/core/constants/_base.py b/src/bv_challenge/challenge/api/core/constants/_base.py index ec418c1..fbe5f32 100644 --- a/src/bv_challenge/challenge/api/core/constants/_base.py +++ b/src/bv_challenge/challenge/api/core/constants/_base.py @@ -1,10 +1,62 @@ -ENV_PREFIX = "BV_CHALLENGE_" -ENV_PREFIX_API = f"{ENV_PREFIX}API_" +# -*- coding: utf-8 -*- + +from enum import Enum + + +ENV_PREFIX = "BV_" +ENV_PREFIX_API = f"{ENV_PREFIX}CHALLENGE_API_" + + +class EnvEnum(str, Enum): + LOCAL = "LOCAL" + DEVELOPMENT = "DEVELOPMENT" + TEST = "TEST" + DEMO = "DEMO" + DOCS = "DOCS" + STAGING = "STAGING" + PRODUCTION = "PRODUCTION" + + +class WarnEnum(str, Enum): + ERROR = "ERROR" + ALWAYS = "ALWAYS" + DEBUG = "DEBUG" + IGNORE = "IGNORE" + + +class LanguageEnum(str, Enum): + en = "en" + ko = "ko" + mn = "mn" + + +class CurrencyEnum(str, Enum): + USD = "USD" + KRW = "KRW" + MNT = "MNT" + + +class HashAlgoEnum(str, Enum): + md5 = "md5" + sha1 = "sha1" + sha224 = "sha224" + sha256 = "sha256" + sha384 = "sha384" + sha512 = "sha512" + + +class HTTPSchemeEnum(str, Enum): + http = "http" + https = "https" -API_SLUG = "rest-bv-challenge" __all__ = [ "ENV_PREFIX", "ENV_PREFIX_API", - "API_SLUG", + "EnvEnum", + "WarnEnum", + "LanguageEnum", + "CurrencyEnum", + "HashAlgoEnum", + "HTTPSchemeEnum", ] diff --git a/src/bv_challenge/challenge/api/core/constants/_error_code.py b/src/bv_challenge/challenge/api/core/constants/_error_code.py index 76d2c9b..8a4c233 100644 --- a/src/bv_challenge/challenge/api/core/constants/_error_code.py +++ b/src/bv_challenge/challenge/api/core/constants/_error_code.py @@ -1,16 +1,20 @@ +# -*- coding: utf-8 -*- + from enum import Enum from http import HTTPStatus -from typing import Union, Any +from typing import Union, Optional, Any -from pydantic import BaseModel, Field +from pydantic import BaseModel, Field, constr class ErrorCodePM(BaseModel): - code: str = Field(..., min_length=3, max_length=36) - name: str = Field(..., min_length=3, max_length=64) + code: constr(strip_whitespace=True) = Field(..., min_length=3, max_length=36) # type: ignore + name: constr(strip_whitespace=True) = Field(..., min_length=3, max_length=64) # type: ignore status_code: int = Field(..., ge=100, le=599) - message: str = Field(..., min_length=1, max_length=256) - description: str | None = Field(default=None, max_length=1024) + message: constr(strip_whitespace=True) = Field(..., min_length=1, max_length=256) # type: ignore + description: Optional[constr(strip_whitespace=True)] = Field( # type: ignore + default=None, max_length=1024 + ) detail: Any = Field(default=None) diff --git a/src/bv_challenge/challenge/api/core/constants/_regex.py b/src/bv_challenge/challenge/api/core/constants/_regex.py index babab2c..3c4ad87 100644 --- a/src/bv_challenge/challenge/api/core/constants/_regex.py +++ b/src/bv_challenge/challenge/api/core/constants/_regex.py @@ -1,5 +1,51 @@ +# -*- coding: utf-8 -*- + # Valid characters: +ALPHANUM_REGEX = r"^[0-9a-zA-Z]+$" +ALPHANUM_SPACE_REGEX = r"^[0-9a-zA-Z ]+$" +ALPHANUM_HYPHEN_REGEX = r"^[0-9a-zA-Z_\-]+$" +ALPHANUM_HOST_REGEX = r"^[0-9a-zA-Z_\-.]+$" +ALPHANUM_EXTEND_REGEX = r"^[0-9a-zA-Z_\-. ]+$" +ALPHANUM_PATH_REGEX = r"^[0-9a-zA-Z_\-. \\\/]+$" + +REQUEST_ID_REGEX = ( + r"\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b|" + r"\b[0-9a-fA-F]{32}\b" +) + +ALPHANUM_CUSTOM_REGEX = r"^[0-9a-zA-Z_\-:+/=]+$" +REQUIREMENTS_REGEX = r"^[0-9a-zA-Z_\-.,\[\]!<>=~]+$" + +HTTP_METHOD_REGEX = r"^(GET|POST|PUT|PATCH|DELETE|HEAD|OPTIONS|CONNECT|TRACE|\*)$" +ASYMMETRIC_ALGORITHM_REGEX = r"^(RS256|RS384|RS512)$" +JWT_ALGORITHM_REGEX = r"^(HS256|HS384|HS512|ES256|ES256K|ES384|ES512|RS256|RS384|RS512|PS256|PS384|PS512|EdDSA)$" + # Invalid characters: +SPECIAL_CHARS_REGEX = r"[&'\"<>]" +SPECIAL_CHARS_BASE_REGEX = r"[&'\"<>\\\/]" +SPECIAL_CHARS_LOW_REGEX = r"[&'\"<>\\\/`{}|]" +SPECIAL_CHARS_MEDIUM_REGEX = r"[&'\"<>\\\/`{}|()\[\]]" +SPECIAL_CHARS_HIGH_REGEX = r"[&'\"<>\\\/`{}|()\[\]!@#$%^*;:?]" +SPECIAL_CHARS_STRICT_REGEX = r"[&'\"<>\\\/`{}|()\[\]~!@#$%^*_=\-+;:,.?\t\n ]" -__all__ = [] +__all__ = [ + "ALPHANUM_REGEX", + "ALPHANUM_SPACE_REGEX", + "ALPHANUM_HYPHEN_REGEX", + "ALPHANUM_HOST_REGEX", + "ALPHANUM_EXTEND_REGEX", + "ALPHANUM_PATH_REGEX", + "ALPHANUM_CUSTOM_REGEX", + "REQUEST_ID_REGEX", + "REQUIREMENTS_REGEX", + "HTTP_METHOD_REGEX", + "ASYMMETRIC_ALGORITHM_REGEX", + "JWT_ALGORITHM_REGEX", + "SPECIAL_CHARS_REGEX", + "SPECIAL_CHARS_BASE_REGEX", + "SPECIAL_CHARS_LOW_REGEX", + "SPECIAL_CHARS_MEDIUM_REGEX", + "SPECIAL_CHARS_HIGH_REGEX", + "SPECIAL_CHARS_STRICT_REGEX", +] diff --git a/src/bv_challenge/challenge/api/core/dependencies/__init__.py b/src/bv_challenge/challenge/api/core/dependencies/__init__.py index e69de29..40a96af 100644 --- a/src/bv_challenge/challenge/api/core/dependencies/__init__.py +++ b/src/bv_challenge/challenge/api/core/dependencies/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/bv_challenge/challenge/api/core/dependencies/auth.py b/src/bv_challenge/challenge/api/core/dependencies/auth.py index afe1068..a0e5de1 100644 --- a/src/bv_challenge/challenge/api/core/dependencies/auth.py +++ b/src/bv_challenge/challenge/api/core/dependencies/auth.py @@ -1,30 +1,30 @@ -from typing import Any +# -*- coding: utf-8 -*- + +from typing import Any, Dict, Optional, List from jwt import ExpiredSignatureError, InvalidTokenError from fastapi import Security, Depends, Request from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer -from potato_util.constants import ALPHANUM_HOST_REGEX -from potato_util import validator -from potato_util.crypto import jwt as jwt_utils - -from api.core.constants import ErrorCodeEnum +from api.core.constants import ErrorCodeEnum, ALPHANUM_HOST_REGEX from api.config import config +from api.core.utils import validator +from api.helpers.crypto import jwt as jwt_helper from api.core.exceptions import BaseHTTPException + _http_bearer = HTTPBearer(auto_error=False) def auth_jwt( request: Request, - authorization: HTTPAuthorizationCredentials | None = Security(_http_bearer), -) -> dict[str, Any]: + authorization: Optional[HTTPAuthorizationCredentials] = Security(_http_bearer), +) -> Dict[str, Any]: """Dependency function to authenticate the access token (JWT) and get the payload. Args: request (Request , required): The FastAPI request object. - authorization (HTTPAuthorizationCredentials, required): 'Authorization: Bearer ' - header credentials. + authorization (HTTPAuthorizationCredentials, required): 'Authorization: Bearer ' header credentials. Raises: BaseHTTPException: If the access token is missing. @@ -32,7 +32,7 @@ def auth_jwt( BaseHTTPException: If the access token is invalid. Returns: - dict[str, Any]: The decoded access token payload. + Dict[str, Any]: The decoded access token payload. """ if not authorization: @@ -50,9 +50,9 @@ def auth_jwt( headers={"WWW-Authenticate": 'Bearer error="invalid_token"'}, ) - _payload: dict[str, Any] + _payload: Dict[str, Any] = None try: - _payload: dict[str, Any] = jwt_utils.decode( + _payload: Dict[str, Any] = jwt_helper.decode( token=_access_token, key=config.api.security.jwt.secret, algorithm=config.api.security.jwt.algorithm, @@ -74,17 +74,17 @@ def auth_jwt( return _payload -def get_user_id(payload: dict[str, Any] = Depends(auth_jwt)) -> str: +def get_user_id(payload: Dict[str, Any] = Depends(auth_jwt)) -> str: """Dependency function to get the user ID from the token payload. Args: - payload (dict[str, Any], required): The decoded access token payload. + payload (Dict[str, Any], required): The decoded access token payload. Returns: str: The user ID. """ - _user_id: str = payload.get("sub", "") + _user_id: str = payload.get("sub") return _user_id @@ -110,39 +110,36 @@ def __init__(self, allow_scope: str, allow_owner: bool = False): self.allow_owner = allow_owner def __call__( - self, request: Request, payload: dict[str, Any] = Depends(auth_jwt) - ) -> dict[str, Any]: + self, request: Request, payload: Dict[str, Any] = Depends(auth_jwt) + ) -> Dict[str, Any]: """Dependency function to check the scope permissions of the user. Args: request (Request , required): The FastAPI request object. - payload (dict[str, Any], required): The decoded access token (JWT) payload. + payload (Dict[str, Any], required): The decoded access token (JWT) payload. Raises: BaseHTTPException: If the user has insufficient scope permissions. Returns: - dict[str, Any]: The decoded access token payload. + Dict[str, Any]: The decoded access token payload. """ if self.allow_owner: - _auth_user_id: str = payload.get("sub", "") - _path_params: list[str] = list(request.path_params.values()) + _auth_user_id: str = payload.get("sub") + _path_params: List[str] = list(request.path_params.values()) if _path_params and (_path_params[0] == _auth_user_id): return payload - _token_all_scope: str = payload.get("scope", "") - _token_scope_list: list[str] = _token_all_scope.split(" ") + _token_all_scope: str = payload.get("scope") + _token_scope_list: List[str] = _token_all_scope.split(" ") if self.allow_scope not in _token_scope_list: raise BaseHTTPException( error_enum=ErrorCodeEnum.FORBIDDEN, message="You do not have enough scope permissions!", description="The request requires more scope permissions.", headers={ - "WWW-Authenticate": ( - 'Bearer error="insufficient_scope", ' - 'error_description="The request requires more scope permissions."' - ) + "WWW-Authenticate": 'Bearer error="insufficient_scope", error_description="The request requires more scope permissions."' }, ) diff --git a/src/bv_challenge/challenge/api/core/exceptions/__init__.py b/src/bv_challenge/challenge/api/core/exceptions/__init__.py index b722c5d..03e9716 100644 --- a/src/bv_challenge/challenge/api/core/exceptions/__init__.py +++ b/src/bv_challenge/challenge/api/core/exceptions/__init__.py @@ -1,3 +1,3 @@ -# flake8: noqa +# -*- coding: utf-8 -*- from ._base import * diff --git a/src/bv_challenge/challenge/api/core/exceptions/_base.py b/src/bv_challenge/challenge/api/core/exceptions/_base.py index f639d22..67918da 100644 --- a/src/bv_challenge/challenge/api/core/exceptions/_base.py +++ b/src/bv_challenge/challenge/api/core/exceptions/_base.py @@ -1,6 +1,8 @@ -from typing import Any, cast +# -*- coding: utf-8 -*- -from pydantic import validate_call +from typing import Any, Optional, Dict + +from pydantic import conint, constr, validate_call from fastapi import HTTPException from api.core.constants import ErrorCodeEnum @@ -17,36 +19,32 @@ class BaseHTTPException(HTTPException): def __init__( self, error_enum: ErrorCodeEnum, - status_code: int | None = None, - message: str | None = None, - content: Any = None, - description: str | None = None, + status_code: Optional[conint(ge=100, le=599)] = None, # type: ignore + message: Optional[ + constr(strip_whitespace=True, min_length=1, max_length=256) # type: ignore + ] = None, + description: Optional[constr(strip_whitespace=True, max_length=1024)] = None, # type: ignore detail: Any = None, - headers: dict[str, str] | None = None, + headers: Optional[Dict[str, str]] = None, ): """Constructor method for BaseHTTPException class. Args: - error_enum (ErrorCodeEnum , required): Main error code enum. - status_code (int | None , optional): HTTP status code: [ge=100, le=599]. Defaults to None. - message (str | None , optional): Error message: [min_length=1, max_length=255]. - Defaults to None. - content (Any , optional): Any data content for response. Defaults to None. - description (str | None , optional): Error description: [max_length=511]. Defaults to None. - detail (Any , optional): Error detail. Defaults to None. - headers (dict[str, str] | None, optional): Headers. Defaults to None. + error_enum (ErrorCodeEnum , required): Main error code enum. + status_code (Optional[int] , optional): HTTP status code: [ge=100, le=599]. Defaults to None. + message (Optional[str] , optional): Error message: [min_length=1, max_length=255]. Defaults to None. + description (Optional[str] , optional): Error description: [max_length=511]. Defaults to None. + detail (Any , optional): Error detail. Defaults to None. + headers (Optional[Dict[str, str]], optional): Headers. Defaults to None. """ _error = error_enum.value.model_dump() if not status_code: - status_code = cast(int, _error.get("status_code", 500)) + status_code: int = _error.get("status_code") if not message: - message = _error.get("message", "An error occurred") - - if content: - self.content = content + message: str = _error.get("message") if description: _error["description"] = description diff --git a/src/bv_challenge/challenge/api/core/handlers/__init__.py b/src/bv_challenge/challenge/api/core/handlers/__init__.py index 0c4cade..1059366 100644 --- a/src/bv_challenge/challenge/api/core/handlers/__init__.py +++ b/src/bv_challenge/challenge/api/core/handlers/__init__.py @@ -1,4 +1,4 @@ -# flake8: noqa +# -*- coding: utf-8 -*- from ._not_found import * from ._method_not_allowed import * diff --git a/src/bv_challenge/challenge/api/core/handlers/_http_exception.py b/src/bv_challenge/challenge/api/core/handlers/_http_exception.py index eb8b89e..8da773b 100644 --- a/src/bv_challenge/challenge/api/core/handlers/_http_exception.py +++ b/src/bv_challenge/challenge/api/core/handlers/_http_exception.py @@ -1,15 +1,16 @@ -from fastapi import HTTPException, Request +# -*- coding: utf-8 -*- + +from typing import Union -from potato_util.http import get_http_status +from fastapi import HTTPException, Request from api.core.constants import ErrorCodeEnum +from api.core import utils from api.core.responses import BaseResponse -# For HTTPException error: -async def http_exception_handler( - request: Request, exc: HTTPException | Exception -) -> BaseResponse: +## For HTTPException error: +async def http_exception_handler(request: Request, exc: HTTPException) -> BaseResponse: """HTTPException handler. Args: @@ -20,14 +21,10 @@ async def http_exception_handler( BaseResponse: Response object. """ - assert isinstance( - exc, HTTPException - ), f"`exc` argument type is invalid {type(exc)}, expected !" - _message: str - _error: dict | str | None = None + _error: Union[dict, str, None] = None - _http_status, _ = get_http_status(status_code=exc.status_code) + _http_status, _ = utils.get_http_status(status_code=exc.status_code) if isinstance(exc.detail, dict): _message = str(exc.detail.get("message", _http_status.phrase)) @@ -45,18 +42,12 @@ async def http_exception_handler( if _error_code_enum: _error = _error_code_enum.value.model_dump() - _content = None - if hasattr(exc, "content"): - _content = getattr(exc, "content") - - _headers = dict(exc.headers) if exc.headers else None return BaseResponse( request=request, - content=_content, status_code=exc.status_code, message=_message, error=_error, - headers=_headers, + headers=exc.headers, ) diff --git a/src/bv_challenge/challenge/api/core/handlers/_method_not_allowed.py b/src/bv_challenge/challenge/api/core/handlers/_method_not_allowed.py index 867e31c..80c4bd1 100644 --- a/src/bv_challenge/challenge/api/core/handlers/_method_not_allowed.py +++ b/src/bv_challenge/challenge/api/core/handlers/_method_not_allowed.py @@ -1,12 +1,14 @@ +# -*- coding: utf-8 -*- + from fastapi import HTTPException, Request from api.core.constants import ErrorCodeEnum from api.core.responses import BaseResponse -# For 405 status code: +## For 405 status code: async def method_not_allowed_handler( - request: Request, exc: HTTPException | Exception + request: Request, exc: HTTPException ) -> BaseResponse: """405 status code handler. @@ -19,7 +21,7 @@ async def method_not_allowed_handler( """ _error = ErrorCodeEnum.METHOD_NOT_ALLOWED.value.model_dump() - _message: str = _error.get("message", "Method Not Allowed") + _message: str = _error.get("message") return BaseResponse( request=request, status_code=405, message=_message, error=_error diff --git a/src/bv_challenge/challenge/api/core/handlers/_not_found.py b/src/bv_challenge/challenge/api/core/handlers/_not_found.py index 5158524..29205e9 100644 --- a/src/bv_challenge/challenge/api/core/handlers/_not_found.py +++ b/src/bv_challenge/challenge/api/core/handlers/_not_found.py @@ -1,13 +1,13 @@ +# -*- coding: utf-8 -*- + from fastapi import HTTPException, Request from api.core.constants import ErrorCodeEnum from api.core.responses import BaseResponse -# For 404 status code: -async def not_found_handler( - request: Request, exc: HTTPException | Exception -) -> BaseResponse: +## For 404 status code: +async def not_found_handler(request: Request, exc: HTTPException) -> BaseResponse: """404 status code handler. Args: @@ -18,11 +18,8 @@ async def not_found_handler( BaseResponse: Response object. """ - if not isinstance(exc, HTTPException): - exc = HTTPException(status_code=404) - _error = ErrorCodeEnum.NOT_FOUND.value.model_dump() - _message: str = _error.get("message", "Not Found") + _message: str = _error.get("message") if hasattr(exc, "detail") and isinstance(exc.detail, dict): _message = exc.detail.get("message", _message) diff --git a/src/bv_challenge/challenge/api/core/handlers/_server_error.py b/src/bv_challenge/challenge/api/core/handlers/_server_error.py index d350114..e7d8ba8 100644 --- a/src/bv_challenge/challenge/api/core/handlers/_server_error.py +++ b/src/bv_challenge/challenge/api/core/handlers/_server_error.py @@ -1,18 +1,17 @@ -from typing import Any +# -*- coding: utf-8 -*- from fastapi import Request -from beans_logging_fastapi import log_http_error +from beans_logging_fastapi import async_log_http_error from api.core.constants import ErrorCodeEnum from api.config import config from api.core.exceptions import PrimaryKeyError, UniqueKeyError from api.core.responses import BaseResponse +from api.logger import logger -# from api.logger import logger - -# For unhandled Exception or 500 internal server error: +## For unhandled Exception or 500 internal server error: async def server_error_handler(request: Request, exc: Exception) -> BaseResponse: """Error handler for any kind of unhandled Exception or 500 internal server error. @@ -30,18 +29,18 @@ async def server_error_handler(request: Request, exc: Exception) -> BaseResponse if isinstance(exc, UniqueKeyError): _error_enum = ErrorCodeEnum.DB_UQ_ERROR - # _request_id: str = request.state.request_id + _request_id: str = request.state.request_id _exc_str = str(exc) _status_code = _error_enum.value.status_code - _error: dict[str, Any] = _error_enum.value.model_dump() + _error = _error_enum.value.model_dump() _error["detail"] = _exc_str - _message: str = _error.get("message", "Internal Server Error") + _message: str = _error.get("message") - # logger.exception(f"[{_request_id}] {_error_enum.value.code} - {_exc_str}") - log_http_error( + logger.exception(f"[{_request_id}] {_error_enum.value.code} - {_exc_str}") + await async_log_http_error( request=request, status_code=_status_code, - msg_format_str=config.api.logger.http.std.err_msg_format_str, + msg_format=config.logger.extra.http_std_error_format, ) return BaseResponse( request=request, status_code=_status_code, message=_message, error=_error diff --git a/src/bv_challenge/challenge/api/core/handlers/_validation_error.py b/src/bv_challenge/challenge/api/core/handlers/_validation_error.py index a535a07..8735d3c 100644 --- a/src/bv_challenge/challenge/api/core/handlers/_validation_error.py +++ b/src/bv_challenge/challenge/api/core/handlers/_validation_error.py @@ -1,3 +1,5 @@ +# -*- coding: utf-8 -*- + from fastapi import Request from fastapi.exceptions import RequestValidationError @@ -5,9 +7,9 @@ from api.core.responses import BaseResponse -# For RequestValidationError error: +## For RequestValidationError error: async def validation_error_handler( - request: Request, exc: RequestValidationError | Exception + request: Request, exc: RequestValidationError ) -> BaseResponse: """RequestValidationError handler for validation error. @@ -19,10 +21,6 @@ async def validation_error_handler( BaseResponse: Response object. """ - assert isinstance( - exc, RequestValidationError - ), f"`exc` argument type is invalid {type(exc)}, expected !" - _message = "Validation error!" _error = ErrorCodeEnum.UNPROCESSABLE_ENTITY.value.model_dump() _error["description"] = str(exc) diff --git a/src/bv_challenge/challenge/api/core/middlewares/__init__.py b/src/bv_challenge/challenge/api/core/middlewares/__init__.py index 1be8359..7271d04 100644 --- a/src/bv_challenge/challenge/api/core/middlewares/__init__.py +++ b/src/bv_challenge/challenge/api/core/middlewares/__init__.py @@ -1,4 +1,4 @@ -# flake8: noqa +# -*- coding: utf-8 -*- from ._process_time import * from ._request_id import * diff --git a/src/bv_challenge/challenge/api/core/middlewares/_process_time.py b/src/bv_challenge/challenge/api/core/middlewares/_process_time.py index bbd08cf..f15fd8e 100644 --- a/src/bv_challenge/challenge/api/core/middlewares/_process_time.py +++ b/src/bv_challenge/challenge/api/core/middlewares/_process_time.py @@ -1,5 +1,7 @@ +# -*- coding: utf-8 -*- + import time -from collections.abc import Callable +from typing import Callable from starlette.middleware.base import BaseHTTPMiddleware from fastapi import Request, Response diff --git a/src/bv_challenge/challenge/api/core/middlewares/_request_id.py b/src/bv_challenge/challenge/api/core/middlewares/_request_id.py index 30abc14..573fb92 100644 --- a/src/bv_challenge/challenge/api/core/middlewares/_request_id.py +++ b/src/bv_challenge/challenge/api/core/middlewares/_request_id.py @@ -1,5 +1,7 @@ +# -*- coding: utf-8 -*- + from uuid import uuid4 -from collections.abc import Callable +from typing import Callable from starlette.middleware.base import BaseHTTPMiddleware from fastapi import Request, Response @@ -16,9 +18,9 @@ class RequestIdMiddleware(BaseHTTPMiddleware): async def dispatch(self, request: Request, call_next: Callable) -> Response: _request_id: str = uuid4().hex if "X-Request-ID" in request.headers: - _request_id: str = request.headers.get("X-Request-ID", _request_id) + _request_id: str = request.headers.get("X-Request-ID") elif "X-Correlation-ID" in request.headers: - _request_id: str = request.headers.get("X-Correlation-ID", _request_id) + _request_id: str = request.headers.get("X-Correlation-ID") request.state.request_id = _request_id response: Response = await call_next(request) diff --git a/src/bv_challenge/challenge/api/core/models/__init__.py b/src/bv_challenge/challenge/api/core/models/__init__.py index e69de29..40a96af 100644 --- a/src/bv_challenge/challenge/api/core/models/__init__.py +++ b/src/bv_challenge/challenge/api/core/models/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/bv_challenge/challenge/api/core/responses/__init__.py b/src/bv_challenge/challenge/api/core/responses/__init__.py index b722c5d..03e9716 100644 --- a/src/bv_challenge/challenge/api/core/responses/__init__.py +++ b/src/bv_challenge/challenge/api/core/responses/__init__.py @@ -1,3 +1,3 @@ -# flake8: noqa +# -*- coding: utf-8 -*- from ._base import * diff --git a/src/bv_challenge/challenge/api/core/responses/_base.py b/src/bv_challenge/challenge/api/core/responses/_base.py index d05c268..3d8e9e0 100644 --- a/src/bv_challenge/challenge/api/core/responses/_base.py +++ b/src/bv_challenge/challenge/api/core/responses/_base.py @@ -1,17 +1,16 @@ +# -*- coding: utf-8 -*- + from http import HTTPStatus -from typing import Any +from typing import Any, Optional, Dict, Type -from pydantic import validate_call +from pydantic import validate_call, conint, constr from starlette.background import BackgroundTask from fastapi import Request from fastapi.encoders import jsonable_encoder from fastapi.responses import JSONResponse -from potato_util.http import get_http_status -from potato_util.http.fastapi import get_relative_url - -from api.__version__ import __version__ from api.config import config +from api.core import utils from api.core.schemas import BaseResPM @@ -27,44 +26,44 @@ class BaseResponse(JSONResponse): def __init__( self, content: Any = None, - status_code: int = 200, - headers: dict[str, str] | None = None, - media_type: str | None = None, - background: BackgroundTask | None = None, - request: Request | None = None, - message: str | None = None, - links: dict[str, Any] | None = None, - meta: dict[str, Any] | None = None, + status_code: Optional[conint(ge=100, le=599)] = 200, # type: ignore + headers: Optional[Dict[str, str]] = None, + media_type: Optional[constr(strip_whitespace=True)] = None, # type: ignore + background: Optional[BackgroundTask] = None, + request: Optional[Request] = None, + message: Optional[ + constr(strip_whitespace=True, min_length=1, max_length=256) # type: ignore + ] = None, + links: Optional[Dict[str, Any]] = None, + meta: Optional[Dict[str, Any]] = None, error: Any = None, - response_schema: type[BaseResPM] = BaseResPM, + response_schema: Optional[Type[BaseResPM]] = BaseResPM, ) -> None: """Constructor method for BaseResponse class. This will prepare the most response data and pass it to `JSONResponse` parent class constructor. Args: - content (Any , optional): Main data content for response. Defaults to None. - status_code (int | None , optional): HTTP status code: [100 <= status_code <= 599]. - Defaults to 200. - headers (dict[str, str] | None , optional): HTTP headers. Defaults to None. - media_type (str | None , optional): Media type for 'Content-Type' header. Defaults to None. - background (BackgroundTask | None , optional): Background task. Defaults to None. - request (Request | None , optional): Request object from FastAPI. Defaults to None. - message (str | None , optional): Message for response: [1 <= len(message) <= 256]. - Defaults to None. - links (dict[str, Any] | None , optional): Links for response. Defaults to None. - meta (dict[str, Any] | None , optional): Meta data for response. Defaults to None. - error (Any , optional): Error data for response. Defaults to None. - response_schema (type[BaseResPM] | None, optional): Response schema type. Defaults to `Type[BaseResPM]`. + content (Any , optional): Main data content for response. Defaults to None. + status_code (Optional[int] , optional): HTTP status code: [100 <= status_code <= 599]. Defaults to 200. + headers (Optional[Dict[str, str]] , optional): HTTP headers. Defaults to None. + media_type (Optional[str] , optional): Media type for 'Content-Type' header. Defaults to None. + background (Optional[BackgroundTask] , optional): Background task. Defaults to None. + request (Optional[Request] , optional): Request object from FastAPI. Defaults to None. + message (Optional[str] , optional): Message for response: [1 <= len(message) <= 256]. Defaults to None. + links (Optional[Dict[str, Any]] , optional): Links for response. Defaults to None. + meta (Optional[Dict[str, Any]] , optional): Meta data for response. Defaults to None. + error (Any , optional): Error data for response. Defaults to None. + response_schema (Optional[Type[BaseResPM]], optional): Response schema type. Defaults to `Type[BaseResPM]`. """ _http_status: HTTPStatus - _http_status, _ = get_http_status(status_code=status_code) + _http_status, _ = utils.get_http_status(status_code=status_code) if not message: if error and isinstance(error, dict) and ("message" in error): message = str(error["message"]) else: - message = _http_status.phrase + message: str = _http_status.phrase if not links: links = {} @@ -78,19 +77,20 @@ def __init__( if request: _request_id: str = request.state.request_id - links["self"] = f"{get_relative_url(request)}" + links["self"] = f"{utils.get_relative_url(request)}" + meta["request_id"] = _request_id meta["method"] = request.method meta["base_url"] = str(request.base_url)[:-1] if "X-Request-Id" not in headers: headers["X-Request-Id"] = _request_id - headers["X-API-Version"] = config.api.version - headers["X-System-Version"] = __version__ + meta["api_version"] = config.api.version + meta["version"] = config.version if error and isinstance(error, dict): if ("code" in error) and ("X-Error-Code" not in headers): - headers["X-Error-Code"] = error.get("code", f"{status_code}_00000") + headers["X-Error-Code"] = error.get("code") if (not config.debug) and (500 <= status_code) and ("detail" in error): error["detail"] = None @@ -115,7 +115,7 @@ def __init__( headers["Retry-After"] = "1800" _response_pm = response_schema( - message=message, data=content, links=links, meta=meta, error=error # type: ignore + message=message, data=content, links=links, meta=meta, error=error ) _content = jsonable_encoder(obj=_response_pm, by_alias=True) diff --git a/src/bv_challenge/challenge/api/core/routers/__init__.py b/src/bv_challenge/challenge/api/core/routers/__init__.py index e69de29..40a96af 100644 --- a/src/bv_challenge/challenge/api/core/routers/__init__.py +++ b/src/bv_challenge/challenge/api/core/routers/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/bv_challenge/challenge/api/core/routers/default.py b/src/bv_challenge/challenge/api/core/routers/default.py index a38c616..dee3054 100644 --- a/src/bv_challenge/challenge/api/core/routers/default.py +++ b/src/bv_challenge/challenge/api/core/routers/default.py @@ -1,8 +1,11 @@ +# -*- coding: utf-8 -*- + from fastapi import APIRouter from fastapi.responses import RedirectResponse from api.config import config + router = APIRouter(tags=["Default"]) @@ -17,6 +20,7 @@ async def get_root(): if config.api.docs.enabled: + if config.api.docs.openapi_url: @router.get( diff --git a/src/bv_challenge/challenge/api/core/routers/utils.py b/src/bv_challenge/challenge/api/core/routers/utils.py index 06a112b..0d0cf44 100644 --- a/src/bv_challenge/challenge/api/core/routers/utils.py +++ b/src/bv_challenge/challenge/api/core/routers/utils.py @@ -1,8 +1,12 @@ -from fastapi import APIRouter, Request +# -*- coding: utf-8 -*- -from api.core.schemas import BaseResPM +from fastapi import APIRouter, Request, Response +from fastapi.responses import JSONResponse + +from api.core.schemas import BaseResPM, HealthResPM from api.core.responses import BaseResponse + router = APIRouter(tags=["Utils"]) @@ -32,22 +36,15 @@ async def get_ping(request: Request): "/health", summary="Health", description="Check health of all related backend services.", - response_model=BaseResPM, + response_class=JSONResponse, + response_model=HealthResPM, ) -async def get_health(request: Request): - _message = "Everything is OK." - _data = {"api": {"message": "API is up.", "is_alive": True}} +async def get_health(response: Response): + response.headers["Cache-Control"] = "no-cache, no-store, must-revalidate" + response.headers["Pragma"] = "no-cache" + response.headers["Expires"] = "0" - return BaseResponse( - request=request, - content=_data, - message=_message, - headers={ - "Cache-Control": "no-cache, no-store, must-revalidate", - "Pragma": "no-cache", - "Expires": "0", - }, - ) + return {"status": "healthy"} __all__ = ["router"] diff --git a/src/bv_challenge/challenge/api/core/schemas/__init__.py b/src/bv_challenge/challenge/api/core/schemas/__init__.py index 6bd70cf..8a20231 100644 --- a/src/bv_challenge/challenge/api/core/schemas/__init__.py +++ b/src/bv_challenge/challenge/api/core/schemas/__init__.py @@ -1,4 +1,4 @@ -# flake8: noqa +# -*- coding: utf-8 -*- from ._base import * from ._responses import * diff --git a/src/bv_challenge/challenge/api/core/schemas/_base.py b/src/bv_challenge/challenge/api/core/schemas/_base.py index 79a9c4b..c026943 100644 --- a/src/bv_challenge/challenge/api/core/schemas/_base.py +++ b/src/bv_challenge/challenge/api/core/schemas/_base.py @@ -1,13 +1,14 @@ +# -*- coding: utf-8 -*- + from datetime import datetime from pydantic import BaseModel, Field, constr, ConfigDict -from potato_util.dt import now_utc_dt -from potato_util.generator import gen_unique_id +from api.core import utils class BasePM(BaseModel): - # model_config = ConfigDict(json_encoders={datetime: dt_to_iso}) + # model_config = ConfigDict(json_encoders={datetime: utils.datetime_to_iso}) pass @@ -19,7 +20,7 @@ class ExtraBasePM(BaseModel): class IdPM(BasePM): id: constr(strip_whitespace=True) = Field( # type: ignore - default_factory=gen_unique_id, + default_factory=utils.gen_unique_id, min_length=8, max_length=64, title="ID", @@ -30,16 +31,16 @@ class IdPM(BasePM): class TimestampPM(BasePM): updated_at: datetime = Field( - default_factory=now_utc_dt, + default_factory=utils.now_utc_dt, title="Updated datetime", description="Last updated datetime of the resource.", - examples=["2026-01-01T00:00:00+00:00"], + examples=["2024-12-01T00:00:00+00:00"], ) created_at: datetime = Field( - default_factory=now_utc_dt, + default_factory=utils.now_utc_dt, title="Created datetime", description="Created datetime of the resource.", - examples=["2026-01-01T00:00:00+00:00"], + examples=["2024-12-01T00:00:00+00:00"], ) diff --git a/src/bv_challenge/challenge/api/core/schemas/_error_responses.py b/src/bv_challenge/challenge/api/core/schemas/_error_responses.py index 488c34b..e13d6b8 100644 --- a/src/bv_challenge/challenge/api/core/schemas/_error_responses.py +++ b/src/bv_challenge/challenge/api/core/schemas/_error_responses.py @@ -1,4 +1,6 @@ -from typing import Any +# -*- coding: utf-8 -*- + +from typing import Any, Union from pydantic import Field @@ -14,13 +16,13 @@ class BadBaseResPM(BaseResPM): description="Response message about the current request.", examples=["Bad Request!"], ) - data: Any | dict | list = Field( + data: Union[Any, dict, list] = Field( default=None, title="Data", description="Resource data or any response related data.", examples=[None], ) - error: ErrorResPM | Any = Field( + error: Union[ErrorResPM, Any] = Field( default=None, title="Error", description="Error information about the current request.", @@ -43,7 +45,7 @@ class UnauthorizedBaseResPM(BadBaseResPM): description="Response message about the current request.", examples=["Unauthorized!"], ) - error: ErrorResPM | Any = Field( + error: Union[ErrorResPM, Any] = Field( default=None, title="Error", description="Error information about the current request.", @@ -66,7 +68,7 @@ class ForbiddenBaseResPM(BadBaseResPM): description="Response message about the current request.", examples=["Forbidden!"], ) - error: ErrorResPM | Any = Field( + error: Union[ErrorResPM, Any] = Field( default=None, title="Error", description="Error information about the current request.", @@ -89,7 +91,7 @@ class NotFoundBaseResPM(BadBaseResPM): description="Response message about the current request.", examples=["Not Found!"], ) - error: ErrorResPM | Any = Field( + error: Union[ErrorResPM, Any] = Field( default=None, title="Error", description="Error information about the current request.", @@ -112,7 +114,7 @@ class MethodNotBaseResPM(BadBaseResPM): description="Response message about the current request.", examples=["Method Not Allowed!"], ) - error: ErrorResPM | Any = Field( + error: Union[ErrorResPM, Any] = Field( default=None, title="Error", description="Error information about the current request.", @@ -135,7 +137,7 @@ class ConflictBaseResPM(BadBaseResPM): description="Response message about the current request.", examples=["Conflict!"], ) - error: ErrorResPM | Any = Field( + error: Union[ErrorResPM, Any] = Field( default=None, title="Error", description="Error information about the current request.", @@ -158,7 +160,7 @@ class InvalidBaseResPM(BadBaseResPM): description="Response message about the current request.", examples=["Validation error!"], ) - error: ErrorResPM | Any = Field( + error: Union[ErrorResPM, Any] = Field( default=None, title="Error", description="Error information about the current request.", @@ -188,7 +190,7 @@ class ErrorBaseResPM(BadBaseResPM): description="Response message about the current request.", examples=["Internal Server Error!"], ) - error: ErrorResPM | Any = Field( + error: Union[ErrorResPM, Any] = Field( default=None, title="Error", description="Error information about the current request.", diff --git a/src/bv_challenge/challenge/api/core/schemas/_responses.py b/src/bv_challenge/challenge/api/core/schemas/_responses.py index 8c41aa8..fe9cfdd 100644 --- a/src/bv_challenge/challenge/api/core/schemas/_responses.py +++ b/src/bv_challenge/challenge/api/core/schemas/_responses.py @@ -1,18 +1,29 @@ -from typing import Any +# -*- coding: utf-8 -*- -from pydantic import Field +from enum import Enum +from typing import Any, Union, Optional -from potato_util.constants import HTTPMethodEnum +from pydantic import Field, constr from api.config import config - from ._base import ExtraBasePM, BasePM +class MethodEnum(str, Enum): + GET = "GET" + POST = "POST" + PUT = "PUT" + PATCH = "PATCH" + DELETE = "DELETE" + HEAD = "HEAD" + OPTIONS = "OPTIONS" + CONNECT = "CONNECT" + TRACE = "TRACE" + + class LinksResPM(ExtraBasePM): - self_link: str | None = Field( + self_link: Optional[constr(strip_whitespace=True, max_length=2048)] = Field( # type: ignore default=None, - max_length=2048, alias="self", title="Self link", description="Link to the current resource.", @@ -21,33 +32,29 @@ class LinksResPM(ExtraBasePM): class PageLinksResPM(LinksResPM): - first_link: str | None = Field( + first_link: Optional[constr(strip_whitespace=True, max_length=2048)] = Field( # type: ignore default=None, - max_length=2048, alias="first", title="First link", description="Link to the first page of the resource.", examples=[f"{config.api.prefix}/resources/?skip=0&limit=100"], ) - prev_link: str | None = Field( + prev_link: Optional[constr(strip_whitespace=True, max_length=2048)] = Field( # type: ignore default=None, - max_length=2048, alias="prev", title="Previous link", description="Link to the previous page of the resource.", examples=[f"{config.api.prefix}/resources/?skip=100&limit=100"], ) - next_link: str | None = Field( + next_link: Optional[constr(strip_whitespace=True, max_length=2048)] = Field( # type: ignore default=None, - max_length=2048, alias="next", title="Next link", description="Link to the next page of the resource.", examples=[f"{config.api.prefix}/resources/?skip=300&limit=100"], ) - last_link: str | None = Field( + last_link: Optional[constr(strip_whitespace=True, max_length=2048)] = Field( # type: ignore default=None, - max_length=2048, alias="last", title="Last link", description="Link to the last page of the resource.", @@ -56,24 +63,48 @@ class PageLinksResPM(LinksResPM): class MetaResPM(ExtraBasePM): - base_url: str | None = Field( + request_id: Optional[ + constr(strip_whitespace=True, min_length=8, max_length=64) # type: ignore + ] = Field( + default=None, + title="Request ID", + description="Current request ID.", + examples=["211203afa2844d55b1c9d38b9f8a7063"], + ) + base_url: Optional[ + constr(strip_whitespace=True, min_length=2, max_length=256) # type: ignore + ] = Field( default=None, - min_length=2, - max_length=256, title="Base URL", description="Current request base URL.", examples=["https://api.example.com"], ) - method: HTTPMethodEnum | None = Field( + method: Optional[MethodEnum] = Field( default=None, title="Method", description="Current request method.", examples=["GET"], ) + api_version: constr(strip_whitespace=True) = Field( # type: ignore + default=config.api.version, + min_length=1, + max_length=16, + title="API version", + description="Current API version.", + examples=[config.api.version], + ) + version: constr(strip_whitespace=True) = Field( # type: ignore + default=config.version, + min_length=5, + max_length=32, + title="Version", + description="Current system version.", + examples=[config.version], + ) class ErrorResPM(BasePM): - code: str = Field( + code: constr(strip_whitespace=True) = Field( # type: ignore ..., min_length=3, max_length=36, @@ -81,14 +112,14 @@ class ErrorResPM(BasePM): description="Code that represents the error.", examples=["400_00000"], ) - description: str | None = Field( + description: Optional[constr(strip_whitespace=True)] = Field( # type: ignore default=None, max_length=1024, title="Error description", description="Description of the error.", examples=["Bad request syntax or unsupported method."], ) - detail: Any | dict | list = Field( + detail: Union[Any, dict, list] = Field( default=None, title="Error detail", description="Detail of the error.", @@ -112,7 +143,7 @@ class BaseResPM(BasePM): description="Response message about the current request.", examples=["Successfully processed the request."], ) - data: Any | dict | list = Field( + data: Union[Any, dict, list] = Field( default=None, title="Data", description="Resource data or any data related to response.", @@ -128,7 +159,7 @@ class BaseResPM(BasePM): title="Meta", description="Meta information about the current request.", ) - error: ErrorResPM | Any = Field( + error: Union[ErrorResPM, Any] = Field( default=None, title="Error", description="Error information about the current request.", @@ -136,10 +167,22 @@ class BaseResPM(BasePM): ) +class HealthResPM(BasePM): + status: str = Field( + default="healthy", + min_length=2, + max_length=32, + title="Status", + description="Health status of the service.", + examples=["healthy"], + ) + + __all__ = [ "LinksResPM", "PageLinksResPM", "MetaResPM", "ErrorResPM", "BaseResPM", + "HealthResPM", ] diff --git a/src/bv_challenge/challenge/api/core/services/__init__.py b/src/bv_challenge/challenge/api/core/services/__init__.py index e69de29..40a96af 100644 --- a/src/bv_challenge/challenge/api/core/services/__init__.py +++ b/src/bv_challenge/challenge/api/core/services/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/bv_challenge/challenge/api/core/utils/__init__.py b/src/bv_challenge/challenge/api/core/utils/__init__.py index b722c5d..3b1b591 100644 --- a/src/bv_challenge/challenge/api/core/utils/__init__.py +++ b/src/bv_challenge/challenge/api/core/utils/__init__.py @@ -1,3 +1,9 @@ -# flake8: noqa +# -*- coding: utf-8 -*- from ._base import * +from ._secure import * +from ._http import * +from ._dt import * +from ._io import * +from . import _validator as validator +from . import _sanitizer as sanitizer diff --git a/src/bv_challenge/challenge/api/core/utils/_base.py b/src/bv_challenge/challenge/api/core/utils/_base.py index c39d6b6..f3fa003 100644 --- a/src/bv_challenge/challenge/api/core/utils/_base.py +++ b/src/bv_challenge/challenge/api/core/utils/_base.py @@ -1,36 +1,117 @@ -import sys -from functools import lru_cache - -BINARY_MODULES = [ - "uvicorn", - "gunicorn", - "fastapi", - "pytest", - "unittest", - "alembic", -] +# -*- coding: utf-8 -*- + +import re +import copy + +from pydantic import validate_call + +from beans_logging import logger -@lru_cache -def is_running_bin() -> bool: - """Checks if the application is running as a binary environment module (e.g., via uvicorn, fastapi, gunicorn, etc.) - by inspecting the command-line arguments. +@validate_call +def deep_merge(dict1: dict, dict2: dict) -> dict: + """Return a new dictionary that's the result of a deep merge of two dictionaries. + If there are conflicts, values from `dict2` will overwrite those in `dict1`. + + Args: + dict1 (dict, required): The base dictionary that will be merged. + dict2 (dict, required): The dictionary to merge into `dict1`. Returns: - bool: True if running as a binary environment module, False otherwise. + dict: The merged dictionary. """ - for _binary_module in BINARY_MODULES: + _merged = copy.deepcopy(dict1) + for _key, _val in dict2.items(): if ( - sys.argv[0].endswith(_binary_module) - or sys.argv[0].endswith(f"{_binary_module}.exe") - or sys.argv[0].endswith(f"{_binary_module}/__main__.py") + _key in _merged + and isinstance(_merged[_key], dict) + and isinstance(_val, dict) ): - return True + _merged[_key] = deep_merge(_merged[_key], _val) + else: + _merged[_key] = copy.deepcopy(_val) + + return _merged + + +@validate_call +def camel_to_snake(val: str) -> str: + """Convert CamelCase to snake_case. + + Args: + val (str): CamelCase string to convert. + + Returns: + str: Converted snake_case string. + """ + + val = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", val) + val = re.sub("([a-z0-9])([A-Z])", r"\1_\2", val).lower() + return val + + +@validate_call +def clean_obj_dict(obj_dict: dict, cls_name: str) -> dict: + """Clean class name from object.__dict__ for str(object). + + Args: + obj_dict (dict, required): Object dictionary by object.__dict__. + cls_name (str , required): Class name by cls.__name__. + + Returns: + dict: Clean object dictionary. + """ + + try: + if not obj_dict: + raise ValueError("'obj_dict' argument value is empty!") + + if not cls_name: + raise ValueError("'cls_name' argument value is empty!") + except ValueError as err: + logger.error(err) + raise + + _self_dict = obj_dict.copy() + for _key in _self_dict.copy(): + _class_prefix = f"_{cls_name}__" + if _key.startswith(_class_prefix): + _new_key = _key.replace(_class_prefix, "") + _self_dict[_new_key] = _self_dict.pop(_key) + return _self_dict + + +@validate_call(config={"arbitrary_types_allowed": True}) +def obj_to_repr(obj: object) -> str: + """Modifying object default repr() to custom info. + + Args: + obj (object, required): Any python object. + + Returns: + str: String for repr() method. + """ + + try: + if not obj: + raise ValueError("'obj' argument value is empty!") + except ValueError as err: + logger.error(err) + raise - return False + _self_repr = ( + f"<{obj.__class__.__module__}.{obj.__class__.__name__} object at {hex(id(obj))}: " + + "{" + + f"{str(dir(obj)).replace('[', '').replace(']', '')}" + + "}>" + ) + return _self_repr __all__ = [ - "is_running_bin", + "deep_merge", + "camel_to_snake", + "clean_obj_dict", + "obj_to_repr", ] diff --git a/src/bv_challenge/challenge/api/core/utils/_dt.py b/src/bv_challenge/challenge/api/core/utils/_dt.py new file mode 100644 index 0000000..88a2648 --- /dev/null +++ b/src/bv_challenge/challenge/api/core/utils/_dt.py @@ -0,0 +1,245 @@ +# -*- coding: utf-8 -*- + +import time +from enum import Enum +from typing import Union, Optional +from zoneinfo import ZoneInfo +from datetime import datetime, timezone, tzinfo, timedelta + +from pydantic import validate_call, constr, conint +from beans_logging import logger + +from api.core.constants import WarnEnum + + +class TSUnitEnum(str, Enum): + SECONDS = "SECONDS" + MILLISECONDS = "MILLISECONDS" + MICROSECONDS = "MICROSECONDS" + NANOSECONDS = "NANOSECONDS" + + +@validate_call(config={"arbitrary_types_allowed": True}) +def add_tzinfo(dt: datetime, tz: Union[ZoneInfo, tzinfo, str]) -> datetime: + """Add or replace timezone info to datetime object. + + Args: + dt (datetime , required): Datetime object. + tz (Union[ZoneInfo, tzinfo, str], required): Timezone info. + + Returns: + datetime: Datetime object with timezone info. + """ + + if isinstance(tz, str): + tz = ZoneInfo(tz) + + dt = dt.replace(tzinfo=tz) + return dt + + +@validate_call +def datetime_to_iso( + dt: datetime, + sep: constr(max_length=8) = "T", # type: ignore + warn_mode: WarnEnum = WarnEnum.IGNORE, +) -> str: + """Convert datetime object to ISO 8601 format. + + Args: + dt (datetime, required): Datetime object. + sep (str , optional): Separator between date and time. Defaults to "T". + warn_mode (WarnEnum, optional): Warning mode. Defaults to WarnEnum.IGNORE. + + Raises: + ValueError: If `dt` argument doesn't have any timezone info and `warn_mode` is set to WarnEnum.ERROR. + + Returns: + str: Datetime string in ISO 8601 format. + """ + + if not dt.tzinfo: + _message = "Not found any timezone info in `dt` argument, assuming it's UTC timezone..." + if warn_mode == WarnEnum.ALWAYS: + logger.warning(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + elif warn_mode == WarnEnum.ERROR: + _message = "Not found any timezone info in `dt` argument!" + logger.error(_message) + raise ValueError(_message) + + dt = add_tzinfo(dt=dt, tz="UTC") + + _dt_str = dt.isoformat(sep=sep, timespec="milliseconds") + return _dt_str + + +@validate_call(config={"arbitrary_types_allowed": True}) +def convert_tz( + dt: datetime, + tz: Union[ZoneInfo, tzinfo, str], + warn_mode: WarnEnum = WarnEnum.ALWAYS, +) -> datetime: + """Convert datetime object to another timezone. + + Args: + dt (datetime , required): Datetime object to convert. + tz (Union[ZoneInfo, tzinfo, str], required): Timezone info to convert. + warn_mode (WarnEnum , optional): Warning mode. Defaults to WarnEnum.ALWAYS. + + Raises: + ValueError: If `dt` argument doesn't have any timezone info and `warn_mode` is set to WarnEnum.ERROR. + + Returns: + datetime: Datetime object which has been converted to another timezone. + """ + + if not dt.tzinfo: + _message = "Not found any timezone info in `dt` argument, assuming it's UTC timezone..." + if warn_mode == WarnEnum.ALWAYS: + logger.warning(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + elif warn_mode == WarnEnum.ERROR: + _message = "Not found any timezone info in `dt` argument!" + logger.error(_message) + raise ValueError(_message) + + dt = add_tzinfo(dt=dt, tz="UTC") + + if isinstance(tz, str): + tz = ZoneInfo(tz) + + dt = dt.astimezone(tz=tz) + return dt + + +def now_utc_dt() -> datetime: + """Get current datetime in UTC timezone with tzinfo. + + Returns: + datetime: Current datetime in UTC timezone with tzinfo. + """ + + _utc_dt = datetime.now(tz=timezone.utc) + return _utc_dt + + +def now_local_dt() -> datetime: + """Get current datetime in local timezone with tzinfo. + + Returns: + datetime: Current datetime in local timezone with tzinfo. + """ + + _local_dt = datetime.now().astimezone() + return _local_dt + + +@validate_call(config={"arbitrary_types_allowed": True}) +def now_dt(tz: Union[ZoneInfo, tzinfo, str]) -> datetime: + """Get current datetime in specified timezone with tzinfo. + + Args: + tz (Union[ZoneInfo, tzinfo, str], required): Timezone info. + + Returns: + datetime: Current datetime in specified timezone with tzinfo. + """ + + _dt = now_utc_dt() + _dt = convert_tz(dt=_dt, tz=tz) + return _dt + + +@validate_call +def now_ts(unit: TSUnitEnum = TSUnitEnum.SECONDS) -> int: + """Get current timestamp in UTC timezone. + + Args: + unit (TSUnitEnum, optional): Type of timestamp unit. Defaults to `TSUnitEnum.SECONDS`. + + Returns: + int: Current timestamp. + """ + + _now_ts: int = None + if unit == TSUnitEnum.SECONDS: + _now_ts = int(time.time()) + elif unit == TSUnitEnum.MILLISECONDS: + _now_ts = int(_now_ts * 1000) + elif unit == TSUnitEnum.MICROSECONDS: + _now_ts = int(time.time_ns() / 1000) + elif unit == TSUnitEnum.NANOSECONDS: + _now_ts = int(time.time_ns()) + + return _now_ts + + +@validate_call +def convert_ts(dt: datetime, unit: TSUnitEnum = TSUnitEnum.SECONDS) -> int: + """Convert datetime to timestamp. + + Args: + dt (datetime , required): Datetime object to convert. + unit (TSUnitEnum, optional): Type of timestamp unit. Defaults to `TSUnitEnum.SECONDS`. + + Returns: + int: Converted timestamp. + """ + + _ts: int = None + if unit == TSUnitEnum.SECONDS: + _ts = int(dt.timestamp()) + elif unit == TSUnitEnum.MILLISECONDS: + _ts = int(dt.timestamp() * 1000) + elif unit == TSUnitEnum.MICROSECONDS: + _ts = int(dt.timestamp() * 1000000) + elif unit == TSUnitEnum.NANOSECONDS: + _ts = int(dt.timestamp() * 1000000000) + + return _ts + + +@validate_call(config={"arbitrary_types_allowed": True}) +def calc_future_dt( + delta: Union[timedelta, conint(ge=1)], # type: ignore + dt: Optional[datetime] = None, + tz: Union[ZoneInfo, tzinfo, str, None] = None, +) -> datetime: + """Calculate future datetime by adding delta time to current or specified datetime. + + Args: + delta (Union[timedelta, int] , required): Delta time to add to current or specified datetime. + dt (Optional[datetime] , optional): Datetime before adding delta time. Defaults to None. + tz (Union[ZoneInfo, tzinfo, str, None], optional): Timezone info. Defaults to None. + + Returns: + datetime: Calculated future datetime. + """ + + if not dt: + dt = now_utc_dt() + + if tz: + dt = convert_tz(dt=dt, tz=tz) + + if isinstance(delta, int): + delta = timedelta(seconds=delta) + + _future_dt = dt + delta + return _future_dt + + +__all__ = [ + "add_tzinfo", + "datetime_to_iso", + "convert_tz", + "now_utc_dt", + "now_local_dt", + "now_dt", + "now_ts", + "convert_ts", + "calc_future_dt", +] diff --git a/src/bv_challenge/challenge/api/core/utils/_http.py b/src/bv_challenge/challenge/api/core/utils/_http.py new file mode 100644 index 0000000..cf52bd3 --- /dev/null +++ b/src/bv_challenge/challenge/api/core/utils/_http.py @@ -0,0 +1,128 @@ +# -*- coding: utf-8 -*- + +from typing import Tuple, Union +from urllib import request +from http import HTTPStatus +from http.client import HTTPResponse + +import aiohttp +from pydantic import validate_call, conint, AnyHttpUrl +from starlette.datastructures import URL +from fastapi import Request + + +@validate_call +def get_http_status(status_code: int) -> Tuple[HTTPStatus, bool]: + """Get HTTP status code enum from integer value. + + Args: + status_code (int, required): Status code for HTTP response: [100 <= status_code <= 599]. + + Raises: + ValueError: If status code is not in range [100 <= status_code <= 599]. + + Returns: + Tuple[HTTPStatus, bool]: Tuple of HTTP status code enum and boolean value if status code is known. + """ + + _http_status: HTTPStatus + _is_known_status = False + try: + _http_status = HTTPStatus(status_code) + _is_known_status = True + except ValueError: + if (100 <= status_code) and (status_code < 200): + status_code = 100 + elif (200 <= status_code) and (status_code < 300): + status_code = 200 + elif (300 <= status_code) and (status_code < 400): + status_code = 304 + elif (400 <= status_code) and (status_code < 500): + status_code = 400 + elif (500 <= status_code) and (status_code < 600): + status_code = 500 + else: + raise ValueError(f"Invalid HTTP status code: '{status_code}'!") + + _http_status = HTTPStatus(status_code) + + return (_http_status, _is_known_status) + + +@validate_call(config={"arbitrary_types_allowed": True}) +def get_relative_url(val: Union[Request, URL]) -> str: + """Get relative url only path with query params from request object or URL object. + + Args: + val (Union[Request, URL]): Request object or URL object to extract relative url. + + Returns: + str: Relative url only path with query params. + """ + + if isinstance(val, Request): + val: URL = val.url + + _relative_url = str(val).replace(f"{val.scheme}://{val.netloc}", "") + return _relative_url + + +@validate_call +async def async_is_connectable( + url: AnyHttpUrl = "https://www.google.com", + timeout: conint(ge=1) = 3, # type: ignore + check_status: bool = False, +) -> bool: + """Check if the url is connectable. + + Args: + url (AnyHttpUrl, optional): URL to check. Defaults to 'https://www.google.com'. + timeout (int , optional): Timeout in seconds. Defaults to 3. + check_status (bool , optional): Check HTTP status code (200). Defaults to False. + + Returns: + bool: True if connectable, False otherwise. + """ + + try: + async with aiohttp.ClientSession() as _session: + async with _session.get(url, timeout=timeout) as _response: + if check_status: + return _response.status == 200 + return True + except: + return False + + +@validate_call +def is_connectable( + url: AnyHttpUrl = "https://www.google.com", + timeout: conint(ge=1) = 3, # type: ignore + check_status: bool = False, +) -> bool: + """Check if the url is connectable. + + Args: + url (AnyHttpUrl, optional): URL to check. Defaults to 'https://www.google.com'. + timeout (int , optional): Timeout in seconds. Defaults to 3. + check_status (bool , optional): Check HTTP status code (200). Defaults to False. + + Returns: + bool: True if connectable, False otherwise. + """ + + try: + _response: HTTPResponse = request.urlopen(url, timeout=timeout) + if check_status: + return _response.getcode() == 200 + return True + except: + return False + + +__all__ = [ + "get_http_status", + "get_relative_url", + "async_is_connectable", + "is_connectable", +] diff --git a/src/bv_challenge/challenge/api/core/utils/_io.py b/src/bv_challenge/challenge/api/core/utils/_io.py new file mode 100644 index 0000000..06f2ddc --- /dev/null +++ b/src/bv_challenge/challenge/api/core/utils/_io.py @@ -0,0 +1,461 @@ +# -*- coding: utf-8 -*- + +import os +import errno +import shutil +import hashlib +from typing import List + +import aioshutil +import aiofiles.os +from pydantic import validate_call, conint, constr +from beans_logging import logger + +from api.core.constants import WarnEnum, HashAlgoEnum + + +_path_max_length = 1024 + + +## Async: +@validate_call +async def async_create_dir( + create_dir: constr(strip_whitespace=True, min_length=1, max_length=_path_max_length), # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Asynchronous create directory if `create_dir` doesn't exist. + + Args: + create_dir (str, required): Create directory path. + warn_mode (str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + + Raises: + OSError: When warning mode is set to ERROR and directory already exists. + OSError: If failed to create directory. + """ + + if not await aiofiles.os.path.isdir(create_dir): + try: + _message = f"Creating '{create_dir}' directory..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + await aiofiles.os.makedirs(create_dir) + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{create_dir}' directory already exists!") + else: + logger.error(f"Failed to create '{create_dir}' directory!") + raise + + _message = f"Successfully created '{create_dir}' directory." + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + elif warn_mode == WarnEnum.ERROR: + raise OSError(errno.EEXIST, f"'{create_dir}' directory already exists!") + + return + + +@validate_call +async def async_remove_dir( + remove_dir: constr(strip_whitespace=True, min_length=1, max_length=_path_max_length), # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Asynchronous remove directory if `remove_dir` exists. + + Args: + remove_dir (str, required): Remove directory path. + warn_mode (str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + + Raises: + OSError: When warning mode is set to ERROR and directory doesn't exist. + OSError: If failed to remove directory. + """ + + if await aiofiles.os.path.isdir(remove_dir): + try: + _message = f"Removing '{remove_dir}' directory..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + await aioshutil.rmtree(remove_dir) + except OSError as err: + if (err.errno == errno.ENOENT) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{remove_dir}' directory doesn't exist!") + else: + logger.error(f"Failed to remove '{remove_dir}' directory!") + raise + + _message = f"Successfully removed '{remove_dir}' directory." + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + elif warn_mode == WarnEnum.ERROR: + raise OSError(errno.ENOENT, f"'{create_dir}' directory doesn't exist!") + + return + + +@validate_call +async def async_remove_dirs( + remove_dirs: List[constr(strip_whitespace=True, min_length=1, max_length=_path_max_length)], # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Asynchronous remove directories if `remove_dirs` exists. + + Args: + remove_dirs (List[str], required): Remove directories paths as list. + warn_mode (str , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + """ + + for _remove_dir in remove_dirs: + await async_remove_dir(remove_dir=_remove_dir, warn_mode=warn_mode) + + return + + +@validate_call +async def async_remove_file( + file_path: constr(strip_whitespace=True, min_length=1, max_length=_path_max_length), # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Asynchronous remove file if `file_path` exists. + + Args: + file_path (str, required): Remove file path. + warn_mode (str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + + Raises: + OSError: When warning mode is set to ERROR and file doesn't exist. + OSError: If failed to remove file. + """ + + if await aiofiles.os.path.isfile(file_path): + try: + _message = f"Removing '{file_path}' file..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + await aiofiles.os.remove(file_path) + except OSError as err: + if (err.errno == errno.ENOENT) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{file_path}' file doesn't exist!") + else: + logger.error(f"Failed to remove '{file_path}' file!") + raise + + _message = f"Successfully removed '{file_path}' file." + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + elif warn_mode == WarnEnum.ERROR: + raise OSError(errno.ENOENT, f"'{file_path}' file doesn't exist!") + + return + + +@validate_call +async def async_remove_files( + file_paths: List[constr(strip_whitespace=True, min_length=1, max_length=_path_max_length)], # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Asynchronous remove files if `file_paths` exists. + + Args: + file_paths (List[str], required): Remove file paths as list. + warn_mode (str , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + """ + + for _file_path in file_paths: + await async_remove_file(file_path=_file_path, warn_mode=warn_mode) + + return + + +@validate_call +async def async_get_file_checksum( + file_path: constr(strip_whitespace=True, min_length=1, max_length=_path_max_length), # type: ignore + hash_method: HashAlgoEnum = HashAlgoEnum.md5, + chunk_size: conint(ge=10) = 4096, # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> str: + """Asynchronous get file checksum. + + Args: + file_path (str , required): Target file path. + hash_method (HashAlgoEnum, optional): Hash method. Defaults to `HashAlgoEnum.md5`. + chunk_size (int , optional): Chunk size. Defaults to 4096. + warn_mode (str , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + + Raises: + OSError: When warning mode is set to ERROR and file doesn't exist. + + Returns: + str: File checksum. + """ + + _file_checksum: str = None + if await aiofiles.os.path.isfile(file_path): + _file_hash = hashlib.new(hash_method.value) + async with aiofiles.open(file_path, "rb") as _file: + while True: + _file_chunk = await _file.read(chunk_size) + if not _file_chunk: + break + _file_hash.update(_file_chunk) + + _file_checksum = _file_hash.hexdigest() + else: + _message = f"'{file_path}' file doesn't exist!" + if warn_mode == WarnEnum.ALWAYS: + logger.warning(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + elif warn_mode == WarnEnum.ERROR: + raise OSError(errno.ENOENT, _message) + + return _file_checksum + + +## Sync: +@validate_call +def create_dir( + create_dir: constr(strip_whitespace=True, min_length=1, max_length=_path_max_length), # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Create directory if `create_dir` doesn't exist. + + Args: + create_dir (str, required): Create directory path. + warn_mode (str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + + Raises: + OSError: When warning mode is set to ERROR and directory already exists. + OSError: If failed to create directory. + """ + + if not os.path.isdir(create_dir): + try: + _message = f"Creating '{create_dir}' directory..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + os.makedirs(create_dir) + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{create_dir}' directory already exists!") + else: + logger.error(f"Failed to create '{create_dir}' directory!") + raise + + _message = f"Successfully created '{create_dir}' directory." + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + elif warn_mode == WarnEnum.ERROR: + raise OSError(errno.EEXIST, f"'{create_dir}' directory already exists!") + + return + + +@validate_call +def remove_dir( + remove_dir: constr(strip_whitespace=True, min_length=1, max_length=_path_max_length), # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Remove directory if `remove_dir` exists. + + Args: + remove_dir (str, required): Remove directory path. + warn_mode (str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + + Raises: + OSError: When warning mode is set to ERROR and directory doesn't exist. + OSError: If failed to remove directory. + """ + + if os.path.isdir(remove_dir): + try: + _message = f"Removing '{remove_dir}' directory..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + shutil.rmtree(remove_dir) + except OSError as err: + if (err.errno == errno.ENOENT) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{remove_dir}' directory doesn't exist!") + else: + logger.error(f"Failed to remove '{remove_dir}' directory!") + raise + + _message = f"Successfully removed '{remove_dir}' directory." + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + elif warn_mode == WarnEnum.ERROR: + raise OSError(errno.ENOENT, f"'{create_dir}' directory doesn't exist!") + + return + + +@validate_call +def remove_dirs( + remove_dirs: List[constr(strip_whitespace=True, min_length=1, max_length=_path_max_length)], # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Remove directories if `remove_dirs` exist. + + Args: + remove_dirs (List[str], required): Remove directory paths as list. + warn_mode (str , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + """ + + for _remove_dir in remove_dirs: + remove_dir(remove_dir=_remove_dir, warn_mode=warn_mode) + + return + + +@validate_call +def remove_file( + file_path: constr(strip_whitespace=True, min_length=1, max_length=_path_max_length), # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Remove file if `file_path` exists. + + Args: + file_path (str, required): Remove file path. + warn_mode (str, optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + + Raises: + OSError: When warning mode is set to ERROR and file doesn't exist. + OSError: If failed to remove file. + """ + + if os.path.isfile(file_path): + try: + _message = f"Removing '{file_path}' file..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + os.remove(file_path) + except OSError as err: + if (err.errno == errno.ENOENT) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{file_path}' file doesn't exist!") + else: + logger.error(f"Failed to remove '{file_path}' file!") + raise + + _message = f"Successfully removed '{file_path}' file." + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + elif warn_mode == WarnEnum.ERROR: + raise OSError(errno.ENOENT, f"'{file_path}' file doesn't exist!") + + return + + +@validate_call +def remove_files( + file_paths: List[constr(strip_whitespace=True, min_length=1, max_length=_path_max_length)], # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Remove files if `file_paths` exist. + + Args: + file_paths (List[str], required): Remove file paths as list. + warn_mode (str , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + """ + + for _file_path in file_paths: + remove_file(file_path=_file_path, warn_mode=warn_mode) + + return + + +@validate_call +def get_file_checksum( + file_path: constr(strip_whitespace=True, min_length=1, max_length=_path_max_length), # type: ignore + hash_method: HashAlgoEnum = HashAlgoEnum.md5, + chunk_size: conint(ge=10) = 4096, # type: ignore + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> str: + """Get file checksum. + + Args: + file_path (str , required): Target file path. + hash_method (HashAlgoEnum, optional): Hash method. Defaults to `HashAlgoEnum.md5`. + chunk_size (int , optional): Chunk size. Defaults to 4096. + warn_mode (str , optional): Warning message mode, for example: 'ERROR', 'ALWAYS', 'DEBUG', 'IGNORE'. Defaults to 'DEBUG'. + + Raises: + OSError: When warning mode is set to ERROR and file doesn't exist. + + Returns: + str: File checksum. + """ + + _file_checksum: str = None + if os.path.isfile(file_path): + _file_hash = hashlib.new(hash_method.value) + with open(file_path, "rb") as _file: + while True: + _file_chunk = _file.read(chunk_size) + if not _file_chunk: + break + _file_hash.update(_file_chunk) + + _file_checksum = _file_hash.hexdigest() + else: + _message = f"'{file_path}' file doesn't exist!" + if warn_mode == WarnEnum.ALWAYS: + logger.warning(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + elif warn_mode == WarnEnum.ERROR: + raise OSError(errno.ENOENT, _message) + + return _file_checksum + + +__all__ = [ + "async_create_dir", + "async_remove_dir", + "async_remove_dirs", + "async_remove_file", + "async_remove_files", + "async_get_file_checksum", + "create_dir", + "remove_dir", + "remove_dirs", + "remove_file", + "remove_files", + "get_file_checksum", +] diff --git a/src/bv_challenge/challenge/api/core/utils/_sanitizer.py b/src/bv_challenge/challenge/api/core/utils/_sanitizer.py new file mode 100644 index 0000000..80592a9 --- /dev/null +++ b/src/bv_challenge/challenge/api/core/utils/_sanitizer.py @@ -0,0 +1,86 @@ +# -*- coding: utf-8 -*- + +import re +import html +from urllib.parse import quote + +from pydantic import validate_call, constr, AnyHttpUrl + +from api.core.constants import ( + SPECIAL_CHARS_BASE_REGEX, + SPECIAL_CHARS_LOW_REGEX, + SPECIAL_CHARS_MEDIUM_REGEX, + SPECIAL_CHARS_HIGH_REGEX, + SPECIAL_CHARS_STRICT_REGEX, +) + + +@validate_call +def escape_html(val: constr(strip_whitespace=True)) -> str: # type: ignore + """Escape HTML characters. + + Args: + val (str, required): String to escape. + + Returns: + str: Escaped string. + """ + + _escaped = html.escape(val) + return _escaped + + +@validate_call +def espace_url(val: AnyHttpUrl) -> str: + """Escape URL characters. + + Args: + val (AnyHttpUrl, required): String to escape. + + Returns: + str: Escaped string. + """ + + _escaped = quote(val) + return _escaped + + +@validate_call +def clean_special_chars(val: str, mode: str = "LOW") -> str: + """Sanitize special characters. + + Args: + val (str, required): String to sanitize. + mode (str, optional): Sanitization mode. Defaults to "LOW". + + Raises: + ValueError: If `mode` is unsupported. + + Returns: + str: Sanitized string. + """ + + _pattern = r"" + mode = mode.upper() + if (mode == "BASE") or (mode == "HTML"): + _pattern = SPECIAL_CHARS_BASE_REGEX + elif mode == "LOW": + _pattern = SPECIAL_CHARS_LOW_REGEX + elif mode == "MEDIUM": + _pattern = SPECIAL_CHARS_MEDIUM_REGEX + elif (mode == "HIGH") or (mode == "SCRIPT") or (mode == "SQL"): + _pattern = SPECIAL_CHARS_HIGH_REGEX + elif mode == "STRICT": + _pattern = SPECIAL_CHARS_STRICT_REGEX + else: + raise ValueError(f"Unsupported mode: {mode}") + + _sanitized = re.sub(pattern=_pattern, repl="", string=val) + return _sanitized + + +__all__ = [ + "escape_html", + "espace_url", + "clean_special_chars", +] diff --git a/src/bv_challenge/challenge/api/core/utils/_secure.py b/src/bv_challenge/challenge/api/core/utils/_secure.py new file mode 100644 index 0000000..3680440 --- /dev/null +++ b/src/bv_challenge/challenge/api/core/utils/_secure.py @@ -0,0 +1,75 @@ +# -*- coding: utf-8 -*- + +import uuid +import string +import secrets +import hashlib + +from pydantic import validate_call, conint, constr + +from api.core.constants import HashAlgoEnum +from ._dt import now_ts + + +@validate_call +def gen_unique_id(prefix: constr(strip_whitespace=True, max_length=32) = "") -> str: # type: ignore + """Generate unique id. + + Args: + prefix (str, optional): Prefix of id. Defaults to ''. + + Returns: + str: Unique id. + """ + + _id = str(f"{prefix}{now_ts()}_{uuid.uuid4().hex}").lower() + return _id + + +@validate_call +def gen_random_string(length: conint(ge=1) = 16, is_alphanum: bool = True) -> str: # type: ignore + """Generate secure random string. + + Args: + length (int , optional): Length of random string. Defaults to 16. + is_alphanum (bool, optional): If True, generate only alphanumeric string. Defaults to True. + + Returns: + str: Generated random string. + """ + + _base_chars = string.ascii_letters + string.digits + if not is_alphanum: + _base_chars += string.punctuation + + _random_str = "".join(secrets.choice(_base_chars) for _i in range(length)) + return _random_str + + +@validate_call +def hash_str(val: str, algorithm: HashAlgoEnum = HashAlgoEnum.sha256) -> str: + """Hash a string using a specified hash algorithm. + + Args: + val (str , required): The string to hash. + algorithm (HashAlgoEnum, required): The hash algorithm to use. Defaults to `HashAlgoEnum.sha256`. + + Returns: + str: The hexadecimal representation of the digest. + """ + + if not isinstance(val, bytes): + val = val.encode("utf-8") + + _hash = hashlib.new(algorithm.value) + _hash.update(val) + + _hash_val = _hash.hexdigest() + return _hash_val + + +__all__ = [ + "gen_unique_id", + "gen_random_string", + "hash_str", +] diff --git a/src/bv_challenge/challenge/api/core/utils/_validator.py b/src/bv_challenge/challenge/api/core/utils/_validator.py new file mode 100644 index 0000000..2090990 --- /dev/null +++ b/src/bv_challenge/challenge/api/core/utils/_validator.py @@ -0,0 +1,152 @@ +# -*- coding: utf-8 -*- + +import re +from typing import List, Union, Pattern + +from pydantic import validate_call + +from api.core.constants import ( + REQUEST_ID_REGEX, + SPECIAL_CHARS_BASE_REGEX, + SPECIAL_CHARS_LOW_REGEX, + SPECIAL_CHARS_MEDIUM_REGEX, + SPECIAL_CHARS_HIGH_REGEX, + SPECIAL_CHARS_STRICT_REGEX, +) + + +@validate_call +def is_truthy(val: Union[str, bool, int, float, None]) -> bool: + """Check if the value is truthy. + + Args: + val (Union[str, bool, int, float, None], required): Value to check. + + Raises: + ValueError: If `val` argument type is string and value is invalid. + + Returns: + bool: True if the value is truthy, False otherwise. + """ + + if isinstance(val, str): + val = val.strip().lower() + + if val in ["0", "false", "f", "no", "n", "off"]: + return False + elif val in ["1", "true", "t", "yes", "y", "on"]: + return True + else: + raise ValueError(f"`val` argument value is invalid: '{val}'!") + + return bool(val) + + +@validate_call +def is_falsy(val: Union[str, bool, int, float, None]) -> bool: + """Check if the value is falsy. + + Args: + val (Union[str, bool, int, float, None], required): Value to check. + + Returns: + bool: True if the value is falsy, False otherwise. + """ + + return not is_truthy(val) + + +@validate_call +def is_request_id(val: str) -> bool: + """Check if the string is valid request ID. + + Args: + val (str, required): String to check. + + Returns: + bool: True if the string is valid request ID, False otherwise. + """ + + _is_valid = bool(re.match(pattern=REQUEST_ID_REGEX, string=val)) + return _is_valid + + +@validate_call +def is_blacklisted(val: str, blacklist: List[str]) -> bool: + """Check if the string is blacklisted. + + Args: + val (str , required): String to check. + blacklist (List[str], required): List of blacklisted strings. + + Returns: + bool: True if the string is blacklisted, False otherwise. + """ + + for _blacklisted in blacklist: + if _blacklisted in val: + return True + + return False + + +@validate_call +def is_valid(val: str, pattern: Union[Pattern, str]) -> bool: + """Check if the string is valid with given pattern. + + Args: + val (str , required): String to check. + pattern (Union[Pattern, str], required): Pattern regex to check. + + Returns: + bool: True if the string is valid with given pattern, False otherwise. + """ + + _is_valid = bool(re.match(pattern=pattern, string=val)) + return _is_valid + + +@validate_call +def has_special_chars(val: str, mode: str = "LOW") -> bool: + """Check if the string has special characters. + + Args: + val (str, required): String to check. + mode (str, optional): Check mode. Defaults to "LOW". + + Raises: + ValueError: If `mode` is unsupported. + + Returns: + bool: True if the string has special characters, False otherwise. + """ + + _has_special_chars = False + + _pattern = r"" + mode = mode.upper() + if (mode == "BASE") or (mode == "HTML"): + _pattern = SPECIAL_CHARS_BASE_REGEX + elif mode == "LOW": + _pattern = SPECIAL_CHARS_LOW_REGEX + elif mode == "MEDIUM": + _pattern = SPECIAL_CHARS_MEDIUM_REGEX + elif (mode == "HIGH") or (mode == "SCRIPT") or (mode == "SQL"): + _pattern = SPECIAL_CHARS_HIGH_REGEX + elif mode == "STRICT": + _pattern = SPECIAL_CHARS_STRICT_REGEX + else: + raise ValueError(f"Unsupported mode: {mode}") + + _has_special_chars = bool(re.search(pattern=_pattern, string=val)) + return _has_special_chars + + +__all__ = [ + "is_truthy", + "is_falsy", + "is_request_id", + "is_blacklisted", + "is_valid", + "has_special_chars", +] diff --git a/src/bv_challenge/challenge/api/databases/__init__.py b/src/bv_challenge/challenge/api/databases/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/src/bv_challenge/challenge/api/endpoints/challenge/__init__.py b/src/bv_challenge/challenge/api/endpoints/challenge/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/src/bv_challenge/challenge/api/endpoints/challenge/router.py b/src/bv_challenge/challenge/api/endpoints/challenge/router.py index 98ffc0b..667af33 100644 --- a/src/bv_challenge/challenge/api/endpoints/challenge/router.py +++ b/src/bv_challenge/challenge/api/endpoints/challenge/router.py @@ -1,12 +1,18 @@ -from fastapi import APIRouter, Request, HTTPException -from fastapi.responses import JSONResponse +# -*- coding: utf-8 -*- -from api.core.constants import ErrorCodeEnum -from api.core.exceptions import BaseHTTPException +from fastapi import APIRouter, Request, HTTPException, Body +from fastapi.responses import HTMLResponse, JSONResponse + +from api.core.responses import BaseResponse +from api.endpoints.challenge.schemas import ( + MinerInput, + MinerOutput, + EvalPayload, + RandomValRequest, +) +from api.endpoints.challenge import service from api.logger import logger -from .schemas import MinerInput, MinerOutput -from . import service router = APIRouter(tags=["Challenge"]) @@ -14,7 +20,7 @@ @router.get( "/task", summary="Get task", - description="This endpoint returns the task for the miner.", + description="This endpoint returns the webpage URL for the challenge.", response_class=JSONResponse, response_model=MinerInput, ) @@ -28,14 +34,14 @@ def get_task(request: Request): _miner_input = service.get_task() logger.success(f"[{_request_id}] - Successfully got the task.") - except HTTPException: - raise - except Exception: - logger.exception(f"[{_request_id}] - Failed to get task!") - raise BaseHTTPException( - error_enum=ErrorCodeEnum.INTERNAL_SERVER_ERROR, - message="Failed to get task!", + except Exception as err: + if isinstance(err, HTTPException): + raise + + logger.error( + f"[{_request_id}] - Failed to get task!", ) + raise return _miner_input @@ -45,27 +51,149 @@ def get_task(request: Request): summary="Score", description="This endpoint score miner output.", response_class=JSONResponse, - responses={422: {}}, + responses={400: {}, 422: {}}, ) -def post_score(request: Request, miner_input: MinerInput, miner_output: MinerOutput): +def post_score( + request: Request, + miner_input: MinerInput, + miner_output: MinerOutput, +): _request_id = request.state.request_id - logger.info(f"[{_request_id}] - Scoring the miner output...") + logger.info(f"[{_request_id}] - Evaluating the miner output...") _score: float = 0.0 try: - _score = service.score(request_id=_request_id, miner_output=miner_output) - logger.success( - f"[{_request_id}] - Successfully scored the miner output: {_score}" + + _score = service.score(miner_output=miner_output) + + logger.success(f"[{_request_id}] - Successfully evaluated the miner output.") + except Exception as err: + if isinstance(err, HTTPException): + # raise + logger.error( + f"[{_request_id}] - Failed to evaluate the miner output!", + ) + + logger.error( + f"[{_request_id}] - Failed to evaluate the miner output!", + ) + # raise + return None + logger.success(f"[{_request_id}] - Successfully scored the miner output: {_score}") + return _score + + +@router.get( + "/_web", + summary="Serves the webpage", + description="This endpoint serves the webpage for the challenge.", + response_class=HTMLResponse, + responses={429: {}}, +) +def _get_web(request: Request): + + _request_id = request.state.request_id + logger.info(f"[{_request_id}] - Getting webpage...") + + _html_response: HTMLResponse + try: + _html_response = service.get_web(request=request) + + logger.success(f"[{_request_id}] - Successfully got the webpage.") + except Exception as err: + if isinstance(err, HTTPException): + raise + + logger.error( + f"[{_request_id}] - Failed to get the webpage!", ) - except HTTPException: raise - except Exception: - logger.exception(f"[{_request_id}] - Failed to score the miner output!") - raise BaseHTTPException( - error_enum=ErrorCodeEnum.INTERNAL_SERVER_ERROR, - message="Failed to score the miner output!", + + return _html_response + + +@router.post( + "/_random_val", + summary="Random value", + responses={401: {}, 422: {}, 429: {}}, +) +def post_random_val(request: Request, payload: RandomValRequest): + _request_id = request.state.request_id + logger.info(f"[{_request_id}] - Checking random val...") + + random_val = payload.random_val.strip() + nonce_val: str + try: + nonce_val = service.get_random_val(nonce=random_val) + logger.success(f"[{_request_id}] - Successfully checked the random val.") + except Exception as err: + if isinstance(err, HTTPException): + raise + logger.error(f"[{_request_id}] - Failed to check the random val!") + raise + + _response = {"nonce_val": nonce_val} + return _response + + +@router.post( + "/_eval", + summary="Evaluate", + description="This endpoint evaluate.", + responses={422: {}, 429: {}}, +) +def _post_eval_bot( + request: Request, + payload: EvalPayload, +): + _request_id = request.state.request_id + logger.info(f"[{_request_id}] - Evaluating the bot...") + + try: + # Extract the data from the nested structure + data = payload.error.data + service.eval_bot(data=data) + + logger.success(f"[{_request_id}] - Successfully evaluated the bot.") + except Exception as err: + if isinstance(err, HTTPException): + raise + + logger.error( + f"[{_request_id}] - Failed to evaluate the bot!", + ) + raise + + _response = BaseResponse(request=request, message="Successfully evaluated the bot.") + return _response + + +@router.post( + "/compare", + summary="Compare miner outputs", + description="This endpoint compares a miner's output to a reference output.", + responses={422: {}, 500: {}}, +) +def post_compare( + request: Request, + miner_output: dict = Body(...), + reference_output: dict = Body(...), + miner_input: dict = Body(...), +): + _request_id = request.state.request_id + logger.info(f"[{_request_id}] - Comparing miner outputs...") + + try: + _score = service.compare_outputs( + miner_input=miner_input, + miner_output=miner_output, + reference_output=reference_output, ) + logger.success(f"[{_request_id}] - Successfully compared miner outputs.") + except Exception as err: + logger.error(f"[{_request_id}] - Error comparing miner outputs: {str(err)}") + raise HTTPException(status_code=500, detail="Error in comparison request") return _score diff --git a/src/bv_challenge/challenge/api/endpoints/challenge/schemas.py b/src/bv_challenge/challenge/api/endpoints/challenge/schemas.py index 6742abf..4cce9b0 100644 --- a/src/bv_challenge/challenge/api/endpoints/challenge/schemas.py +++ b/src/bv_challenge/challenge/api/endpoints/challenge/schemas.py @@ -1,57 +1,193 @@ -from pydantic import BaseModel, Field, field_validator +# -*- coding: utf-8 -*- -from potato_util.generator import gen_random_string +import os +import pathlib +from typing import Optional, Union, List, Dict, Any +from pydantic import BaseModel, Field, constr, field_validator -class MinerInput(BaseModel): - random_val: str | None = Field( - default_factory=gen_random_string, - title="Random Value", +from api.core.constants import ( + ALPHANUM_REGEX, + ALPHANUM_HOST_REGEX, + ALPHANUM_EXTEND_REGEX, + REQUIREMENTS_REGEX, + ALPHANUM_CUSTOM_REGEX, +) +from api.config import config +from api.core import utils + + +_src_dir = pathlib.Path(__file__).parent.parent.parent.parent.resolve() +_bot_dir = _src_dir / "bot" +_bot_core_dir = _bot_dir / "src" / "core" + +_bot_py_path = str(_bot_core_dir / "bot.py") +_bot_py_content = "def run_bot(driver):\n print('Hello, World!')" +if os.path.exists(_bot_py_path): + with open(_bot_py_path, "r") as _bot_py_file: + _bot_py_content = _bot_py_file.read() + +_dockerfile_path = str(_bot_dir / "Dockerfile") +_dockerfile_content = """FROM redteamsubnet61/bv-bot-base:latest +COPY requirements.txt . +RUN python3 -m pip install -r requirements.txt +COPY ./src . +ENTRYPOINT [ "docker-entrypoint.sh" ]""" +if os.path.exists(_dockerfile_path): + with open(_dockerfile_path, "r") as _dockerfile_file: + _dockerfile_content = _dockerfile_file.read() + + + +class KeyPairPM(BaseModel): + private_key: str = Field( + ..., + min_length=32, + title="Private Key", + description="Private key as a string.", + ) + public_key: Union[str, None] = Field( + ..., + min_length=32, + title="Public Key", + description="Public key as a string.", + ) + nonce: Union[ + constr( + strip_whitespace=True, + min_length=4, + max_length=64, + pattern=ALPHANUM_REGEX, + ), # type: ignore + None, + ] = Field( + ..., + title="Nonce", description="Random value to prevent caching.", examples=["a1b2c3d4e5f6g7h8"], ) -class CommitFilePM(BaseModel): - file_name: str = Field( +class MinerFilePM(BaseModel): + fname: constr(strip_whitespace=True) = Field( # type: ignore ..., min_length=4, max_length=64, + pattern=ALPHANUM_HOST_REGEX, title="File Name", description="Name of the file.", - examples=["solution.js"], + examples=["config.py"], ) - content: str = Field( + content: constr(strip_whitespace=True) = Field( # type: ignore ..., min_length=2, title="File Content", description="Content of the file as a string.", - examples=["console.log('Challenge accepted!');"], + examples=["threshold = 0.5"], + ) + + @field_validator("fname") + @classmethod + def _check_fname(cls, val: str) -> str: + + if not isinstance(val, str): + raise TypeError("File name must be a string!") + + if val.startswith("."): + raise ValueError("File name cannot start with a dot(.)!") + + _allowed_exts = config.challenge.allowed_file_exts + if not val.endswith(tuple(_allowed_exts)): + raise ValueError( + f"File extension is not supported, only '{_allowed_exts}' extensions are allowed!" + ) + + return val + + +class MinerInput(BaseModel): + random_val: Optional[ + constr( + strip_whitespace=True, min_length=4, max_length=64, pattern=ALPHANUM_REGEX + ) # type: ignore + ] = Field( + default_factory=utils.gen_random_string, + title="Random Value", + description="Random value to prevent caching.", + examples=["a1b2c3d4e5f6g7h8"], ) class MinerOutput(BaseModel): - commit_files: list[CommitFilePM] = Field( + bot_py: str = Field( + ..., + title="bot.py", + min_length=2, + description="The main bot.py source code for the challenge.", + examples=[_bot_py_content], + ) + dockerfile: str = Field( ..., - title="Commit Files", - description="List of Commit files for the challenge.", + title="Dockerfile", + min_length=2, + description="Dockerfile to build the bot container", + examples=[_dockerfile_content], + ) + score_job_id: str = Field( + default="", + max_length=128, + description=( + "Optional caller-supplied job ID. Forwarded to vm-runner so the bot " + "container is named bot_container_ and labeled score_job_id=, " + "enabling external log streaming." + ), ) - @field_validator("commit_files", mode="after") + @field_validator("bot_py", mode="after") @classmethod - def _check_commit_files(cls, val: list[CommitFilePM]) -> list[CommitFilePM]: - for _miner_file_pm in val: - _content_lines = _miner_file_pm.content.splitlines() - if len(_content_lines) > 500: - raise ValueError( - f"`{_miner_file_pm.file_name}` file contains too many lines, should be <= 500 lines!" - ) + def _check_bot_py_lines(cls, val: str) -> str: + _lines = val.split("\n") + if len(_lines) > 2000: + raise ValueError("bot_py content is too long, max 2000 lines are allowed!") + return val + @field_validator("dockerfile", mode="after") + @classmethod + def _check_dockerfile_lines(cls, val: str) -> str: + _lines = val.split("\n") + if len(_lines) > 500: + raise ValueError("Dockerfile content is too long, max 500 lines are allowed!") return val +class ErrorData(BaseModel): + data: str = Field( + ..., + min_length=2, + pattern=ALPHANUM_CUSTOM_REGEX, + description="Bot data to evaluate.", + examples=["data"], + ) + + +class EvalPayload(BaseModel): + error: ErrorData + + +class RandomValRequest(BaseModel): + random_val: str = Field( + ..., + min_length=4, + max_length=64, + pattern=ALPHANUM_REGEX, + title="Random value", + description="Random value.", + examples=["a1b2c3d4e5f6g7h8"] + ) __all__ = [ + "KeyPairPM", "MinerInput", - "CommitFilePM", "MinerOutput", + "EvalPayload", + "RandomValRequest" ] diff --git a/src/bv_challenge/challenge/api/endpoints/challenge/service.py b/src/bv_challenge/challenge/api/endpoints/challenge/service.py index 488f3bb..f63d257 100644 --- a/src/bv_challenge/challenge/api/endpoints/challenge/service.py +++ b/src/bv_challenge/challenge/api/endpoints/challenge/service.py @@ -1,22 +1,343 @@ -import random +# -*- coding: utf-8 -*- + +import os +import time +import json +import pathlib +from typing import List, Union, Dict, Tuple from pydantic import validate_call +from fastapi import Request +from fastapi.responses import HTMLResponse +from fastapi.templating import Jinja2Templates +# from rt_comparer import RTComparer + +# try: +# from modules.rt_bv_score import MetricsProcessor # type: ignore +# except ImportError: +# from rt_bv_score import MetricsProcessor # type: ignore + +from api.core.constants import ErrorCodeEnum +from api.core import utils +from api.config import config +from api.core.exceptions import BaseHTTPException +from api.helpers.crypto import asymmetric as asymmetric_helper +from api.endpoints.challenge.schemas import KeyPairPM, MinerInput, MinerOutput +from api.endpoints.challenge import utils as ch_utils +from api.logger import logger + + +_src_dir = pathlib.Path(__file__).parent.parent.parent.parent.resolve() + + +class TaskManager: + """ + Task Manager for handling key pairs, action lists, and evaluation metrics + during challenge sessions. + """ + + @validate_call + def __init__(self, uid: str = None): + self.uid = uid + self.reset_tasks() + self.scores = [] + + def reset_tasks(self) -> None: + """Reset all tasks, regenerate key pairs and action lists""" + self._actions_idx = 0 + + # Generate key pairs + self.key_pairs = ch_utils.gen_key_pairs( + n_challenge=config.challenge.n_run_per_ch, + key_size=config.api.security.asymmetric.key_size, + ) + + # Generate challenge actions + self.challenges_action_list = ch_utils.gen_cb_actions( + n_challenge=config.challenge.n_ch_per_epoch, + window_width=config.challenge.window_width, + window_height=config.challenge.window_height, + n_checkboxes=config.challenge.n_checkboxes, + min_distance=config.challenge.cb_min_distance, + max_factor=config.challenge.cb_gen_max_factor, + checkbox_size=config.challenge.cb_size, + exclude_areas=config.challenge.cb_exclude_areas, + pre_action_list=config.challenge.cb_pre_action_list, + ) + + # Reset current task properties + self.cur_key_pair = None + self.cur_score = None + self.scores = [] + + def pop_task(self) -> Union[KeyPairPM, List[Dict]]: + """Get the next task (key pair and action list)""" + if not self.key_pairs: + return None + + self.cur_key_pair = self.key_pairs.pop(0) + return self.cur_key_pair + + def has_remaining_tasks(self) -> bool: + """Check if there are remaining tasks""" + return len(self.key_pairs) > 0 + + def get_remaining_task_count(self) -> int: + """Get the number of remaining tasks""" + return len(self.key_pairs) -from .schemas import MinerInput, MinerOutput + def record_score(self, score: float) -> None: + """Record a score from the current session""" + self.scores.append(score) + + def is_last_session(self) -> bool: + """Check if this is the last session in the epoch""" + _current_session = len(self.scores) + 1 + _total_sessions = config.challenge.n_run_per_ch + logger.info( + f"Session progress: {_current_session}/{_total_sessions} completed" + ) + return _current_session == _total_sessions + + def get_nonce(self) -> str: + _nonce_key: str = self.cur_key_pair.public_key + self.cur_key_pair.public_key = None + self.cur_key_pair.nonce = None + return _nonce_key + + def get_private_key(self) -> str: + _private_key: str = self.cur_key_pair.private_key + self.cur_key_pair.private_key = None + return _private_key + + def get_session_info(self) -> Dict: + """Get information about current session for VM execution""" + return { + "total_sessions": config.challenge.n_run_per_ch, + "nonce": self.cur_key_pair.nonce if self.cur_key_pair else None, + } + + +# Initialize the task manager as a global variable +global tm +tm = TaskManager() def get_task() -> MinerInput: - return MinerInput() + """Get the task for the miner""" + _miner_input = MinerInput() + return _miner_input @validate_call -def score(request_id: str, miner_output: MinerOutput) -> float: +def score(miner_output: MinerOutput) -> float: + """Score the miner output by sending to external VM""" + _score = 0.0 + _num_tasks = config.challenge.n_ch_per_epoch * config.challenge.n_run_per_ch + + # Reset the task manager if needed + if not tm.has_remaining_tasks(): + tm.reset_tasks() + + if tm.get_remaining_task_count() < _num_tasks: + tm.reset_tasks() + + try: + # Get the next task + task = tm.pop_task() + tm.cur_score = None + if not task: + raise BaseHTTPException( + error_enum=ErrorCodeEnum.TOO_MANY_REQUESTS, + message="No initialized key pairs or action lists, or out of tasks!", + ) + + # Send build and run request to external VM + logger.info("Sending bot to external VM for build and execution...") + _vm_response = ch_utils.send_build_and_run_request( + vm_endpoint=config.challenge.vm_endpoint, + bot_py=miner_output.bot_py, + dockerfile=miner_output.dockerfile, + session_count=config.challenge.n_run_per_ch, + timeout=config.challenge.vm_timeout, + ssl_verify=config.challenge.vm_ssl_verify, + score_job_id=miner_output.score_job_id, + ) + + # Wait for all sessions to complete and metrics to be collected + _i = 0 + while True: + if len(tm.scores) >= config.challenge.n_run_per_ch: + _score = sum(tm.scores) / len(tm.scores) + logger.info("Successfully scored the miner output.") + break + + logger.info(f"Waiting for the bot to finish... {tm.scores[-1] is not None}") + time.sleep(1) + _i += 1 + + if config.challenge.bot_timeout < _i: + logger.error("Timeout error: Bot running too long or failed to finish!") + break + + except Exception as err: + if isinstance(err, BaseHTTPException): + raise + + logger.error(f"Failed to score the miner output: {str(err)}!") + raise + + return _score + + +@validate_call(config={"arbitrary_types_allowed": True}) +def get_web(request: Request) -> HTMLResponse: + """Get the web interface for the challenge""" + _nonce = None + if tm.cur_key_pair: + _nonce = tm.cur_key_pair.nonce + else: + _nonce = utils.gen_random_string() + logger.warning( + "Not initialized key pair, this endpoint is shouldn't be called directly!" + ) + _key_pair: Tuple[str, str] = asymmetric_helper.gen_key_pair( + key_size=config.api.security.asymmetric.key_size, as_str=True + ) + _, _public_key = _key_pair + _templates = Jinja2Templates(directory=(_src_dir / "./templates/html")) + _html_response = _templates.TemplateResponse( + request=request, + name="index.html", + context={ + "nonce": _nonce, + "public_key": _public_key, + "actions_list": tm.challenges_action_list, + }, + ) + return _html_response + + +@validate_call +def get_random_val(nonce: str) -> str: + """Get the random value for the nonce""" + if not tm.cur_key_pair: + raise BaseHTTPException( + error_enum=ErrorCodeEnum.BAD_REQUEST, + message="Not initialized key pair or out of key pair, this endpoint is shouldn't be called directly!", + ) + + if tm.cur_key_pair.nonce != nonce: + raise BaseHTTPException( + error_enum=ErrorCodeEnum.UNAUTHORIZED, + message="Invalid nonce value!", + ) + + if not tm.cur_key_pair.public_key: + raise BaseHTTPException( + error_enum=ErrorCodeEnum.TOO_MANY_REQUESTS, + message="Nonce is already retrieved!", + ) + + _nonce_key = tm.get_nonce() + return _nonce_key + + +@validate_call +def eval_bot(data: str) -> None: + """Evaluate the bot performance""" + if not tm.cur_key_pair: + raise BaseHTTPException( + error_enum=ErrorCodeEnum.BAD_REQUEST, + message="Not initialized key pair or out of key pair, this endpoint is shouldn't be called directly!", + ) + + _private_key: str = tm.get_private_key() + + logger.debug("Evaluating the bot...") + + try: + _plaintext = ch_utils.decrypt(ciphertext=data, private_key=_private_key) + _plain_data = json.loads(_plaintext) + + + _metrics_processor = "MetricsProcessor()" + # _result = _metrics_processor(data=_plain_data) + _cur_session_score = 0.5 + + logger.info(f"Bot evaluation result: {_cur_session_score}") + tm.cur_score = _cur_session_score + tm.record_score(_cur_session_score) + logger.info(f"Bot current score: {tm.cur_score}") + + # Reset for next epoch + tm.cur_key_pair = None + tm.pop_task() + + logger.debug("Successfully evaluated the bot.") + except Exception as err: + if isinstance(err, BaseHTTPException): + raise + + logger.error(f"Failed to evaluate the bot: {str(err)}!") + raise + + return + + +def compare_outputs(miner_input, miner_output, reference_output) -> dict: + """ + Compare miner's output against a reference output using CFGAnalyser and CFGComparer. + + Args: + miner_input (dict): The input used for both miner outputs. + miner_output (dict): The output from the current miner (expects "bot_py" key). + reference_output (dict): The reference output. + + Returns: + dict: Similarity score and reason. + """ + try: + logger.info("Analyzing miner output...") + + _miner_code = miner_output["bot_py"] + _reference_code = reference_output["bot_py"] + + if not _miner_code or not _reference_code: + logger.error("Missing bot_py in miner_output or reference_output.") + return { + "similarity_score": 0.0, + "reason": "Missing bot_py in miner_output or reference_output", + } + + _result = """RTComparer().compare( + challenge="bot-virus-challenge", + miner_script=_miner_code, + reference_script=_reference_code, + )""" + + _similarity_score = _result.get("similarity_score", 0.0) + _reason = _result.get("reason", "Unknown") + logger.info(f"Similarity Score: {_similarity_score}") + logger.info(f"Similarity Reason: {_reason}") + + try: + _similarity_score = float(_similarity_score) + except Exception: + _similarity_score = 0.0 + + return {"similarity_score": _similarity_score, "reason": _reason} - _score_result = random.random() # nosec B311 - return _score_result + except Exception as err: + logger.error(f"Error in compare_outputs function: {str(err)}") + return {"similarity_score": 0.0, "reason": str(err)} __all__ = [ "get_task", + "get_web", + "get_random_val", "score", + "eval_bot", + "compare_outputs", ] diff --git a/src/bv_challenge/challenge/api/endpoints/challenge/utils.py b/src/bv_challenge/challenge/api/endpoints/challenge/utils.py new file mode 100644 index 0000000..135faf5 --- /dev/null +++ b/src/bv_challenge/challenge/api/endpoints/challenge/utils.py @@ -0,0 +1,215 @@ +# -*- coding: utf-8 -*- + +import os +import re +import time +import shutil +import random +import requests +import subprocess +from datetime import datetime, timezone +from typing import List, Dict, Union, Tuple, Optional + +import vault_unlock +from api.config import config +import docker +from docker.models.networks import Network +from docker import DockerClient +from pydantic import validate_call + +from api.core.constants import ErrorCodeEnum, ENV_PREFIX +from api.core import utils +from api.core.exceptions import BaseHTTPException +from api.helpers.crypto import asymmetric as asymmetric_helper +from api.endpoints.challenge.schemas import KeyPairPM, MinerOutput +from api.logger import logger + + +@validate_call +def gen_key_pairs(n_challenge: int, key_size: int) -> List[KeyPairPM]: + + _key_pairs: List[KeyPairPM] = [] + for _ in range(n_challenge): + _key_pair: Tuple[str, str] = asymmetric_helper.gen_key_pair( + key_size=key_size, as_str=True + ) + _private_key, _public_key = _key_pair + _nonce = utils.gen_random_string(length=32) + _key_pair_pm = KeyPairPM( + private_key=_private_key, public_key=_public_key, nonce=_nonce + ) + _key_pairs.append(_key_pair_pm) + + return _key_pairs + +@validate_call +def gen_cb_actions( + n_challenge: int = 10, + window_width: int = 1420, + window_height: int = 740, + n_checkboxes: int = 5, + min_distance: int = 300, + max_factor: int = 10, + checkbox_size: int = 20, # Assuming checkbox size ~20px + exclude_areas: Union[List[Dict[str, int]], None] = None, + pre_action_list: Union[ + List[Dict[str, Union[int, str, Dict[str, Dict[str, int]]]]], None + ] = None, +) -> List[Dict[str, Union[int, str, Dict[str, Dict[str, int]]]]]: + + _max_attempts = n_checkboxes * max_factor # Avoid infinite loops + + _challenge_list = [] + for _ in range(n_challenge): + _n_attempts = 0 + _i = 0 + _action_list = [] + + if pre_action_list: + _action_list = pre_action_list + while len(_action_list) < n_checkboxes: + _x = random.randint(checkbox_size, window_width - checkbox_size) + _y = random.randint(checkbox_size, window_height - checkbox_size) + + _is_near = False + _i = len(_action_list) + for _action in _action_list: + if _action["type"] == "click": + ## Calculate distance between two points using Euclidean distance: + if (_x - _action["args"]["location"]["x"]) ** 2 + ( + _y - _action["args"]["location"]["y"] + ) ** 2 < min_distance**2: + _is_near = True + break + + _is_in_area = False + if exclude_areas: + for _area in exclude_areas: + if (_area["x1"] <= _x <= _area["x2"]) and ( + _area["y1"] <= _y <= _area["y2"] + ): + _is_in_area = True + break + + if (not _is_near) and (not _is_in_area): + _action = { + "id": _i, + "type": "click", + "args": {"location": {"x": _x, "y": _y}}, + } + _action_list.append(_action) + + _n_attempts += 1 + + if _max_attempts <= _n_attempts: + logger.warning("Skipped generating positions due to max attempts!") + break + _next_id = len(_action_list) + _action_list.extend( + [ + { + "id": _next_id, + "type": "input", + "selector": { + "name": "username", + "id": utils.gen_random_string(length=32), + }, + "args": {"text": utils.gen_random_string(length=32)}, + }, + { + "id": _next_id + 1, + "type": "input", + "selector": { + "name": "password", + "id": utils.gen_random_string(length=32), + }, + "args": {"text": utils.gen_random_string(length=32)}, + }, + ] + ) + _challenge_list.append(_action_list) + + return _challenge_list + +@validate_call +def decrypt(ciphertext: str, private_key: str) -> str: + + _plaintext: str = vault_unlock.decrypt_payload( + encrypted_text=ciphertext, private_key_pem=private_key + ) + return _plaintext + + +@validate_call +def send_build_and_run_request( + vm_endpoint: str, + bot_py: str, + dockerfile: str, + session_count: int, + timeout: int = 120, + ssl_verify: bool = True, + score_job_id: str = "", +) -> Dict: + """ + Send build and run request to external VM. + + Args: + vm_endpoint: VM endpoint URL + bot_py: Bot Python code + dockerfile: Dockerfile content + session_count: Number of sessions to run + timeout: Request timeout in seconds + ssl_verify: Whether to verify SSL certificates + + Returns: + Response from VM containing session results + + Raises: + requests.RequestException: If request fails + ValueError: If response is invalid + """ + logger.info(f"Sending build and run request to VM: {vm_endpoint}") + + try: + _payload = { + "bot_py": bot_py, + "dockerfile": dockerfile, + "session_count": session_count, + "score_job_id": score_job_id, + } + + _response = requests.post( + f"{vm_endpoint}/build_and_run", + json=_payload, + timeout=timeout, + verify=ssl_verify, + ) + + if _response.status_code != 200: + logger.error( + f"VM request failed with status {_response.status_code}: {_response.text}" + ) + raise ValueError( + f"VM request failed with status {_response.status_code}: {_response.text}" + ) + + _result = _response.json() + logger.success("Successfully received response from VM") + return _result + + except requests.Timeout: + logger.error(f"VM request timed out after {timeout} seconds") + raise + except requests.RequestException as err: + logger.error(f"VM request failed: {str(err)}") + raise + except Exception as err: + logger.error(f"Unexpected error during VM request: {str(err)}") + raise + + +__all__ = [ + "gen_key_pairs", + "decrypt", + "send_build_and_run_request", +] diff --git a/src/bv_challenge/challenge/api/exception.py b/src/bv_challenge/challenge/api/exception.py index 0089a51..e462e88 100644 --- a/src/bv_challenge/challenge/api/exception.py +++ b/src/bv_challenge/challenge/api/exception.py @@ -1,3 +1,5 @@ +# -*- coding: utf-8 -*- + from pydantic import validate_call from fastapi import FastAPI, HTTPException from fastapi.exceptions import RequestValidationError @@ -24,7 +26,7 @@ def add_exception_handlers(app: FastAPI) -> None: app.add_exception_handler(500, server_error_handler) app.add_exception_handler(HTTPException, http_exception_handler) app.add_exception_handler(RequestValidationError, validation_error_handler) - # Add more exception handlers here... + ## Add more exception handlers here... return diff --git a/src/bv_challenge/challenge/api/helpers/__init__.py b/src/bv_challenge/challenge/api/helpers/__init__.py index e69de29..40a96af 100644 --- a/src/bv_challenge/challenge/api/helpers/__init__.py +++ b/src/bv_challenge/challenge/api/helpers/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/bv_challenge/challenge/api/helpers/crypto/__init__.py b/src/bv_challenge/challenge/api/helpers/crypto/__init__.py new file mode 100644 index 0000000..40a96af --- /dev/null +++ b/src/bv_challenge/challenge/api/helpers/crypto/__init__.py @@ -0,0 +1 @@ +# -*- coding: utf-8 -*- diff --git a/src/bv_challenge/challenge/api/helpers/crypto/asymmetric.py b/src/bv_challenge/challenge/api/helpers/crypto/asymmetric.py new file mode 100644 index 0000000..6c4b95a --- /dev/null +++ b/src/bv_challenge/challenge/api/helpers/crypto/asymmetric.py @@ -0,0 +1,626 @@ +# -*- coding: utf-8 -*- + +import os +import errno +import base64 +from typing import Tuple, Union + +import aiofiles +from cryptography.hazmat.primitives.asymmetric import rsa, padding +from cryptography.hazmat.primitives import serialization, hashes +from cryptography.hazmat.primitives.asymmetric.types import ( + PrivateKeyTypes, + PublicKeyTypes, +) +from pydantic import validate_call +from beans_logging import logger + +from api.core.constants import WarnEnum +from api.core import utils + + +@validate_call +def gen_key_pair( + key_size: int, + as_str: bool = False, +) -> Tuple[Union[PrivateKeyTypes, str], Union[PublicKeyTypes, str]]: + + _private_key: PrivateKeyTypes = rsa.generate_private_key( + public_exponent=65537, key_size=key_size + ) + _public_key: PublicKeyTypes = _private_key.public_key() + + if as_str: + _private_key: bytes = _private_key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.PKCS8, + encryption_algorithm=serialization.NoEncryption(), + ).decode() + + _public_key: bytes = _public_key.public_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PublicFormat.SubjectPublicKeyInfo, + ).decode() + + return _private_key, _public_key + + +@validate_call +async def async_create_keys( + asymmetric_keys_dir: str, + key_size: int, + private_key_fname: str, + public_key_fname: str, + force: bool = False, + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Async generate and create asymmetric key files. + + Args: + asymmetric_keys_dir (str , required): Asymmetric keys directory. + key_size (int , required): Asymmetric key size. + private_key_fname (str , required): Asymmetric private key filename. + public_key_fname (str , required): Asymmetric public key filename. + force (bool , optional): Force to create asymmetric keys. Defaults to False. + warn_mode (WarnEnum, optional): Warning mode. Defaults to WarnEnum.DEBUG. + + Raises: + FileExistsError: If warning mode is ERROR and asymmetric keys already exist. + OSError : If failed to create asymmetric keys. + """ + + _private_key_path = os.path.join(asymmetric_keys_dir, private_key_fname) + _public_key_path = os.path.join(asymmetric_keys_dir, public_key_fname) + + if force: + await utils.async_remove_file(file_path=_private_key_path, warn_mode=warn_mode) + await utils.async_remove_file(file_path=_public_key_path, warn_mode=warn_mode) + + if (await aiofiles.os.path.isfile(_private_key_path)) and ( + await aiofiles.os.path.isfile(_public_key_path) + ): + logger.trace( + f"Asymmetric keys already exist: ['{_private_key_path}', '{_public_key_path}']" + ) + return + + _message = ( + f"Generating asymmetric keys: ['{_private_key_path}', '{_public_key_path}']..." + ) + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + _private_key: PrivateKeyTypes + if await aiofiles.os.path.isfile(_private_key_path): + if warn_mode == WarnEnum.ERROR: + raise FileExistsError(f"'{_private_key_path}' private key already exists!") + + _private_key: PrivateKeyTypes = await async_get_private_key( + private_key_path=_private_key_path + ) + else: + _private_key: PrivateKeyTypes = rsa.generate_private_key( + public_exponent=65537, key_size=key_size + ) + + if await aiofiles.os.path.isfile(_public_key_path): + if warn_mode == WarnEnum.ERROR: + raise FileExistsError(f"'{_public_key_path}' public key already exists!") + + await utils.async_remove_file(file_path=_public_key_path, warn_mode=warn_mode) + + _public_key = _private_key.public_key() + + _private_pem = _private_key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.PKCS8, + encryption_algorithm=serialization.NoEncryption(), + ) + + _public_pem = _public_key.public_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PublicFormat.SubjectPublicKeyInfo, + ) + + await utils.async_create_dir(create_dir=asymmetric_keys_dir, warn_mode=warn_mode) + + if not await aiofiles.os.path.isfile(_private_key_path): + try: + async with aiofiles.open(_private_key_path, "wb") as _private_key_file: + await _private_key_file.write(_private_pem) + + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{_private_key_path}' private key already exists!") + else: + logger.error(f"Failed to create '{_private_key_path}' private key!") + raise + + if not await aiofiles.os.path.isfile(_public_key_path): + try: + async with aiofiles.open(_public_key_path, "wb") as _public_key_file: + await _public_key_file.write(_public_pem) + + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{_public_key_path}' public key already exists!") + else: + logger.error(f"Failed to create '{_public_key_path}' public key!") + raise + + _message = f"Successfully generated asymmetric keys: ['{_private_key_path}', '{_public_key_path}']" + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + return + + +@validate_call +async def async_get_private_key( + private_key_path: str, as_str: bool = False +) -> Union[PrivateKeyTypes, str]: + """Async read asymmetric private key from file. + + Args: + private_key_path (str , required): Asymmetric private key path. + as_str (bool, optional): Return private key as string. Defaults to False. + + Raises: + FileNotFoundError: If Asymmetric private key file not found. + + Returns: + Union[PrivateKeyTypes, str]: Asymmetric private key. + """ + + if not await aiofiles.os.path.isfile(private_key_path): + raise FileNotFoundError(f"Not found '{private_key_path}' private key!") + + logger.debug(f"Reading '{private_key_path}' private key...") + _private_key: PrivateKeyTypes + async with aiofiles.open(private_key_path, "rb") as _private_key_file: + _private_key_bytes: bytes = await _private_key_file.read() + _private_key: PrivateKeyTypes = serialization.load_pem_private_key( + data=_private_key_bytes, password=None + ) + + if as_str: + _private_key = _private_key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.PKCS8, + encryption_algorithm=serialization.NoEncryption(), + ).decode() + + logger.debug(f"Successfully read '{private_key_path}' private key.") + + return _private_key + + +@validate_call +async def async_get_public_key( + public_key_path: str, as_str: bool = False +) -> Union[PublicKeyTypes, str]: + """Async read asymmetric public key from file. + + Args: + public_key_path (str , required): Asymmetric public key path. + as_str (bool, optional): Return public key as string. Defaults to False. + + Raises: + FileNotFoundError: If asymmetric public key file not found. + + Returns: + Union[PublicKeyTypes, str]: Asymmetric public key. + """ + + if not await aiofiles.os.path.isfile(public_key_path): + raise FileNotFoundError(f"Not found '{public_key_path}' public key!") + + logger.debug(f"Reading '{public_key_path}' public key...") + _public_key: PublicKeyTypes + async with aiofiles.open(public_key_path, "rb") as _public_key_file: + _public_key_bytes: bytes = await _public_key_file.read() + _public_key: PublicKeyTypes = serialization.load_pem_public_key( + data=_public_key_bytes + ) + + if as_str: + _public_key = _public_key.public_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PublicFormat.SubjectPublicKeyInfo, + ).decode() + + logger.debug(f"Successfully read '{public_key_path}' public key.") + + return _public_key + + +@validate_call +async def async_get_keys( + private_key_path: str, public_key_path: str, as_str: bool = False +) -> Tuple[Union[PrivateKeyTypes, str], Union[PublicKeyTypes, str]]: + """Async read asymmetric keys from file. + + Args: + private_key_path (str , required): Asymmetric private key path. + public_key_path (str , required): Asymmetric public key path. + as_str (bool, optional): Return keys as strings. Defaults to False. + + Returns: + Tuple[Union[PrivateKeyTypes, str], Union[PublicKeyTypes, str]]: Private and public keys. + """ + + _private_key = await async_get_private_key( + private_key_path=private_key_path, as_str=as_str + ) + _public_key = await async_get_public_key( + public_key_path=public_key_path, as_str=as_str + ) + + return _private_key, _public_key + + +@validate_call +def create_keys( + asymmetric_keys_dir: str, + key_size: int, + private_key_fname: str, + public_key_fname: str, + force: bool = False, + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Generate and create asymmetric key files. + + Args: + asymmetric_keys_dir (str , required): Asymmetric keys directory. + key_size (int , required): Asymmetric key size. + private_key_fname (str , required): Asymmetric private key filename. + public_key_fname (str , required): Asymmetric public key filename. + force (bool , optional): Force to create asymmetric keys. Defaults to False. + warn_mode (WarnEnum, optional): Warning mode. Defaults to WarnEnum.DEBUG. + + Raises: + FileExistsError: If warning mode is ERROR and asymmetric keys already exist. + OSError : If failed to create asymmetric keys. + """ + + _private_key_path = os.path.join(asymmetric_keys_dir, private_key_fname) + _public_key_path = os.path.join(asymmetric_keys_dir, public_key_fname) + + if force: + utils.remove_file(file_path=_private_key_path, warn_mode=warn_mode) + utils.remove_file(file_path=_public_key_path, warn_mode=warn_mode) + + if os.path.isfile(_private_key_path) and os.path.isfile(_public_key_path): + logger.trace( + f"Asymmetric keys already exist: ['{_private_key_path}', '{_public_key_path}']" + ) + return + + _message = ( + f"Generating asymmetric keys: ['{_private_key_path}', '{_public_key_path}']..." + ) + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + _private_key: PrivateKeyTypes + if os.path.isfile(_private_key_path): + if warn_mode == WarnEnum.ERROR: + raise FileExistsError(f"'{_private_key_path}' private key already exists!") + + _private_key: PrivateKeyTypes = get_private_key( + private_key_path=_private_key_path + ) + else: + _private_key = rsa.generate_private_key( + public_exponent=65537, key_size=key_size + ) + + if os.path.isfile(_public_key_path): + if warn_mode == WarnEnum.ERROR: + raise FileExistsError(f"'{_public_key_path}' public key already exists!") + + utils.remove_file(file_path=_public_key_path, warn_mode=warn_mode) + + _public_key = _private_key.public_key() + + _private_pem = _private_key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.PKCS8, + encryption_algorithm=serialization.NoEncryption(), + ) + + _public_pem = _public_key.public_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PublicFormat.SubjectPublicKeyInfo, + ) + + utils.create_dir(create_dir=asymmetric_keys_dir, warn_mode=warn_mode) + + if not os.path.isfile(_private_key_path): + try: + with open(_private_key_path, "wb") as _private_key_file: + _private_key_file.write(_private_pem) + + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{_private_key_path}' private key already exists!") + else: + logger.error(f"Failed to create '{_private_key_path}' private key!") + raise + + if not os.path.isfile(_public_key_path): + try: + with open(_public_key_path, "wb") as _public_key_file: + _public_key_file.write(_public_pem) + + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{_public_key_path}' public key already exists!") + else: + logger.error(f"Failed to create '{_public_key_path}' public key!") + raise + + _message = f"Successfully generated asymmetric keys: ['{_private_key_path}', '{_public_key_path}']" + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + return + + +@validate_call +def get_private_key( + private_key_path: str, as_str: bool = False +) -> Union[PrivateKeyTypes, str]: + """Read asymmetric private key from file. + + Args: + private_key_path (str , required): Asymmetric private key path. + as_str (bool, optional): Return private key as string. Defaults to False. + + Raises: + FileNotFoundError: If asymmetric private key file not found. + + Returns: + Union[PrivateKeyTypes, str]: Asymmetric private key as PrivateKeyTypes or str. + """ + + if not os.path.isfile(private_key_path): + raise FileNotFoundError(f"Not found '{private_key_path}' private key!") + + logger.debug(f"Reading '{private_key_path}' private key...") + _private_key: PrivateKeyTypes + with open(private_key_path, "rb") as _private_key_file: + _private_key_bytes: bytes = _private_key_file.read() + _private_key: PrivateKeyTypes = serialization.load_pem_private_key( + data=_private_key_bytes, password=None + ) + + if as_str: + _private_key = _private_key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.PKCS8, + encryption_algorithm=serialization.NoEncryption(), + ).decode() + + logger.debug(f"Successfully read '{private_key_path}' private key.") + + return _private_key + + +@validate_call +def get_public_key( + public_key_path: str, as_str: bool = False +) -> Union[PublicKeyTypes, str]: + """Read asymmetric public key from file. + + Args: + public_key_path (str , required): Asymmetric public key path. + as_str (bool, optional): Return public key as string. Defaults to False. + + Raises: + FileNotFoundError: If asymmetric public key file not found. + + Returns: + Union[PublicKeyTypes, str]: Asymmetric public key as PublicKeyTypes or str. + """ + + if not os.path.isfile(public_key_path): + raise FileNotFoundError(f"Not found '{public_key_path}' public key!") + + logger.debug(f"Reading '{public_key_path}' public key...") + _public_key: PublicKeyTypes + with open(public_key_path, "rb") as _public_key_file: + _public_key_bytes: bytes = _public_key_file.read() + _public_key: PublicKeyTypes = serialization.load_pem_public_key( + data=_public_key_bytes + ) + + if as_str: + _public_key = _public_key.public_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PublicFormat.SubjectPublicKeyInfo, + ).decode() + + logger.debug(f"Successfully read '{public_key_path}' public key.") + + return _public_key + + +@validate_call +def get_keys( + private_key_path: str, public_key_path: str, as_str: bool = False +) -> Tuple[Union[PrivateKeyTypes, str], Union[PublicKeyTypes, str]]: + """Read asymmetric keys from file. + + Args: + private_key_path (str , required): Asymmetric private key path. + public_key_path (str , required): Asymmetric public key path. + as_str (bool, optional): Return keys as strings. Defaults to False. + + Returns: + Tuple[Union[PrivateKeyTypes, str], Union[PublicKeyTypes, str]]: Private and public keys. + """ + + _private_key = get_private_key(private_key_path=private_key_path, as_str=as_str) + _public_key = get_public_key(public_key_path=public_key_path, as_str=as_str) + + return _private_key, _public_key + + +@validate_call(config={"arbitrary_types_allowed": True}) +def encrypt_with_public_key( + plaintext: Union[str, bytes], + public_key: PublicKeyTypes, + base64_encode: bool = False, + as_str: bool = False, + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> Union[str, bytes]: + """Encrypt plaintext with public key. + + Args: + plaintext (Union[str, bytes], required): Plaintext to encrypt. + public_key (PublicKeyTypes , required): Public key. + base64_encode (bool , optional): Encode ciphertext with base64. Defaults to False. + as_str (bool , optional): Return ciphertext as string or bytes. Defaults to False. + warn_mode (WarnEnum , optional): Warning mode. Defaults to WarnEnum.DEBUG. + + Raises: + Exception: If failed to encrypt plaintext with asymmetric public key. + + Returns: + Union[str, bytes]: Encrypted ciphertext as string or bytes. + """ + + if isinstance(plaintext, str): + plaintext = plaintext.encode() + + _ciphertext: Union[str, bytes] + try: + _message = "Encrypting plaintext with asymmetric public key..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + _ciphertext: bytes = public_key.encrypt( + plaintext=plaintext, + padding=padding.OAEP( + mgf=padding.MGF1(algorithm=hashes.SHA256()), + algorithm=hashes.SHA256(), + label=None, + ), + ) + + _message = "Successfully encrypted plaintext with asymmetric public key." + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + except Exception: + _message = "Failed to encrypt plaintext with asymmetric public key!" + if warn_mode == WarnEnum.ALWAYS: + logger.error(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + raise + + if base64_encode: + _ciphertext = base64.b64encode(_ciphertext) + + if as_str: + _ciphertext = _ciphertext.decode() + + return _ciphertext + + +@validate_call(config={"arbitrary_types_allowed": True}) +def decrypt_with_private_key( + ciphertext: Union[str, bytes], + private_key: PrivateKeyTypes, + base64_decode: bool = False, + as_str: bool = False, + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> Union[str, bytes]: + """Decrypt ciphertext with private key. + + Args: + ciphertext (Union[str, bytes], required): Ciphertext to decrypt. + private_key (PrivateKeyTypes , required): Private key. + base64_decode (bool , optional): Decode ciphertext with base64. Defaults to False. + as_str (bool , optional): Return plaintext as string or bytes. Defaults to False. + warn_mode (WarnEnum , optional): Warning mode. Defaults to WarnEnum.DEBUG. + + Raises: + Exception: If failed to decrypt ciphertext with asymmetric private key for any reason. + + Returns: + Union[str, bytes]: Decrypted plaintext as string or bytes. + """ + + if isinstance(ciphertext, str): + ciphertext = ciphertext.encode() + + if base64_decode: + ciphertext = base64.b64decode(ciphertext) + + _plaintext: Union[str, bytes] + try: + _message = "Decrypting ciphertext with asymmetric private key..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + _plaintext: bytes = private_key.decrypt( + ciphertext=ciphertext, + padding=padding.OAEP( + mgf=padding.MGF1(algorithm=hashes.SHA256()), + algorithm=hashes.SHA256(), + label=None, + ), + ) + + _message = "Successfully decrypted ciphertext with asymmetric private key." + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + except Exception: + _message = "Failed to decrypt ciphertext with asymmetric private key!" + if warn_mode == WarnEnum.ALWAYS: + logger.error(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + raise + + if as_str: + _plaintext = _plaintext.decode() + + return _plaintext + + +__all__ = [ + "gen_key_pair", + "async_create_keys", + "async_get_private_key", + "async_get_public_key", + "async_get_keys", + "create_keys", + "get_private_key", + "get_public_key", + "get_keys", + "encrypt_with_public_key", + "decrypt_with_private_key", +] diff --git a/src/bv_challenge/challenge/api/helpers/crypto/ssl.py b/src/bv_challenge/challenge/api/helpers/crypto/ssl.py new file mode 100644 index 0000000..c232a12 --- /dev/null +++ b/src/bv_challenge/challenge/api/helpers/crypto/ssl.py @@ -0,0 +1,301 @@ +# -*- coding: utf-8 -*- + +import os +import errno +from datetime import timedelta +from typing import Union + +import aiofiles +import aiofiles.os +from pydantic import validate_call, BaseModel, Field +from cryptography import x509 +from cryptography.x509.oid import NameOID +from cryptography.hazmat.primitives import hashes +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.asymmetric import rsa +from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey +from cryptography.hazmat.primitives.asymmetric.types import PrivateKeyTypes +from beans_logging import logger + +from api.core.constants import WarnEnum +from api.core import utils + +from . import asymmetric as asymmetric_helper + + +class X509AttrsPM(BaseModel): + C: str = Field(default="US", min_length=2, max_length=2) + ST: str = Field(default="Washington", min_length=2, max_length=256) + L: str = Field(default="Seattle", min_length=2, max_length=256) + O: str = Field(default="Organization", min_length=2, max_length=256) + OU: str = Field(default="Organization Unit", min_length=2, max_length=256) + CN: str = Field(default="localhost", min_length=2, max_length=256) + DNS: str = Field(default="localhost", min_length=2, max_length=256) + + +@validate_call +async def async_create_ssl_certs( + ssl_dir: str, + cert_fname: str, + key_fname: str, + key_size: int, + x509_attrs: X509AttrsPM = X509AttrsPM(), + force: bool = False, + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Async generate and create SSL key and cert files. + + Args: + ssl_dir (str , required): SSL directory path. + cert_fname (str , required): Certificate file name. + key_fname (str , required): Key file name. + key_size (int , required): Key size. + x509_attrs (X509AttrsPM, optional): X509 named attributes. Defaults to X509AttrsPM(). + force (bool , optional): Force to create SSL key and cert files. Defaults to False. + warn_mode (WarnEnum , optional): Warning mode. Defaults to WarnEnum.DEBUG. + + Raises: + FileExistsError: When warning mode is set to ERROR and SSL key or cert files already exist. + OSError : If failed to create SSL key or cert files. + """ + + _key_path = os.path.join(ssl_dir, key_fname) + _cert_path = os.path.join(ssl_dir, cert_fname) + + if force: + await utils.async_remove_file(file_path=_key_path, warn_mode=warn_mode) + await utils.async_remove_file(file_path=_cert_path, warn_mode=warn_mode) + + if (await aiofiles.os.path.isfile(_key_path)) and ( + await aiofiles.os.path.isfile(_cert_path) + ): + logger.trace( + f"SSL key and cert files already exist: ['{_key_path}', '{_cert_path}']" + ) + return + + _meesage = f"Generating SSL key and cert files: ['{_key_path}', '{_cert_path}']..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_meesage) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_meesage) + + _private_key: Union[RSAPrivateKey, PrivateKeyTypes] + if await aiofiles.os.path.isfile(_key_path): + if warn_mode == WarnEnum.ERROR: + raise FileExistsError(f"'{_key_path}' SSL key file already exists!") + + _private_key: PrivateKeyTypes = await asymmetric_helper.async_get_private_key( + private_key_path=_key_path + ) + else: + _private_key: RSAPrivateKey = rsa.generate_private_key( + public_exponent=65537, key_size=key_size + ) + + if await aiofiles.os.path.isfile(_cert_path): + if warn_mode == WarnEnum.ERROR: + raise FileExistsError(f"'{_cert_path}' SSL cert file already exists!") + + await utils.async_remove_file(file_path=_cert_path, warn_mode=warn_mode) + + _subject = _issuer = x509.Name( + [ + x509.NameAttribute(NameOID.COUNTRY_NAME, x509_attrs.C), + x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, x509_attrs.ST), + x509.NameAttribute(NameOID.LOCALITY_NAME, x509_attrs.L), + x509.NameAttribute(NameOID.ORGANIZATION_NAME, x509_attrs.O), + x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, x509_attrs.OU), + x509.NameAttribute(NameOID.COMMON_NAME, x509_attrs.CN), + ] + ) + _cert = ( + x509.CertificateBuilder() + .subject_name(name=_subject) + .issuer_name(name=_issuer) + .public_key(key=_private_key.public_key()) + .serial_number(number=x509.random_serial_number()) + .not_valid_before(time=utils.now_utc_dt()) + .not_valid_after(time=utils.now_utc_dt() + timedelta(days=365)) + .add_extension( + extval=x509.SubjectAlternativeName([x509.DNSName(x509_attrs.DNS)]), + critical=False, + ) + .sign(private_key=_private_key, algorithm=hashes.SHA256()) + ) + + await utils.async_create_dir(create_dir=ssl_dir, warn_mode=warn_mode) + + if not await aiofiles.os.path.isfile(_key_path): + try: + async with aiofiles.open(_key_path, "wb") as _key_file: + await _key_file.write( + _private_key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.TraditionalOpenSSL, + encryption_algorithm=serialization.NoEncryption(), + ) + ) + + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{_key_path}' SSL key file already exists!") + else: + logger.error(f"Failed to create '{_key_path}' SSL key file!") + raise + + if not await aiofiles.os.path.isfile(_cert_path): + try: + async with aiofiles.open(_cert_path, "wb") as _cert_file: + await _cert_file.write(_cert.public_bytes(serialization.Encoding.PEM)) + + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{_cert_path}' SSL cert file already exists!") + else: + logger.error(f"Failed to create '{_cert_path}' SSL cert file!") + raise + + _message = f"Successfully generated SSL key and cert files: ['{_key_path}', '{_cert_path}']" + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + return + + +@validate_call +def create_ssl_certs( + ssl_dir: str, + key_fname: str, + cert_fname: str, + key_size: int, + x509_attrs: X509AttrsPM = X509AttrsPM(), + force: bool = False, + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> None: + """Generate and create SSL key and cert files. + + Args: + ssl_dir (str , required): SSL directory path. + key_fname (str , required): Key file name. + cert_fname (str , required): Certificate file name. + key_size (int , required): Key size. + x509_attrs (X509AttrsPM, optional): X509 named attributes. Defaults to X509AttrsPM(). + force (bool , optional): Force to create SSL key and cert files. Defaults to False. + warn_mode (WarnEnum , optional): Warning mode. Defaults to WarnEnum.DEBUG. + + Raises: + FileExistsError: When warning mode is set to ERROR and SSL key or cert files already exist. + OSError : If failed to create SSL key or cert files. + """ + + _key_path = os.path.join(ssl_dir, key_fname) + _cert_path = os.path.join(ssl_dir, cert_fname) + + if force: + utils.remove_file(file_path=_key_path, warn_mode=warn_mode) + utils.remove_file(file_path=_cert_path, warn_mode=warn_mode) + + if os.path.isfile(_key_path) and os.path.isfile(_cert_path): + logger.trace( + f"SSL key and cert files already exist: ['{_key_path}', '{_cert_path}']" + ) + return + + _message = f"Generating SSL key and cert files: ['{_key_path}', '{_cert_path}']..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + _private_key: Union[RSAPrivateKey, PrivateKeyTypes] + if os.path.isfile(_key_path): + if warn_mode == WarnEnum.ERROR: + raise FileExistsError(f"'{_key_path}' SSL key file already exists!") + + _private_key: PrivateKeyTypes = asymmetric_helper.get_private_key( + private_key_path=_key_path + ) + else: + _private_key: RSAPrivateKey = rsa.generate_private_key( + public_exponent=65537, key_size=key_size + ) + + if os.path.isfile(_cert_path): + if warn_mode == WarnEnum.ERROR: + raise FileExistsError(f"'{_cert_path}' SSL cert file already exists!") + + utils.remove_file(file_path=_cert_path, warn_mode=warn_mode) + + _subject = _issuer = x509.Name( + [ + x509.NameAttribute(NameOID.COUNTRY_NAME, x509_attrs.C), + x509.NameAttribute(NameOID.STATE_OR_PROVINCE_NAME, x509_attrs.ST), + x509.NameAttribute(NameOID.LOCALITY_NAME, x509_attrs.L), + x509.NameAttribute(NameOID.ORGANIZATION_NAME, x509_attrs.O), + x509.NameAttribute(NameOID.ORGANIZATIONAL_UNIT_NAME, x509_attrs.OU), + x509.NameAttribute(NameOID.COMMON_NAME, x509_attrs.CN), + ] + ) + _cert = ( + x509.CertificateBuilder() + .subject_name(name=_subject) + .issuer_name(name=_issuer) + .public_key(key=_private_key.public_key()) + .serial_number(number=x509.random_serial_number()) + .not_valid_before(time=utils.now_utc_dt()) + .not_valid_after(time=utils.now_utc_dt() + timedelta(days=365)) + .add_extension( + extval=x509.SubjectAlternativeName([x509.DNSName(x509_attrs.DNS)]), + critical=False, + ) + .sign(private_key=_private_key, algorithm=hashes.SHA256()) + ) + + utils.create_dir(create_dir=ssl_dir, warn_mode=warn_mode) + + if not os.path.isfile(_key_path): + try: + with open(_key_path, "wb") as _key_file: + _key_file.write( + _private_key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.TraditionalOpenSSL, + encryption_algorithm=serialization.NoEncryption(), + ) + ) + + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{_key_path}' SSL key file already exists!") + else: + logger.error(f"Failed to create '{_key_path}' SSL key file!") + raise + + if not os.path.isfile(_cert_path): + try: + with open(_cert_path, "wb") as _cert_file: + _cert_file.write(_cert.public_bytes(serialization.Encoding.PEM)) + + except OSError as err: + if (err.errno == errno.EEXIST) and (warn_mode == WarnEnum.DEBUG): + logger.debug(f"'{_cert_path}' SSL cert file already exists!") + else: + logger.error(f"Failed to create '{_cert_path}' SSL cert file!") + raise + + _message = f"Successfully generated SSL key and cert files: ['{_key_path}', '{_cert_path}']" + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + return + + +__all__ = [ + "async_create_ssl_certs", + "create_ssl_certs", +] diff --git a/src/bv_challenge/challenge/api/helpers/crypto/symmetric.py b/src/bv_challenge/challenge/api/helpers/crypto/symmetric.py new file mode 100644 index 0000000..0209f61 --- /dev/null +++ b/src/bv_challenge/challenge/api/helpers/crypto/symmetric.py @@ -0,0 +1,87 @@ +# -*- coding: utf-8 -*- + +import base64 +from typing import Union + +from cryptography.hazmat.primitives import ciphers +from cryptography.hazmat.primitives.ciphers import algorithms, modes +from cryptography.hazmat.primitives import padding +from pydantic import validate_call +from beans_logging import logger + +from api.core.constants import WarnEnum + + +@validate_call(config={"arbitrary_types_allowed": True}) +def decrypt_aes_cbc( + ciphertext: Union[str, bytes], + key: bytes, + iv: bytes, + base64_decode: bool = False, + as_str: bool = False, + warn_mode: WarnEnum = WarnEnum.DEBUG, +) -> Union[str, bytes]: + """Decrypts a ciphertext using AES-CBC key and iv. + + Args: + ciphertext (Union[str, bytes], required): The ciphertext to decrypt. + key (bytes , required): The key to use for decryption. + iv (bytes , required): The initialization vector to use for decryption. + base64_decode (bool , optional): Whether to decode the ciphertext from base64. Defaults to False. + as_str (bool , optional): Whether to return the plaintext as a string or bytes. Defaults to False. + warn_mode (WarnEnum , optional): The warning mode to use. Defaults to WarnEnum.DEBUG. + + Raises: + Exception: If failed to decrypt ciphertext using AES-CBC key and iv for any reason. + + Returns: + Union[str, bytes]: The decrypted plaintext as a string or bytes. + """ + + if isinstance(ciphertext, str): + ciphertext = ciphertext.encode() + + if base64_decode: + ciphertext = base64.b64decode(ciphertext) + + _plaintext: Union[str, bytes] + try: + _message = "Decrypting ciphertext using AES-CBC key and iv..." + if warn_mode == WarnEnum.ALWAYS: + logger.info(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + _cipher = ciphers.Cipher( + algorithm=algorithms.AES(key=key), mode=modes.CBC(initialization_vector=iv) + ) + _decryptor = _cipher.decryptor() + _padded_plaintext = _decryptor.update(data=ciphertext) + _decryptor.finalize() + + _unpadder = padding.PKCS7(block_size=algorithms.AES.block_size).unpadder() + _plaintext = _unpadder.update(_padded_plaintext) + _unpadder.finalize() + + _message = "Successfully decrypted ciphertext using AES-CBC key and iv." + if warn_mode == WarnEnum.ALWAYS: + logger.success(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + except Exception: + _message = "Failed to decrypt ciphertext using AES-CBC key and iv!" + if warn_mode == WarnEnum.ALWAYS: + logger.error(_message) + elif warn_mode == WarnEnum.DEBUG: + logger.debug(_message) + + raise + + if as_str: + _plaintext = _plaintext.decode() + + return _plaintext + + +__all__ = [ + "decrypt_aes_cbc", +] diff --git a/src/bv_challenge/challenge/api/lifespan.py b/src/bv_challenge/challenge/api/lifespan.py index 5caee29..4ad25f7 100644 --- a/src/bv_challenge/challenge/api/lifespan.py +++ b/src/bv_challenge/challenge/api/lifespan.py @@ -1,27 +1,23 @@ +# -*- coding: utf-8 -*- + import os -from collections.abc import AsyncGenerator +from typing import AsyncGenerator from contextlib import asynccontextmanager from fastapi import FastAPI -from potato_util.io import async_create_dir -from potato_util.crypto import asymmetric as asymmetric_utils -from potato_util.crypto import ssl as ssl_utils - -from api.__version__ import __version__ +from api.core import utils from api.config import config +from api.helpers.crypto import asymmetric as asymmetric_helper +from api.helpers.crypto import ssl as ssl_helper from api.logger import logger -def _check_ssl_certs() -> None: - """Check if SSL certificates exist when SSL is enabled or set to be generated. - - Raises: - SystemExit: If SSL certificates are missing or cannot be created. - """ +def pre_init() -> None: + """Pre-initialization tasks before creating FastAPI application.""" if config.api.security.ssl.generate: - ssl_utils.create_ssl_certs( + ssl_helper.create_ssl_certs( ssl_dir=config.api.paths.ssl_dir, key_fname=config.api.security.ssl.key_fname, cert_fname=config.api.security.ssl.cert_fname, @@ -30,31 +26,20 @@ def _check_ssl_certs() -> None: ) if config.api.security.ssl.enabled: - _ssl_keyfile_path = os.path.join( + _ssl_keyfile = os.path.join( config.api.paths.ssl_dir, config.api.security.ssl.key_fname ) - _ssl_certfile_path = os.path.join( + _ssl_certfile = os.path.join( config.api.paths.ssl_dir, config.api.security.ssl.cert_fname ) - if (not os.path.isfile(_ssl_keyfile_path)) or ( - not os.path.isfile(_ssl_certfile_path) - ): + if (not os.path.isfile(_ssl_keyfile)) or (not os.path.isfile(_ssl_certfile)): logger.error("SSL key or certificate file not found!") raise SystemExit(1) return -def pre_init() -> None: - """Pre-initialization tasks before creating FastAPI application.""" - - _check_ssl_certs() - # Add more pre-initialization tasks here... - - return - - async def _async_create_dirs() -> None: """Create directories before starting FastAPI application. @@ -63,8 +48,8 @@ async def _async_create_dirs() -> None: """ try: - await async_create_dir(config.api.paths.data_dir) - # Add directories that need to be created here... + await utils.async_create_dir(config.api.paths.data_dir) + ## Add directories needs to be created here... except Exception: logger.exception("Failed to create directories:") raise SystemExit(1) @@ -84,16 +69,16 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]: logger.info("Preparing to startup...") # await _async_create_dirs() if config.api.security.asymmetric.generate: - await asymmetric_utils.async_create_keys( + await asymmetric_helper.async_create_keys( asymmetric_keys_dir=config.api.paths.asymmetric_keys_dir, key_size=config.api.security.asymmetric.key_size, private_key_fname=config.api.security.asymmetric.private_key_fname, public_key_fname=config.api.security.asymmetric.public_key_fname, ) - # Add startup code here... + ## Add startup code here... logger.success("Finished preparation to startup.") - logger.opt(colors=True).info(f"Version: {__version__}") + logger.opt(colors=True).info(f"Version: {config.version}") logger.opt(colors=True).info(f"API version: {config.api.version}") logger.opt(colors=True).info(f"API prefix: {config.api.prefix}") logger.opt(colors=True).info( @@ -103,7 +88,7 @@ async def lifespan(app: FastAPI) -> AsyncGenerator[None, None]: yield logger.info("Praparing to shutdown...") - # Add shutdown code here... + ## Add shutdown code here... logger.success("Finished preparation to shutdown.") diff --git a/src/bv_challenge/challenge/api/logger.py b/src/bv_challenge/challenge/api/logger.py index 46da0bd..d2b046b 100644 --- a/src/bv_challenge/challenge/api/logger.py +++ b/src/bv_challenge/challenge/api/logger.py @@ -1,5 +1,124 @@ -from beans_logging_fastapi import logger +# -*- coding: utf-8 -*- + +from pydantic import validate_call +from fastapi.concurrency import run_in_threadpool + +from beans_logging import Logger, LoggerLoader +from beans_logging_fastapi import ( + add_http_file_handler, + add_http_file_json_handler, + http_file_format, +) + +from api.core.constants import WarnEnum +from api.config import config + + +logger_loader = LoggerLoader(config=config.logger, auto_config_file=False) +logger: Logger = logger_loader.load() + + +def _http_file_format(record: dict) -> str: + _format = http_file_format( + record=record, + msg_format=config.logger.extra.http_file_format, + tz=config.logger.extra.http_file_tz, + ) + return _format + + +if config.logger.extra.http_file_enabled: + add_http_file_handler( + logger_loader=logger_loader, + log_path=config.logger.extra.http_log_path, + err_path=config.logger.extra.http_err_path, + formatter=_http_file_format, + ) + +if config.logger.extra.http_json_enabled: + add_http_file_json_handler( + logger_loader=logger_loader, + log_path=config.logger.extra.http_json_path, + err_path=config.logger.extra.http_json_err_path, + ) + + +@validate_call +def log_mode( + message: str, level: str = "INFO", warn_mode: WarnEnum = WarnEnum.ALWAYS +) -> None: + """Log message with level and warn mode. + + Args: + message (str, reqiured): Message to log. + level (LogLevelEnum, optional): Log level when warn mode is `WarnEnum.ALWAYS`. Defaults to "INFO". + warn_mode (WarnEnum, optional): Warn mode to use. Defaults to `WarnEnum.ALWAYS`. + + Raises: + ValueError: If `level` is not a valid log level. + """ + + level = level.upper() + if warn_mode == WarnEnum.ALWAYS: + if level == "INFO": + logger.info(message) + elif level == "SUCCESS": + logger.success(message) + elif level == "WARNING": + logger.warning(message) + elif level == "ERROR": + logger.error(message) + elif level == "CRITICAL": + logger.critical(message) + elif level == "TRACE": + logger.trace(message) + else: + raise ValueError(f"Unknown log level: '{level}'") + + elif warn_mode == WarnEnum.DEBUG: + logger.debug(message) + + return + + +@validate_call +async def async_log_mode( + message: str, level: str = "INFO", warn_mode: WarnEnum = WarnEnum.ALWAYS +) -> None: + """Log message with level and warn mode in async mode. + + Args: + message (str , required): Message to log. + level (str , optional): Log level when warn mode is `WarnEnum.ALWAYS`. Defaults to "INFO". + warn_mode (WarnEnum, optional): Warn mode to use. Defaults to `WarnEnum.ALWAYS`. + """ + + level = level.upper() + if warn_mode == WarnEnum.ALWAYS: + if level == "INFO": + await run_in_threadpool(logger.info, message) + elif level == "SUCCESS": + await run_in_threadpool(logger.success, message) + elif level == "WARNING": + await run_in_threadpool(logger.warning, message) + elif level == "ERROR": + await run_in_threadpool(logger.error, message) + elif level == "CRITICAL": + await run_in_threadpool(logger.critical, message) + elif level == "TRACE": + await run_in_threadpool(logger.trace, message) + else: + raise ValueError(f"Unknown log level: '{level}'") + + elif warn_mode == WarnEnum.DEBUG: + await run_in_threadpool(logger.debug, message) + + return + __all__ = [ + "logger_loader", "logger", + "log_mode", + "async_log_mode", ] diff --git a/src/bv_challenge/challenge/api/main.py b/src/bv_challenge/challenge/api/main.py index e748463..4b2e097 100644 --- a/src/bv_challenge/challenge/api/main.py +++ b/src/bv_challenge/challenge/api/main.py @@ -1,23 +1,5 @@ -# Third-party libraries -from dotenv import load_dotenv -from fastapi import FastAPI +# -*- coding: utf-8 -*- -load_dotenv(override=True) +from .__main__ import app, main -# Internal modules -from api.bootstrap import create_app, run_server # noqa: E402 - -app: FastAPI = create_app() - - -def main() -> None: - """Main function.""" - - run_server(app="api.main:app") - return - - -__all__ = [ - "app", - "main", -] +__all__ = ["app", "main"] diff --git a/src/bv_challenge/challenge/api/middleware.py b/src/bv_challenge/challenge/api/middleware.py index 1db2285..c238873 100644 --- a/src/bv_challenge/challenge/api/middleware.py +++ b/src/bv_challenge/challenge/api/middleware.py @@ -1,9 +1,17 @@ +# -*- coding: utf-8 -*- + from pydantic import validate_call from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware from fastapi.middleware.gzip import GZipMiddleware from fastapi.middleware.trustedhost import TrustedHostMiddleware +from beans_logging_fastapi import ( + HttpAccessLogMiddleware, + RequestHTTPInfoMiddleware, + ResponseHTTPInfoMiddleware, +) + from api.config import config from api.core.middlewares import ProcessTimeMiddleware, RequestIdMiddleware @@ -16,8 +24,19 @@ def add_middlewares(app: FastAPI) -> None: app (FastAPI): FastAPI app instance. """ - # Add more middlewares here... - app.add_middleware(GZipMiddleware, **config.api.gzip.model_dump()) + ## Add more middlewares here... + app.add_middleware(ResponseHTTPInfoMiddleware) + app.add_middleware( + HttpAccessLogMiddleware, + debug_format=config.logger.extra.http_std_debug_format, + msg_format=config.logger.extra.http_std_msg_format, + ) + app.add_middleware( + RequestHTTPInfoMiddleware, + has_proxy_headers=config.api.behind_proxy, + has_cf_headers=config.api.behind_cf_proxy, + ) + # app.add_middleware(GZipMiddleware, minimum_size=config.api.gzip_min_size) app.add_middleware(CORSMiddleware, **config.api.security.cors.model_dump()) app.add_middleware( TrustedHostMiddleware, allowed_hosts=config.api.security.allowed_hosts diff --git a/src/bv_challenge/challenge/api/mount.py b/src/bv_challenge/challenge/api/mount.py index 1f1b005..209a265 100644 --- a/src/bv_challenge/challenge/api/mount.py +++ b/src/bv_challenge/challenge/api/mount.py @@ -1,9 +1,10 @@ -# import os +# -*- coding: utf-8 -*- + +import pathlib from pydantic import validate_call from fastapi import FastAPI - -# from fastapi.staticfiles import StaticFiles +from fastapi.staticfiles import StaticFiles @validate_call(config={"arbitrary_types_allowed": True}) @@ -14,9 +15,13 @@ def add_mounts(app: FastAPI) -> None: app (FastAPI): FastAPI app instance. """ - # app.mount("/static", StaticFiles(directory=os.path.join("api", "static")), name="static") - # Add mounts here + _src_dir = pathlib.Path(__file__).parent.parent.resolve() + app.mount( + path="/static", + app=StaticFiles(directory=str(_src_dir / "./templates/html/static")), + name="static", + ) return diff --git a/src/bv_challenge/challenge/api/router.py b/src/bv_challenge/challenge/api/router.py index c5e6560..8fd1a8a 100644 --- a/src/bv_challenge/challenge/api/router.py +++ b/src/bv_challenge/challenge/api/router.py @@ -1,9 +1,10 @@ +# -*- coding: utf-8 -*- + from pydantic import validate_call from fastapi import FastAPI, APIRouter from api.config import config from api.core.routers.utils import router as utils_router -from api.core.routers.default import router as default_router from api.endpoints.challenge.router import router as challenge_router @@ -16,14 +17,11 @@ def add_routers(app: FastAPI) -> None: """ _api_router = APIRouter(prefix=config.api.prefix) - _api_router.include_router(challenge_router) _api_router.include_router(utils_router) + _api_router.include_router(challenge_router) # Add more API routers here... - # Add admin API routers here... - app.include_router(_api_router) - app.include_router(default_router) return diff --git a/src/bv_challenge/challenge/api/static/css/.gitkeep b/src/bv_challenge/challenge/api/static/css/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/src/bv_challenge/challenge/api/static/fonts/.gitkeep b/src/bv_challenge/challenge/api/static/fonts/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/src/bv_challenge/challenge/api/static/images/favicon.ico b/src/bv_challenge/challenge/api/static/images/favicon.ico deleted file mode 100644 index 9efd3bf379b48e49321fbdd2dc8cba5ae4a2593b..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 15406 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 diff --git a/src/bv_challenge/challenge/api/static/index.html b/src/bv_challenge/challenge/api/static/index.html deleted file mode 100644 index e69de29..0000000 diff --git a/src/bv_challenge/challenge/api/static/js/.gitkeep b/src/bv_challenge/challenge/api/static/js/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/src/bv_challenge/challenge/api/static/media/.gitkeep b/src/bv_challenge/challenge/api/static/media/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/src/bv_challenge/challenge/api/templates/html/.gitkeep b/src/bv_challenge/challenge/api/templates/html/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/src/bv_challenge/challenge/api/templates/mail/.gitkeep b/src/bv_challenge/challenge/api/templates/mail/.gitkeep deleted file mode 100644 index e69de29..0000000 diff --git a/src/bv_challenge/challenge/requirements.txt b/src/bv_challenge/challenge/requirements.txt index 4870bad..728bb85 100644 --- a/src/bv_challenge/challenge/requirements.txt +++ b/src/bv_challenge/challenge/requirements.txt @@ -1,5 +1,15 @@ -certifi>=2024.2.2,<2030.0.0 -anyio>=4.3.0,<5.0.0 -potato-util[crypto,async]~=0.5.3 -beans-logging-fastapi~=6.0.4 -fastapi[all]~=0.135.1 +pycparser>=2.22,<3.0.0 +certifi>=2024.8.30,<2030.0.0 +Mako>=1.3.6,<2.0.0 +argon2-cffi-bindings>=21.2.0,<22.0.0 +aioshutil~=1.5 +aiofiles~=24.1.0 +PyJWT~=2.10.1 +cryptography>=43.0.0,<50.0.0 +argon2-cffi~=23.1.0 +beans-logging-fastapi~=1.1.1 +onion-config[pydantic-settings]~=5.1.1 +aiohttp~=3.10.2 +fastapi[all]~=0.110.1 +docker~=7.1.0 +./requirements/vault_unlock-0.1.0-cp310-abi3-manylinux_2_34_x86_64.whl diff --git a/src/bv_challenge/challenge/requirements/vault_unlock-0.1.0-cp310-abi3-manylinux_2_34_x86_64.whl b/src/bv_challenge/challenge/requirements/vault_unlock-0.1.0-cp310-abi3-manylinux_2_34_x86_64.whl new file mode 100644 index 0000000000000000000000000000000000000000..4a4fdc494017c2b744c1d3df17703f0aa15cfa69 GIT binary patch literal 3076190 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%0AWTJ$2b$dH_N#1G&&AylprWkBv7V%hZ5d)6rKb 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%0Dy>M#d@fQx6=lf`AnEmtGSIP6f)ii8Eax~O~oc$ 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ℜ5H$&KS?Ui8Vxp=vw-xM6o3W4rD@S_I1gFo)Ils|Q(>PyIDaaF7kv!a7w(6;? zxzcv#m!76cW-q9};H?oXg%N$h6g`)e znQAh$AM%)*=2*anBB?ARq#DPzv=ss~xa4!@U~7W>h^YmJ&e|Isa=dle&bjwVUe$DT z1atzwCx;xgUH3>$eapPYUW;UwB!o~|D2ImI5UPJ$oqHK#8zpKNuP*dEmD5S9xug}n z3vWS(VlL%BzQ!smMj;Yh?0!`Cc0;_pW-a_zfK>+l))T|aeh1%@B@TiCXzN-U3651H zg^{KWV@&2zOn){70{FVTW_wRIB*n2GldF$;pr7R?f3Ja0aUW3t6YA7n!I?qvs@wy7 z%Zi?+KHdUNeMwVwxucxTW=n&eD&1-~ecLJ>Z2*j+2~2-&=dpxlw-=#yHASQNc(_@* z&%BN6cA!GaFV3HC83b$)iY@kYKPdAsh+TopS~jaUPi6RwwQggdnPak#-T$9Ag)F?b zv4mdK?ItLm(s?-ORE|^aTbWpw2U(xqNIC+YM%rvG(wv}2yQHiTVIvrS?|D&aY&l2@ z96M%{J4NEK9p{>C`kmufd9I){o|Hv}pB`NyYvyGi&p&JJHDIUJ)?N{YO#4%wMn`*! z$Nv^ZMJV6c(|xob8iAJds95hXA5r@~H!bdOFr$^e;av8ZsprbB3t>VGr7RL z*i4p14_xGxoB8@tNvXb&L(J6RSG^DQ*Vzs@}A zmkxQmoi&?s7QcHFGn{0IXbB~oYnGOYcJUoR`XMsba7K`TUG}$ckH`=?F zu4H@|);6mnBcf&8+qpt=zS||pT(hTdIJFl)Sk}-Y)j3VHPKNDnsb$Z%~9T%OmKZZ zx>993t)CG)2yL66h-t(|EVwJj<@w()e|?K5H4_G-5r91`T4P#Qi>t9TvX_i}1inAjyJm=HZLKT#t556hNx#xj z()Vg%NtyBNkSv1+yB9rsi!~YGk(r^UrAYW{@NONp%asFz>NS!mG9WB>uM!P=n7Ox^ z(;eoctl(}hLLz~?m!+;e&)*!i`&HJB+qb2f&65DW#(-6t_)B!&K8dLZlcFQ#f-!<) zxq{5R5T;LWBX%jPFZk3SIZyWVkA~>U|P&%f0PdN3(KV>hJb5WA{LLJVWaew5G!0^}w-N0OHL`edj z4iXP0vM@caww=t#o5DcZpdtlC2AP^d06Fkw>mymUd`hF&J0qKL1~1^UNjWz7ZcvYL z2^l(rM9DcDlDHcJo`wZ?(8P4U7~O}(HGte?R!eqN`!)l4RBr2A;WI&-nF|EUVjJPW z;6Kw^rs6Czy3@L5&&{c)_oEER^FdzSHYas4Vs-bVeZd({`R}0|Q8^zBfjr+{VS=hP z&~lGP_G_qU<$@0Fq^}6XRy8f8^@>d{Ha_p&(zb^?9X#LZeq}o|OlL0?3#U1eL--LY zmaluU@JnSjC--R3&qr{>pV&|`9p{Hckzt3o zF=I50-g)@?SQpIK;k?IAl_Y6pm^;607MjawJs7XQI3o3(DNA-3)3h`xudGcS#dF_^ z<=(Hi2;To@mc`t8a$BHTbVE`jascA6xwG;Eiz~vpBVCQ*GWM80U9#i_m~50DhF;?5 zGT6?4V(6gm+#*q=3?hzR4@h-w=5Vt95W9N2YA}O_@|n(+YdNVhnj2~Xqj*uzg+)mW za>rbgUY{c#{9|Me=%$IsX-kKo6`JiR#zB5Tm=jt#4%XvS&CQmssYc{xiSXB6^0PIc z6f?FLTFV+@{(F(t9`PoMweGBU-JAa}Fal~=IwsP%K2M-VOBITESdhJ?R0%ykk{%Tu zI#5FytTr!yeUvdO){o2?@p>xw6dvK=7d@G?26sQ@%NX>PwA?vMK5&q%y zJNvamFp6J>)1a=Xj`VJm!W3kXtm`V;O?j9tPQ`b+t}aIaI0JxxRx#x3T~LYe?X0Wz z`|E;fOC(oy#u+`J2M#t^MR@N|T~r@yU-j_@tNxzH6H@s3@2Zsvx%V7kS6 z&W&N(v9Lt6W1ge;X~mEWlv4}M6*4B~fE3y%=4!e~;0u$xmhvi1AJJl&qY&LY8I%&^ z{$4MgfCkpc^7@18g&QS0%H{!KCDT)Az*sKyx4>U|dL^G_jy&^qk2~!~?8nqHW;a&^ z9YCo`U34ededOCTBE?qH;+|h1$MSL8@+V+0+N7mKgnILEO29Cz%WLuR@p$Xsd5u3( zXTiWbCz9&@S7W7^MjFCGBVqV=AW_2xDbDGAUaLtobDZ>KAeh-CF>((`YV-yZSfZ6& z>TtCLe)n+F>oJte_rLZfVpACY(i)@RAJ{6J@{FlfIC(kCrm%6c7gE0fcf_l~+Bwv8 zIQv~{y@UW2IBso#r*W)wdHMlv$nytkaNODgX?5Hx1rM8ceu1ZVt?@MT+tqqm0+O9} z-oYYZU-7o}OLW|l1BaM)?!n6ATKV+(nd|;aV_zZRAf0yZa+J=#csl{)gq>z^t-($> zxYTM9i;+5M-{Z(|+~VZ`Y_W~@v4Wd%u-p1UQ=7q4>1(%(%TvO$YDDVB7UDPG1`> zxYbhDh0U}=_JvL=5!Xr=g_vE9r&tW2ux*^FwrioE{ds<1>cD)`K67F=?F|0|-HExZ zi!VAc$C`Hmz@c6mf1>MgmfEgkIRF=E#}Q`QnWinlQF}+r^rRiA4g91X*8z6gx#JjW z+WD$2z;SC-tFO&Qx@K34jaSXCCNqPIePwDIHR}Ry{0B1tpdA8Y$&LUp{TZ2_0C4iN zzS0rwq#gDr3CRyse$e!T|JfpcylOvjwNrpB*P{SzCjioKrT-w=5^&sjEwYn#xx)<3 zm913EeXSS08bHNIT5E0B*lmDf3x5#nz;e>AduRc8)25aH#b#A`h6fMsReQ*AaqKQPDvyjwhSjy0J-vA9`3_*sgZ3P5%O05p>e zSr;ikNlt!}SUv!*G4#E3)&=bZ6Z?vGw&}5!t9H)0)=K~&-!*Drn&UF|o-blp*&clb zxRYH+S`?YeKj~M6)EzJOE6Z%XH+e{03zxXhe}HR|`VbtqD&u(F1s+N3a|6(izj(qd z7*pHEtcc*^#i)n~;KQX13m}6r6v$*yX7a4$5-8olB4z)G!lxAtaOsJ+3~k|FfBHZy zC3Jd>Cek?n^R$3C@-TJ%Na9drH;2SCkD!=2ZF?s^SAJd+|Ixm;9-pwWedQ2zR)W3| zuRx;#IH5pXH@n z1}^eXgi2OZ_KUh`fw7Ch*(3`0+XSF0o3QF4KX(^tJ>#U1dL2Fzu}X5OByvu2*(hQl zzP6t-*c#$*Lp%HgPh){F+|mXvWr8m@d&yv8yYN2nVRpCGuOCAYAcv=>Ngq5 zLY%KyEmH+s0W8aKHuzWEK@cC;d0-#cL|~r{_1+sOmR;8-wA&6HnAfgR>fILscz<$_ zF(J6uXg=#RP~qULRo^any86{L@KkhwP=6KiKV!ca!2HqGs+|idwrBHlzigQ)I)EL)H zH=Fz0utYLA)wcE+$00jv)8$}ZSWL|{o&4QAJCj-qEVkUSzYb@gHe!q7xQDh*Z_Qym z!&X^_=y_g$?;oj<%%L5^zD@FoYYmN{otKn0ZZJkE^H8V{&`;YpEM!C{M%SNY?;EvT zs+in0&^-(?RH-P6hs8n@!(751rPy!AX}b6(EF;8k@aCG;J8atSqu-%~9q&OHM(;t` z4>XW8%L;MXo71PBP)*B=OMFqaciX3`Ci+G5%-xG-NK3d^~zkCW!pqXba!CmD^_{Dau1@27@ zcyy}rhl+9kQQlU*@50MMjEU1l&@Bv0J#@41q}oZucOBpfZY4G3P7hr*&jHrfIiz5? zl%dCYUGU)bD`;+fj; zFvo|^{y&n=F}#wdTf>>ywr$(CZB1<3w(U%8Ta$@x+qRv3@_y&)-S_TQUEO_ktv}UO zPp#GBH76*prBA((enN)dBGN5CL_4y2upju&wGxfweqAS+%^{#k^~5@pZ8_Ir;Gf-A zZN0*L$e)6*bK#>h3VqNpHYb;QghpnicWQ?GyHr?)&j(r zlIe7+oH{o0-C2ohvq}jpYkz#bW2k9DFhSakBv1p^123ztLS#E2=VYo;daTFqR#g~3 z#Qz{X4vV9}Vsf|d;DG`)Hk;FncMYL~mM^dSEc{Sm%I6PmuN?>oV{c(=`QPgHS`#}n zWnftcBPV6{j@}wo;XE6f?1|F^f|k^NYACYY&m(RqDW>N|R7%N*^ePK5v@qq_SU-9Jkn6oRR(sDUn~@R#H4f!gr24fj!EVwjFR)QWb5@SrGb zhdOM<)NtNZn}B!Cw=a91s)a9m?ziYpdIvD9^;02Ats5}a zn6(3dZ-##99jKOn={2tI|GE+Vx$wrN$^oEbvvlKsqM3W`UsX;1()*;I{IN5nzVNY= zs^0Xm(^PZ((tDznd*jd0*x3!}>95=Z=o_cr__yhleC%Y`tbg6)E|XvT-!!qi0zT@O zp1y7l)K^}5%YBEh{Sh>Ot}|%F{y}yW2c$$>f2o~!3~g2 z@KYWK`BOduZu!!i9Q<=KQ)vCmUMj&0po2uZ4Oj-ny7tEjF8}AJ{?vJhTlI>ZNxD;s8!OMSU{C}pxf0+3X4FA=u`w#X}eQG;s z!Bu{=;2K}bu(j{Gn7U6GOzr0eMh=i}$C79?DORJe(isWBv#9|A6-cJDBBbe|y;ffbfGGs2>pgXA=B( zA|L)g{C8yVUs?R=&zmg&_@?g1H;c6G=PSdzl>!+*uO$alTiLwwb^0LHqd>cUwoBgv;G>sj zIm324Sd>S(8wl=kut(xD!dBdtP01A+P*s`O=Bc6TICD=%wUk6rIALET}g?< zU4N3I=v_3Dl5UBST}Kz=s;>DlkByDjxkojXzF<)`mcEEk#X#icR65bHD65SLdR9Kr zc`UrB>u75Z@NEMuDkp8(x5A$-hh<#dt+rB*zj?BHu>gc}?NYd@(oK z+_gF9`<+8M2!byJL1V1xNT;o;;=6@!rqS7L-N!Qe-hVC$nrj~jrfn@^(0yY4!<;$p zri%T=7iu9DE{6`+Rc5=#`%RPGGAVjpQxPV~Cs?LNE=}SS{g(yYpe#jl<>;rmLyHO& zEH$46+!&iv6XonC`9p&X>i*?7u{9Ts2_!>&8bd@#3;x-Nhvf_{8qgO8c2;dLOV3I6 zH|*O64f<_1J;tM`8Lg4Oh#nZ=$r646d2|AuF2CYj<YurKk zcSTcem(RW0WewJTo%r|^<9g{p)~>_=i$XNXfLH%->NdZA(RILVk0meLsg9yi-;LR53aH+2R$QH*pnPAJt>A@MDUV8w z_#W)AX7$lHkt^pbkS4xk(e+%|zw^B|#rjQwEKwcu&!ynmC;zgwB?dkS7oQK}A8$$` zo)D@XxvTQaHL#dd+~Yz2l0N~7-jhF3iS}u7$}A2D5(o`k9joj_P4bR&PysEYHy(M2 z9FGHGURk|!^yt!8k{bhSg&(gfB7P(J*xA_T*w_@AQd7iIE*2_?EvI}mvkUjtwUuux zzYo+xS0cWx50wVxZ-|&rW}uUVHigz!X%gy;0?gUq$d7hMaaBYkllD-nMA*z@fTMyg z!4dinDR2)2`vt#Cy@)uuII?*z21o56g{LP{5HZ1Jc;8n;^ne+jn;wFNn8w$6Ma<`N z@PVH2mPfBFER0@acn~Ls;E|&2B|ayHcu%YoC3ja)6RhY&-6I_;akQY3s&ntHYBT3I}&D83jQGtcCo61!KS9RJ|0Y# z!ni1i~~mW`|OO{A2FWp!HbE*2C3OrI&Ok<=w6=uIvmJ6cQ~8N`f<_#ZofV1E zaQX?B`^+0K3nw-UP90FBc+*Gkc6;R9WyMK2Q@R&GVJrK{ zIx-!j`gY&N6Q^YQG7_n}Rs)sA4wD3ihvM2_#j7-{RiS`f5*3})9>l_)`&%I=Q_jv@ z>(kVn+`2LrPeoPNN+yvNW1s;Djq0S(OPqA~kBxGEzk*i7*`aE8bS*122R3_w-+8~! zE;Y*>KQ~JYl&MtuRp03Yj7~B+%lu<}kZWQxxgV+@Ak+zd-19q~95Mcbtv~^~x>W=# z>D|0dRtjM>&$1YvhDAa2ir)oyK_lloY!zW9vQ_o%-LJytfB2xNeEV}1MPqc9|Z1K{v5OUgQ8(!Owa7! zQ{jmxJt*llAwv*T5NL=SFW4=Rw#lMqz1dM0&WJfHWrJfmw51~(>($) z{h|-Bm~ORSITNl3dbe}CBWV;?=@i*s(C=z^uV|hK`tdmtmUT9cfJP6y0hrQKevTV1P8udZr#lt?}C#GuhGumSdFlGmPb-Bw!EMGcjRr^Vgq; zbHd1hv+-m8=Kzob08ejB+3$sJ!<{kVCiuCSnHrWKT_9wm@YpHnKw- zk4jp7-Gx=bWd+1*D=Ui1q`u)uVwvaN!8F|PfBR<1@X3P{%Ni6dk3Pk*E_u}xJ#lhM zY;QD5buAY3xCebIV(|fyDiy~h%Dy?Pow}oa2aj+}u`c693z%$_$j14y&Q4<#=nUDl z+=ige?Dr=E@ho2#yr~W z8RY6=iieg$(tUSuncFt~R>hah*HvNj{K!@@Rk+sj+Ulq_b_b}E6RLD(N2s1IwbZ9p z+TZTs9=RV|$m@)my{gs$KAx@DsScCcOTv{AXIj6Ggt#tYslnS1(ovbySlPXJ*Z=Lik{*l1eZ{`luAex2+n;dThUA?8=z~t&0@ctcrFDF^{4lP@xcT z)paK@RX8+Eh81y@78PkkW1dG`Z%uwKlerCyxxayu)ZS&bAw=!xkR zKk};E!SghAXh0MiBhFDN%?;OgqiGA-Uk|jYf8E})$U^1%*dv7=_G+re-u=Q~*M+?| zEMk|%EW6;9BcXrNvOCGWXe@$wOYa4?nrX zVyM37rauUU@MLS;kl6*zdo(IO7h(|d+dJ@8Zn=i=U>WvKXsdJ;nADl?B)FPtzE1bD z_W9u2j+t89t%<6pzejJerhh3VPK)=^u586W_wKg3u=drdGy(+Il^fMnRnELf*%nm3 z8*1MO?Wo?DTDyAMvb~TUv){j>97ogXou^CZ@%lAQdairpM38oA#$bXMSz6n>ijgV5 zV}G|prsGku&YJM}gVfkwYvwYmSP29q2Mt@U)3u!gxc@?{zpz1X6s}MK|Bmz1H-(9{ zZ?8dnDy!Pd-9a7B7|g`{T#- z`0t3A-U!?|Ol|u!AV4~LjPH?pdETGGV@e3YTr&;2~xM* zu|0wH+0Va6xj-mGKHABce%(^UwLXD2vn8_L+~zFsxIh1s{sK{vN^1+8nTt#KtIZZz z7j5p7n^^1CfP3qDI*k`hxv0du4BKu|$4~^PHcUCJhD5^JzYY{O$EzMqxMTrWq`!<^ zesPo9@jWGkm#^N&24frKLS)q~sXa2!|9NtitqwaI_3QfxlQ8>HJ;S6tpI9;s8C8ne zh1i}*1(hwV!RyQ$d0nj2Mr&HF$UkRMPfKnME8g|sh zi;KV3g|>}ew7-B5>#_*n>o-c#TIV0c7QPF|^~eq}0#$Cd5{>NHfQTw23=Z`+qcswg+NMwNF~Wn;e>N)g;w zWoE;9_Q}o%dX7rY2KIg;$96Z?US>#x=TWRe77ZI%YDxKcnu56EPv}AzrUo%3Ka8No zV(GGatQLP3w!f-Y)=vZ_FGfd=M@JZLM6EA%MIN?7+g}NgG-^?<`_L=q$ce2m*Tk)v zqUNi_y8NqKR1C1HWNwmXJ273<)6>+QNJeLX3mEi-8m>|BfP!zwR^rN_rtUrwGZ=2H z_~x5x^?;f6Y8}uCSjNFRrF&h&JdagE$7URMCc~~__quS~lIezX+oI`F;|cJp#Bf9} zme~J;Fo~CMz)HknZ^GX($yH~uIGBhMmWcDm#7HO*)VJ3eKfLy~Ah*mwPoN;;c`pY6e%kdRXhA3ytWUdkZw2d-^6f6!9HdwuRPlZOsa z%RvuKz{cG+!JqXze(XPMcl=m?HtzIsDA(@%kVZex{87r^7Bs3^9h&1)A>!=Jj{=J- zHgwTBJEPSgac!HR1B(`T_J))ksV=b|{iSJh;gIQKMpR5DL-ZEQqLZDe&>uQmt8Mt3 z-r8J`Y!?uzLF@CcAUsH#?iO36cS>$P0-3s z&(U>klUzfY9ZJd?o-y-R+}y7-yHC1kykHOdR1Wp@S$t0+BZsF9D^BkX6P7a=2LCwe+~T7@=%#vnDrv#cQuxtdFd7I!4h)H*0uN7yVw-i>UJ_I zJT^|*XK#VcKqA3r>+r`32=xunVN36Mz^H3Q|E>Ht+zZ!T7`m^ z_u+zd;VszTED=?@KlQ2-p(Pg+>q-KoFH>j4?jugcA3!_Jj^uY8DAl>l2gbW83|#uM z6>Qh67^Mla=%r7>p{Czt!{cS9>&rT8|2ZOL)jK!Uf{}DEw3LuM5k{Y`z@pb~fNTe#qp2`5mz2Yl!wQl(;>L4OOr!*E7VZC7rg0|gY+H6+M{|q!{<=cBR zR+ZUUXDTePImkd~xWn|8X76y9h0*Yg!CRhiHx{MY$scL9SX+20MJrG2ZG;IKH8_by z>o@J-L^rymhmk+-NRbndH>U5-C~e!tp9Lc;L8>5MooD{Z*d^$zUI4g~9t$>6X~rTc z%r518yXST1y>LXmav}v^y}VLiVT)QXzS#LuHmf3&MIIyi)RQmLiBrT4RN{EdR`j5V zZk)G~XZW;vvsT=79VtBJ8X?n9@U5?7l3TB$Y9#*E7OtXT#o4>~qMA0|0|!ewoi>C@ zjYcQU>h8W#HJ67XlsZ!7^U34M9V5ReJD+>ntZFc))=8uL)=W>y_D(S@%uX?6w`93$ zPp1-JX2rUJvWjNCH|vo4=$!4WI6hIOrL1ymVRNsXI#)dW$NDR@vBv+?p83SCP1apN zHCKn{mXaMZ=x+SI@xXTe$&c|ZAO*{gVe~M$gD`nZKOueE;`d`8IXD>S!?EH*!oFF( zW#fi(N9`(}P1dGtesb28)9__7K7-@h ztu9Baxie(Rnkf=jos{y4hv}clTJrMcL*MI27d_?7)4zKKo=Jq+(vE)o*BX}dC#AK% z3SqBUuZwTukuPIu4mUaeQCQfxfCTAbuj0-j&zQ=^!|zX$(OH&F{qQk5&G50><=^>U zJut8lyzQ^;QWK@G&Mj6$}*>KRQ54 zHcK{>Ol~6FutzPos5vxOt#ya{ZDNjY@66w6cSg-CPQTNbNc=k(Co+^8aTx}coPnqy zvRt2>j_t0Gj?C@@Op+XHFWd6IP((i{d?bFte;+%C#xbp5k@f^3Q^?I&vvZdqo#kH+JbV27g+K&fHKi&`Ea6ibLYy+=Hsjf07Y>#)KQeakx&%-GFO zjj9qF$oG2x>b;R9_G)ZEU*>N1&BTaBRrygYs0v_!TA31RU#Io& z?rXIKp~4m0C^6BtEGn~wxZrWMrHEm+*Q-V_I=EI~Y8vWPplj}yDyzX<{PGyDtF+aW zbz8_<9D|P4l*tQ<3CenB((Q@5WGLB7Xn8D9#_uI8lbuZ-XGliFLQjL@$OJjgD7T(U zd?GfRT;i=mok3F_belPnN0H2iRw6T&33X;2h^INU2y=XJ!K*y<1jnm{9nAotw6@bi zqrDY_GhHevE`)|hQr0s?U;f;r=Bs{-qn498gVxN3IZ^Hw45qXXdps-{AU}*}7{$vl zV5M#g;8nDaz{vyB5W92GYCebM;vETNF(Jc%yNzUtz#Y`3dtKHfp&Q1JCmJg{hh)~H}46Hu?3~DLTa4fYTRL7w;&|P^ zpvJfw=nT{}WZ7%ZSXQTcZJ;EB#?7zHPAJ}C#7-l~u=c*gg8vL(EMtMtR3?20T(zkw zd5-Cle^CP&elQb@rsg`aBNYzlJN^BI?+AD~u`VN1#q_V(%Y}5hDJj%hF0O*BA>8tK zTgtKmZ$@q&n1v2nyqXpKllpH1u7-3#PVwq$T{=LW*9}WsC}Cc&Fw1U;UL4hf7aXvs zY59Ul=18N8yZypM)I1t7(wso@K)@2o+<3;sH$K`D-#|$Mb;mjm$?AK6Z=90Y<2^`8 zGIR4=Nn8`|aqTXfT* za&x=jM9S-ap2D{<&wYK`!}}TY$G71m^WZJ#xW&jTck8dlJfoxeq0BQ>$kwJWVAG@IGbWVYzhy>jaO02p*cgIT)!+1LZnT<*1AMos zrZQ&8s%NC34?qV?b(|Rcn+Ko*7uI%CCEppozw?yqSl|228T@4(BA>;}7;wy0I{Cig zOgqTwnHNDc3=>LfvkQ}FPBcv5udjAK$!UlzwBG^Z?go)xODPAHW13j5z9k+xS=gm?w zHnft?x_{oLTZ>wdKvhpd1zrnp?5C0KxL0*oic15 zoq!rB(NFkkeB3>ZwHLU^Mo3gWgJ>rD4b|v5z_E7pzm+-0Uq&Wv5WKK=yZwB*9m6$Q z6K}bB^Foi|mx0^F+46fx?29t@Cw$}4;g~2t>2GYSVI*`RFuLYtwzyw|IC@koPs`H< z(ZF6Mvmzk5MkQ2e2M=e&A>F6XNe%WeduBB(W^>mee6h$q$25lE3j8X8O9vEG|8;NI z4dq5RkjUH>)0?F1dn^r1^>iY7*spoKggs|84$93xCei8kGb)qVy9>jPuNg)gzjHn>otST>j z;M7tG+=RSVsaN)7$~v5V`IgQF^@qHPeP-f>I<^iOj~B~!bwRZ;Ys%ZtLow|9rw}y9 zZFdbwSnB+x(UMh@eE|JCM?Q0}GY}C#kyV?|Kl$d4Qzsx6LIORYX8n3h$n@&(9q9nD z2au3o+FTr4ZRrC3O^Nw}=ZGmI&l`+q!;eT04FNq z{EG7NC_M|$ay2LuYVoJhflhZfCue(ALNUpx!oZ2)Ly zl93bR{9w+iJ#nsUy>Q@@d*CFvt0q;Q3HqPJ3HmiGro%bBBiFAt+8_3UH%D$|3gh=y zNC^h)z0aa>@Os#W;65YE+OC%;7B-`*qTzODoWQJ8g=*ID!?ah?x_MSQ3rC)ZYIi@{ zyAHIczAc~<#m&i>-i`d?B;Q5DXL+kyOaBIO?=Wk+Inx1Y=Cj2vm59Z*kdKQlxD?e& zhn`{N6r4hXnqxQDT?;O-Zev5W)<;5{-c?2n6izEJL|YUh8W)g5$Ldatq-m-?<)@+x zksZ@UN9OI~pbM2;;zd`pMhFC-HD7I|h}RNsc3nr zVL$29wG@k+g^{1;2-;SzGbzU$wM(fwd`K>u%hW?=X;lr{^Aq~%Yaj@fO&|AhbIpic zn8ZRXtl8W$p4!mgCD?4Kd$rfQ20tb5j-i`XmYp)&*Ok?BymgoT*?%geaBmvPbplAD zfd;pgCf0SeYhGLNEYQ&{^>$AYKcCS@&mzR^tEuSg8!RK|+J}eNzZJgjKC!{$hZ&h? zGfargA5T0ukcVt~+7e2*(lt{EE(z+IAM64UVHNb1m}}dcjgT@ghtP2+8SUe=Rp;sW zk(cDc)98%iC?q_(!g3qUwy#9f|3PU}^Sg3s)ui|R{j0(tqa%N9JL1|hI>U`>a}fbV2lnBWlNa=?4i1T} zv++nQi3f`)=ivu~n2RR?W<~W69tA{9r#3XOP;UmFE;S~bU6B_Lu&6RSWl?1@jcIKf zx1cgcNhg5S**i#$owH?u7CUFx#60*|sU{+8ugzs9V1-8NNT7{n;4n!|IA#!(r6K3y zJ!6vGZs-O|22q4>DK?;+gj9WzC~SWMaq+Bo`@5xYwT#-S1wIwH$4g$apA{Fn6x-`C z-tfwyx!K%2N5T6k=E0spJI?f+Dx*W156t+lmVyvQYs-jpzRitb%P*Y(LU_SgZO+a; zUGb|f^hMnDQ0j)ZKf`o-?OPpTZxTx0=0^pr_l~)SH@pGme%+DBBiWFC-FJfJ<^23= z6IGBZEuZS`VetVt(PAQB$$MF-61F}`D|?I<&4=J_g)E*uo>-n4fswExQAFVY&Adz`1$QRycg zS$o^N)rNRn1hNSC+)aWcVH=Aw?x+Z^OjA`-*V>hr*D;XybenQ{aurUV4a*KruVl6T zvzmNzR*GOl`8+G}L%XaU`);;Jv!Lfk$)`al88g@vtbJaQg}=OlWd})bLxHSSSX5r@ z7jxB7s1gi}Z5?;Hq^40>sVT1=R>LMm)Ms!-lx$q#9up{{Nj#?&`=H8J%gY{8MkdKQS2L{teM zmE+HZL`ed;pzzs}{Gr*fmGxAkK6yV9RYay2=nWErMlDH{}fw*J0YL5S&(xW-a;E97<%uujGgP*kZIxOVi_NsJ^ZE|n>F#cLC=bmy>iA)qtbZ%4e@x) z54=%d6W@u>MfWC8Ff~|3sQpKcT$}|bw$S3Pn3W?((srB@1Yrgu+b(1(;DUY9oHTnA zMdTv`3#!OS!hCU)!j-+_uK+`4oZN!Xf;f6{itMT6*J z7V=@;M1aP>^l}Ah=UF!r2^K()u6E`@k8G2^cN!VSWi(>f!-}1UPtRR! z(E}Y;v*`0JTzC?D%ON~yBJHRg&+e%qj3 zJ5v}D&hwtmLxPu-7lf@oV7(htoR?XRe+u^aFwzV+J;wJ1d9IcgWZh|;>`i8GwkA#* zUE-l1{tRkQ;nuymMp3*dpk7UR$Qc9+5>f_ z9p&={tDS6}s#&ordRNJEjDA(dz!#m@QnciB>-=Ujv|_NS_5P<$4&&`l616XCGXB$C!u5S z_45OeNGsJGyVPV?xjN@&O)dSzy!+|8Or2>@oynVw|M0sCW#gyNtF<|6;cMhp?IOvN zt<2fpOovROX7%qyt^Q484qpd0v^)j8L+8y z=iZ|iV6E7tvEM>|gr6wNVD|;B?jTc1*VwV-PgA&nucfs}(!v;{5%M7{-GgQZtL)xP z1a@^j617e5Kg7If@io)AEeIheRzLJ-H(qMd7%GDC?z1FdK5O6@%FGbx>!lK2HW8U6 zG>sJvwMAn_F6QiGqlBy>6Z$?vw(=xBEp_g)nBDrr0vXRsLws3;=*!rbZt40u4*eIN+f}XdxC$gay(?j%0Y8{}a{`B{Zb7pKgx$&I(`mjr< z@f;lub#Z(qGlW{pY7zxR?13swk(Nl31_bY>_D&N!Jvmo7a!@n^h+UDczCs)}5g3GLs*zrY*_ zRXHZQAi?s^Dw2Z>^zN7q2^GEq!9R+!a^=0f#)R@ zV#pf2jBurvQ4XYj^5hBLKMsmAt18G67d;J{FbgTj5-mIqsxr$c$dVkPw~CJpEH0)V z{p!y)SQezF!`z1nc1)|7sGRP{sD+KBRtKRum&UFdrQIK z;)kc0DUT-^eK_F8>gP<%?5`i5L1m}VpqskZ;Br|#Z9Gh{K9&f<| zfgb}|lloBppGO|)1_+YBDHh?5DJA}(2-;By>-d4k;z5o`>>u*Q#Te>Z{TK*6zO`#2 z3ER!`IaEvrxiUuN07A(-@tTFO4z`jf(ghvGtC=Tp^XG_*Xw5@3-c*jr%%h=lB`?t# zWi}D>cME$-O?mZq$Z@}){^_3(yIZ9qLH;umM&l13%tSH%mx5BQ-ZzH@+93_Lsr$Pn z*{1ck^HQz+SLsr%F+bUrhEaqu46_osDf{UM7O$t?B?XP}O(~fwM&xZ@ze{oq`QF0y z&Mf7aGw7?uC0gP)TbJPSFlf~T(~yBYb}uw5!`~W&0pt1y-fTUJAU?;(jpZaq!BQJtx$>-dYf1eEsMKF&6bZ-JSH# z*-@I1F-?2ubzfY~nVbebN!rlzt&6@Z7hN*fTnJtZ{#|1I%t*iD#jdrPqyf3GtXS5s z{4-qXU%|L#8UKtAL&CWgYhW*S~A=?a^{a zMEV~%JZ}B{3yUcE%4ltliYS|_N$w`e?zZ4)yR2Oc@9um_i;_16?4ooy`6rj9oh87H zuAy2qADFHX zS9}6BWnJcc6oI;KluyMu&l_IfzMQ9n?T94kNy8Va2l@W+Fi!IyPYCPI6%=p~WFZ{E z!SZASj@;tKrUQ2_?cSOZ6Y{$5kfIwDATVzdpL&{-AN|Qep|A(8Rt>XIZeJ?AonLNR?O^zc4BJ_@yKkCf;dm`&ied zMQBY7Ru$ozNXb)6cG3js6dIHtSZR}X)+y;I6VH+Xe`dC6R&NlhTHQU2h8wN2t7}qU zu1{s-wOdY5742x7){X?I?*l+1{O^TQvR^Xn5=v{&>Qy{TmZhV=nk*X9m=xWI%f~GW zf!73bL711^Km03A#PP3ArjH_M5;J>rXlj0WjyCrWquKz25h?==8i4tXtAHfRV_n zG`g;bk1h%z+qp&-A}$@v8vy6kR-@^Qu|K&^iPI8&1G&?Zy4a^bV{9|2{3CZSbKFPi zJn0d~aOM_Db0a%|b~)@ZmLt1Vy=2-S9Z%}|4ZtP`=*NBBk>InML z^EfM@WG`1nELKJwhJeK#7GvWJ`2ozP4^F;cSH+dEdb;r^)##e>Zv!srm-n=^S%3(cwBSQ5=zV$`>my*ftotw9833!EgUq@4P>rZmiG?T?>o{8my zK(flWdu39y4T5eve5=phC;6tSK=X8cfUM!?G@Ai||HG9})$9>#P2u2EfcJR-Cv~2l zmUvi=MDKINyKY@Z*>e6mnlo-Ecui0e3SvsLP0!=nEUEmS`TP}*{1G-6y>Fy?;4l;< zt9GmSy20!q_FV1K-3bl0Kf~Uci&I%RqCZ1ago%y;ek_7W?yrYcB_xa9+9>P-gdL%K zBCakZ5y+*b}wSmT%=4%sENC+9I(v35TC<@;#HJlVCvj-l8mOszO@+=FiGSTUIC zz{JSMgaDQn)W)U>3m{@xY*npa#VeuO$j~@4nm~Qlbgx4Z4Cf)r!&s7|l6=s*ZH-afIZ?CQOU^*OHJ!l#O9UU^vdrBRuCtIF<&4W3E z#*=+HObb3Mp2tK^#Uep@MCls)$xPm!5)DlQ<;MU6S&oYodMx;7c zCPN}e8<4oydqYHG|1cKa^cH(%lG^`PSa|{1h;65%zS<#C4eB)iqoYD6a)1eIP-$Qp zYr!Pef^BsOa|#jLHYgLK%eQH4cXM{Bl$5)_tMIOn@d_pN%&AQ8M!s1bpp*6bBB#i#+>%_%hAMZ_^bo-_r}FOekTe=rbnPvCnvkqK##n~)1U zV=4%#p0Xsf@Z02}aV!`}OIJ^Okr9LbbFx(8u)(6%>$a*XCCFKH#vSEyYwAWcTVXbf zqaMo4JT#vs4cPx#<^KF=W!@6VDw4ADUqfYW9c6{N(xkN&hA|8qV@4`1btx_6a>ecA zqpr{J+$8xCwi=rOyo_I%xCb4gR%pq27iFsCuT3w6Z(gIJx{k9am-|gfB786Z{tV!l zXnp-PL<4Pg;o!oi(V2lIiWp=$EL=yh8VP6wyI+B_b!0Mu{ggw3Q%_=WY=U-aisCe5 zDwA|Nsxr<^J(jd8s~oN-e>j$itMheKRusWEfXA8eEn|ARxv7(Ub=ls>c5`JEPS6$> zAm+lA{p4lM>m48h`lE)LsN7Zc<^q&qB;|^sHX~TPH$KcZiipcNN~dEQGzQ6DrpaI4 zGhK+e?jGItCHy;3e46F`CDe8FTn=3nCMMyVNlc@oWaKp%R;zNmoHQb|G~~}F+t0_X zw?b=EG-!eSzHTmLqww08a}d?gmI!tFR?peo4!M8AUq%V7E30*vTeul}Dw%4rb^?SBkB|$0-RGtwj7*8j=j8c|Y5P*2}bT^t2jRiiQHgaiuF&38v za)zLWt5gDukrealE-VZslw^mH;x5m?NFgdcM$IPw`)rL|Om;}|ry|`Oe=ODS+(O&k z;Rq$gef*{5gOIKVUuhmAs3|rS5u&z(8C$Q7MiS=B&m+#cg&#e~pzR;0 zgdiwmpf?C4_x5I*fx3CL@jD?-kqE!?t9xr&18v8Z1>7r@JDV}J`6t3BDSk8 zzrzJadPe1i0tt|xpvXKJRe9E zsj47zKq`>NcqzM(bmIDjMV<*aQT(%Zlq4^rA4Ab4KTjVhMs}_K9DG+c};sEJzOhb&4)B23Kp^Ee~s7nQiXNL)aSDK~F^1}~r;ZGNh^{VH zj?3ByzXwMeEq2e4EVGf<(nI3elFSKe^BH=2LOY6<3M_zE43}5`TUy6_}9St;G>7K?L8DSSn6i^41@J?jBsg~;a{F8R6pe>wxM)D zdQMZu^!@*$%_Iq*k}=(8WaR`co_nT@kiMY!);i24w0b0AT0|QUO6u&+5Uvlr6taw} zilL>eEvc*aLkmS3gGd6(FJpY^q-U%G1Nus|K^u2N(Mpc)nsW!5b7THu9qMWrRIa(~ zm(f=n-wzb-uRWQ-_EzTx%=dLhg>{%zg69WJnh-trG&DknqjTQC$aQ&A>1>&xAlYd- zg72bPz~3WyMt+%3aLO_HEeXD>DLhROUh!sOZd8;c2+p^wM|OTP^yQS6g<(I%em)*M*1?ZfLk;O3uM z#7Rot-$PxW$EVFlDM;^TFE2`5!Vr&|Fu+Rnr8Lgn_Adnf!H*(Ph5dtz1^9nHl?K)# zKEp8(yTfXF4Y`D)Pb&4Uy*2Q{+W|XqMRc$4>@R_v2RyG=nsN)aCq3W}wxvO$#+;vS z-SZ?5dZEpFcSOhXYht4_klqa?Uu;(NcV{7VWo2{t691e}3Bh`e33=ThCaYiH(}hZK zb~#Svf3m2B1DdBobibm7gWv(s?pU_zt-(|zS9U-l_fVhUU#}RD#i;@8K;FZg_Q<#3 ziycM1!oVW%V8T>?Ngaf!fsG>BPXDFqMIb-Yz^Ajl7KO-@o+7;CTYoG;mQdmtXb>`) z1!F)pQrf@n?rQPShBA|t_b9(1C^7=?Aw0UwS z<d(yA?qX$e$;qHn0~@gdwCi zSGev6B6Y#NLuVzmcI!;BT+cRq!{84Xivqk3h}}Ha@;7 zo9Wbh`x&Qxu%9^fv;D-WU*RWC{Z)SQ)T<|`+0;vAhN+jz3{x+aVFIV#XE&UZ?e@W+ zvaX#;$2*b6QLOZM?|A1eu(pFP12R!z&(@&4YiVK`9-~2{^aLK#r>zp6`Qw>S zj97LA{kjAg_F-SOBc6B9u@axxDcyyO_?BsG5I&EiU{N5k*TAlD28)TNV1aK4tsOk- z1U9HM1sg54R`9M9*!c+*Y_Qn3-A-UW-?fLeyuK45f5NZttKQ?L!z5^phu{!FZX1}g zkaGsK!)IK2)(&q$J;nER?=5spI-d#mct3;-EvRFnws2*0EtCM?bfk~af;tXr3(+4n z(?T2!^Yw8;3sHuz7}s12hk&0OlpwS)*zgra&9u;C=P)n&Fcf~3$=?33@i$zc5Ia8n z1`jdtU|$7-hp>bT6_N%iN9U0WIl!w0;y!%CyGu`{u4eNmSI@vGkCnb#=3;4{P#TP->7IeT#0&~L96|l= z)Iky9wE5mUq?edMLAwG}@0F48H}dT}3>7vjCKbNA11tQBZ|HxUp~4%ApH!ju%1Hnc zIs8@`F7PT3BV3gLLVqH=+@R+Kve69dC1${ACIU>Kal&`Df!}tA^v2sTxDpN$`MmHN zWMKoouy{q@Zpdu=t)fJZztJS~<~!xgHXnO;>?LN<5qby*bA=I9983-LLIiEN%>XJ6 zqYjEAxy;a2X(Tn!OXR_nzB<6{s{_owI>79!1B_oC;PR^jj9(q#@~Z=kUmf7`s{@Q* z9pK`tiM;^!RoFMMujzxRKU+=a` zP%kk9FwrFd)Auj_vvLch94oiU)jHhg>1(WZ)i$x(4Ulrg8>@};@B_$+kljy%ELMTS zZ{7u`@%hjxAEkZdLl5es2`3v^(|pf|Q1Me4}*fC1%+C zq4SLhy7LwT=zB_x3_2Y^p982^uSik;p1EAZIe!;Snp-TYLD3RAP(wT5i)egt31Lb=$;(&R$<9cP;x8onP=e7eBPwCy~GS#;gt$`7ePI5HGtywl0a_< zP}{BA_KJo_34rIPLB8Y6VTRUldr7VR4y|oA*ez8BW_vETr2@%y8abJ7ILf zE`#}6s#2|chr6U&ts_{`41(M1DLk~^gsT6;hf!B4R%iztNLBajiX10LRohwu%1EF=etLpJ#NMWk+4$SsgzuZ5hr z6_9!yQt^L2VIf-~Cp4wA{Sf?*_!er1z@A8@(+-u>h5a=mTIOqism&AtI!+oIkd!iA1ZoTk;=a<0{-pBc;RJ(4KG6m z_$0lo2N}%1{2jW)@u)~}z#rS6GlX-(x|E+2x6TyKiJYbEocL{~a8Be8))6f|C&Y}N z%6J#&ga}2?2}3m(=Y&*^o)hDnIwxwE3g<)vuiKpn=Y*Px$Ur+M)(keB6Jkchd9#Fb zLITBeLIRyKOFAbu4i-^;fp$)a`ShF+GkPio^qeqM*3Sw1R`|-qjIR8|IJA_X7-Sht z>w|^Di4nVuofxyQ#9kzv7?r$nc4CCBh8NTGLM#p& z0lC^~A+?03h162SET_|g9T(RQHXIjXMyz+Od|Zfy^tcc+dU9y(xX}0)wmpzhNw^RG z*mlnnxRi~{`1Y7zEO04%mN72n;bIdmMcW=?hU@JiLP=ao)7wL;*8KK3w#na(mr~#^mr`KDrHI?Zz8tp4!7iL%DOk?8$ExKhlbS8?D?697 z?Qs-Kj?OmWSG4URX4r<5nD8sw_K-j?FJb&jSROPlaVvCtw1r$JUPap;QcE9}IPofO zF)Ot#Vpa^>BS|d{x8U~h0Woh5ih3`j2Ul`=xkBiXbs0S$lUKm}ezKFMKh3j{XrF;V z8m)lzmEL}~I{~;WWY}{cC+sIk^}ES^AEK^s@%t&X4VXUOagXf< z^6u7K?ujG&s}kBv%&^@uPa!h_Dr_Mhu7Kgo9&1PPjW!jQB%a{R-56&@k zTAtzPBQScgI2jAQI@)K!gUzc}A@4x0?IL*i94G7+__GmVGQ6zzJqU9Iita|35%BOR zJf#0JP(J~B!|$khk-fyUE%Xc^cL%9J&BLz+_&^Ol`fNCQk6|CKg0r|METye@7C#UV zYi>21#j)*d^^o}-q#bQ0peH1em_7eBp_<<7Vv-oMPo^(L@z_0Ih!U2UDE)OUylnyA&Fdk4DJ_F@@9bb84(=6E7 zY2x0+OxU}C_EjcNKj$3uoU4N~?pEQPJ5sNmbIW5aB>C$zoX@#ctNA%MxPhN@J0U0R zf(DKhk7DYT2D5W6v{68c);0W`%Ylcmibmm_t6gKnf8DV9_C^!@hl|Du|6!(h&TU=8 z&$&bJV0*WbpL4?&2<(bh!_NLzn*5kKd$7Mh)N(YRh?&tmH|dL3M|*FvJ> zCXX&LzX9x4NCdqcZ0ogHA)&BR?1vyDtO`X|*iq5*iigFabNFFF*1^zTy@nqa z9%l)MMeI6uSPVOh9~Kv$C9LdZ-m=CNi5a%v&gO^3zO#kHLaKvnTdFf+EnnM<&*p1e zEDq~)Ha{%HT=B4wTF3P+wSM(lepvi;mMK#-Yn>TWv~wM2iclLr?A^6|N((U6VI7~+ z+xdGaQ#53q$mgERvD*G2y6Dq{DH4m>JU_s5DBAvDoiNX8iNq9%nIcweKa}NbOp%yj zTX(KARucgPtoF*e!rX^&7!9k58Ma5(J7YDe2F|=x!|yyk^EK=F%!|cgj`adolUl-A z7BiY;iVmI2u^PI~u}wOUW3~6r6R=wBdXCj*AxzW;j@34wCt$Vp{Dmr(64SQo4Nh2X zuK`|6+m39In4)kH*Kb_UnWBbsK#JwbnW8|=Rtoh7m@amAgOrYI$@YD z)%X3<+siRyszO!{6R-+o_5>~qvgrk_ScaNYuw?iJt;UzJE-Zxe^aea?53r;5qx1Pu zdw|Iw`(L1t9f4giodc(^y#V?)0Q&aQVK2bZ?|Lt4qxMn#(fYV_szDsY`goDrN3l%m zqs~Njeh7}0Pw&*aXS~-t!0z>g4q7{?J?qexP3Ne0+7REP-qbt_RbdY$Fa_#&Z6Kdj zs9rKQ3jch+^V6VuCo-rbPZAX>fkTbHK+C$qhh`CVGD~T$vzQl8Uxj&)G&>^%Qf+$`5M?FEvb@1z`!-lkqZSj0; ziz(t?@(dyOz^~&G93~AUXAo+^wduH*kooZIcv!(YdJCU+hvMAVp(uSH6z^2znr-o> zl=#;`*^^lQt5jP6Y4ggnu($UENSX4|bj2KI6qIjAnDvTtCppXu2M9R>dpgamr)_#1 zgb#sVN4kRWhGOD#Zvy-oG?+i-jULQw#~g1m+cC$Rg&!-z4b>#N1$v~y=6mRF;D_KL zel*-;TVazp-tHI?a}Oc4kdCN>hh^{(8F^S1H-!*igD#~~m_uRg1<**`b5QYINQYaG z07{0O5XCn<;+lKmWk*nT03MRz!M+E9Cqrr=rjB9iM@WsulpQ`YF7G}|HDr^9l$Pq@sZ#{#JfMpy;%8%>6i;%mqb0yChnrP$OQv!{+8bDV7ROD5L zw}t=cA*(e<_}ov(tuI;RcMVb|-Vb?wzSt{Qk0=~t=<7tEeHIes)j(pqZ)v|zQfP?z zW`aVFCgZ|L4xjlrERqz4w(L3Z5LXW`J_mB+pM;mxLQc=Gy~01-VpqZ#xplE7asPr~@=J1ERMgz?}Onvt(f}6|nDmyq4^;%#|} z+BT>~BPhH#g{QhP@J!LLkI%hU(y=Ex;#WF{A0y;3_;vKR;Oy(wM?%gsu~0SRMy)jD zvR+;A`3PE>`)+y$y(Ly_Fs;=AJEb@xEO^#I?=7%G zSHdsknDst_^&X`G@caQZVC``8*VsZo+97L)v)+VSj!aq`l9%7r8Ip+>AH3bRw(syw z8v?1-bX=_+F1xl9l#aA~_b`$YkJ5%l@rGF0TwaFbg(>=_M9UaOGt}3Nm0mNJy+-ZQ zWY#78$W7xE(jSf`M<)v-bL5ZgBur5!HbumzOGiQ-Bha6obVXbat0C|;SP|D+3f4W& z*Z#G%vP5wqVeYuj0*u6DN^$9nh4?;%hAzGWQ39{J9`1*I5Nr76gLF2^cNCTm*^M*m zdG^sRs*U`eD>yO<@%${ngFV{)cR{Wf+;zr<)eayWgZNuOI*v8tQYjJR;Rl20-vF7| zMqGlPIpkr;YzuFV8`w6TLVXFsfMfuOEBzMk5VAkL4>%CWqNO>QBL2z12w`{QdQtqu z8rpjyLuGNpC@Akpk4=PB!f#vwV!ePpQwX_voHx-y+F};*e{v?!oiLaDt+)Ilz7M}@uVG6nG;0Y{WXMQp=(@9T&*{Z8=r|?=)o=@z+(Jnyt+ZnxC8ZF( zcD@=~Y7c`Md#-|?t!PkIN`FH(ZHtWV3(0`%SUWIoqq^>?FDc|^ z_>JvCiS*<(QyGeYG&Yd@4y19RLHco65)P}Memc=Bkx-?heDR@72%#{J2tS$V0MK3% zUEEWd)R%!)2%yON#r9Bw4cEexmHhb5r6Q%{ctQCl8^eA|5hwI3eR&kEZ? zWK={edR9_Idj%EI?rUBVt>}=Xi1wCiMYJLpifDaq7Ou8Y=;%GYeZ+X^_>+*|{0(^* zVsb-{TD?v;?l3xJJ(FG{Y-(&t^HVPq8mhZ-YO-RlczgcnrXzi*jL=<5CGz zy4&rjn3x6YehK78e+m;_06DSif#^I0z4!$(Y-{1cvki1-avOOh;}!)O*LV>H(Q?s$ zd05qKSg%-r)lFJ;>QOwduAS}N5<+%BexD^fEK*_ju6|LtM9;&8{5U{ejtlu!VIimE zCzY{<{1GnXUjXVGT*zyMjv`d2PQkXgQbMl8UUa!Z)(G&vHb_LXO9Uyb313`>OU46{YSj;P%Ab1#GV3v9yf1tKu=V zOkBX}pSF=12=5&o(ytK47xUtO=_2tIw)fz}?!E!#<1=>S&`!EeuF&CEVQ6WMJE6uI z*U=iwaa6|`UeO`j!_U?cx>m=UT_KeB8F{^oMgz+HqLdlsCt-iJxlPunq5F&eq&_!K zt^u2^vwbJbY*wd2kh!nwN)*UK!XtVPa1Tdu(>aumwvAA_8Zu%&0PJb)3ftg|_Vyf9 zuCFd4&})lix6CS zwzcq}Ejl}@e1ts@Sr@>I?Xj5p3sP4@Dy+DekQ?El&%@v9-->tK-G68oaSar{2>B6* z;o)s~h^#k2g_i}ildi@id;l4&$2#foaQU}R%0j48(V;g8qZAkqJjxyGa@NB8{WaNl?y+n3u)$exIWKoe(M+BKv(C? zyIt>jYK#UT#oMGyKM8>jP-alR36=)(O^(P}IxM9sU=-n= zy#>(eT%9<2of1d;fG`RI$!=^fDxFNex||b7y%=$H2W+qRH_-H!7ocyw+sZPv*l2+` z@}+&77)N0o*=-HPQM5C0G?;;|ZYxU<05m;)mZ5(9?qEap@pBo7eHN_V4wnN9r^Lq6 zoP8tww^cw1 zJK*elARXpAmmO>|c(5Jo&JMKq=CT7V9uG8oC_Ts`;wuQD2idX;c96y3K~@k-4=~&F zkVy})PV?9S7J~=as!(=tmCyT^99%m?*}=7I-sw8HzN&Kj;Ci^q<-vuNyz$_|Jn`Vd zw5|Vq_24RUI=B!(I=EePK^NdA{3J_8nzt=|Ux2%W!P)mzOMjRy%pM-2e^U3{a7Wj>w=1 z{XP96UWAu_gqJS9b%cBi50N3S$zalH%`73u^?wa5A!iOzK^@Qd%NkGdy_H}`@{KaK zi0>#ExNsyh_C{Rdg)`xw;|C*B`qddJS+`U8?%NIfhQeo4Y{Yg=p}1>Ex^kn;J9huG zy~J_aM!@=s!d~pTt{LXk76PCjU+01$wXLWT$SC4?PasrqWMY#9LM51f)TCc>@!w3Z zJb?eiFp?6z!r_kr48Z>e|I+8*C?gM%Y@zeN4JLLi9p$2n@%#F0H(;CljQFV1AA_c#X$ z$I~JpC701%omQ+SvGc@_O9f|X?>+|oNlzSMRu%zxUlWoZ zCg|>A9$<@JV%p{d$H*Y6t5i4!{-ww7lq*nOrNWUr(RioI1ef4hB;gWDsKRBU5tC3r z5tC3rkHSlQB?O}7?s3Xh3J#)`q=-~#qoNKbqlybBjFP7HpHFJ+u`yDkvFdb@8tL_J zlNvttE=dhkt~Zhz6kq;gM3>_jp;6#OXt+R^;~1Gy;6!HV=yDuGmjy0~4C>qIln@z+ zGAWUvvmZY1pfURQSJE5V&)^@5T=9l%*fv7mf#28xqM-NaCYpl;M|&!x%~sIspTNfS zplnRm%L=&h6haX)@lne7>om~l z_kjJ`3ZE1^5XiB?3kmrhGHlPnK=|Iw4I&Ofv9GtK8#RcqIs}7=90xOq*Z}pYK}4+s zjWZ$TmO+FsF*k_7e90h!vZzi55twUY5J6itHHe_?iUtw1T@!-{*0Q-l#B`VzHw_|s z0;pyXfzGtULKXoWj_VbuQ4Kl1o)()OZ$xc{Q1lRLR6h+5Pb0B=HJmfCJsGjvb}=FM z;Yl?X9v;U7=%8>?QU5FANk#pyj9UT=XeZUG{Q+wv+-9ipiP62%HmETgpu)W1VcKm5 z=SpD@z`N(-3ZFg7(2{sg(Uy)u1ItHIz1njP2bPIcW0?if!5e@ICcXmw9n7wLb}i%R zU@$`m8OsUPq=$5e0JtSqUep_23%{{Lgnfn?wgD^9(hWLXe@F&RO$hLlLC*!y^8u>Q z-OpJh(B#XMh?k)7*mJ0J^c(!`^V*X#NZK;Lh)}pS_IwIK0^#rArwxiiNijP8cP9MC z%>nqtrv$YcntMCs=0a|K(SDF;z}zQ&(k&u&6<{Su$9Fyiq!DDMP3Rc00y0w%;Y$YJ zzE3_+lfDR7lUnNs;QO{>FMxV6P+cy> z^j>GY%s_u^XCM`aInk6ed|(38-)+|%O*!LJ4ibJHUcSJ$#|{UYG86{u9;7Mfz{765 zYxqOBYe2p>paSk1mPKu8=L>u0*)!2OEl_}&0Tv0WQ`cZyr`53Lu{T?9l=rju{2&8` zKknfhsj~B4B-o3#%it0L#o?E1r|@fy;Jtrn0*zdSB5Touj*hLLA+f#KzA1cBksa3(N3iWQHpVFJVS+jh$x0O~+Ky**}L z;(G{yV!bc%y@*`m`xZPq&bdvlg_MJHwd-!vtKH#5Kk$M_5XFApJP|R|d$@pEwL;*T zNZ3thncU+IAx!Lf*V!ibcvwj9@s{y>yid$~YDJa`)4i?I$#(0x?EcWc2Vr`z=a+gU zlAu`=ztnqdy~(8>o(p)X_w;$33FxrFgb6?>i3z|AU>NC@-pCE?N)N7ARc;_X`!RWn zyMNhDUK73GeN!K!*S2MkA(GlHR|uct(^;;u0BU%%8o`e#vJ!EuGRfwgH?uFcY#(kw zrw{mK7|~zGaN6z=5eue&U{HO5J6TCg2!b)ZnFVnb-pe{ZcSGmJo9=>1!Phmd>;fQy zfN{djdZ!Qx!HnAtxT~-nU>wg0GzsSW{_JTr0=}feIPQ8_e?L-P-PGKJ>3m?|Q!=v!va0D8p$kUY` z2AXj~0>GpbBjBw@Y4ZeMgsXo{X2e8Vg|cj$HWIQOH`JR3=1-zeC};|RT5dP;e6L&x zgv9Mml8(Y2kmr~{-5f=eBjD9rtKvCSykkb5U9*bmtG;y;PPcTfT4agpMbVBKbo;o+>hq0 zC@OBDUNlDoDD|RwA%LP6%}Dg3ss5;5G<%5|P&JOiP~V#3fa<MBGTT|bfVg__v^sT9tm9j zaoP}P8VB=CcpV&7O5+%i(8P~$EWbBmFc>KV2AddG?1aH4_AA!vb$)smA=&ps_B4eV zEyxPH)0o08mBUU`&=kkoq4a({NTw@`sB=xl*$*dvh9b$sN%GOuqjL0h1r?%`y4xD;XxY z+xx&*-FBsbz-RSg2z+ZF^cZ<1N8rC+$r1QbtPp;cfWYn19Dxtr#1Z(;s{{mI5X}+z zDtL&vcoRq9Z*AfTeBMy340b}Rah7cy{ieSv zOUVGI4wR&1w2cV>)xW(Fw4WE8?Cv1&i8t;=tUSqmJU+3I;_(?~c$~gl#N%2wO)>dk zLbcYMFge{gModmK0h34W7X%HsTMpBtb?D-Oka|N81^Ck{jx=gQ2O&=bw-kE1=n+Qwd;D0uI}F<(3`a}oZj4uz@Y#`Db6+5bBgn< z9YpuruKq}V+tnY5wv_M#wHz1m1GgM!*g+;kKfV4`lA%TO1W^7H-3UDNp%_X@bh7;j zxcoxMu#LGI#3whS5?Wsj2LP#?@Ybzu4Iu@PPy?o zuwAv8AMZyupN`|*lzaQ^8n?N(b=R12Z;{uSa&I%-<=$pGac?_uKu2CHocTxl@-u() zwS4!zcdc;dTl?`{_v#kD>*BX??kxw3;<|4Y4*%MI{P2hW5gWJg-Br1jAO451!XsNv zb`=H#!CeIl6ZaIX8Qf8k8;l_53kJ@Z0q{34cqbZw?h}y);0wQ;!LLw3-QkK%cT3VX z_jgMR4*Qwoq{E*5XfSZOYVLW2b2jgE4b(#|m~NZtaz z=Q-Ii6qYa;$6r(Q&f_TiUZ5zHrszoB={SxG<(|CU(d8B*WuhYp$4cW{%al&Ww{GGv zQnSHk%?6t_8*FSgSZ3uQ-~ z5-219>f5F_{OvRIJBtLL8SjPC;Vg?g8;fDnLx_V$VUxJgcGi z6Cg9}D7?A|9%4p6sE}GH!Z-t45#%s{R6u6fRRGcm57BGjEIx!Fd*PybC3NN*$gsT# z4>#Y=dtxVP(9y7G3Av|x0CaRJ4rcrxJ`VZ^Gj`w4jl9%3+XMJ<#D zEbC-j1)0^5w(W-pEr7+=G#0?3>vP08fQ1h+1h8ON5tEt;V1ZC3*R+$G31C61(W{h6 zO$D$xl*S@LM9h2cbluYyzUcNnZS;$>LWIPtQk{imei0YF$P^>sNI%(X5!wM|M?>16 zcj%g)Mb~uu7AcA}$qLhk1#bo4JsM?cm)9bNc_fsWS7$HMQ#9?ui<3Z1T{C{j(26NU?^ zRR3kYB&yX`1r@3g(PSS06p!PEh(-hv$BkBb1ge~ch^H-7*~p>o1+Y>ko^e2Z{W3%> zF^HvCL4p7B_V%6d-}X2FBvY)M3xDGgD<4f4vGJJ)88(hbY;4UCvG9uro58|TH-i`^ zUO`u_I1ET$_^*hSh&o#kw7vEo)Nm}g$T$c=hC!eehCzib57G*^>aa1mJaeGe{tJWb zwea8Oc#4oW5r5-y+?v7g_aQ7f7fQZ2E)Qj&mEpG<5I`FD=-hS^y_&+>En=_mmG*!r&tflYq}~qI7+)Wk9SsZ7)Q@gr&gnkz*!td%eTXCSm&1rxdT67 z|8|)#aQxm&VsUIAz^8slt#ZbGv)z^P(eRg4tDLd?K$AE@KqL>t%N%n;Wd_GVgi+|k z`nw2VY|Ej&vqCL$D`9^??nTC2XnTuuUg7OH>Q@+S*c|sMy$y(K(ryal`05q;+TF2B z2s_N&s}y>@O7$^9U!^q;8VCP==PCUp6fLGEeIF{ybu=J6&nE7Nk3xr)ivOB(4dsYP zCMgr?g_Hj*yl+bXx>#070n$hU2U%|S*-k1a6MN5AtEHbOoRk=6!wSAadF{a%19LCRYd!cl;Msel5zy$K z5C9(+U`YDikI9(8zpqV31Ys`_a)1FjleI&GjAZRi6lAP8h!j8(?FCpg1&TI6ZgdL#S(U{$w0$QQRUU#@V9}58El0E1 z7PecnQ9lHVtbI9iI&Lm_DEpA=J!bNe$=WkNdVPdpfTrn=(>(5?aq6b zP(RT;5;7`&5m?d%+7i zyxV}oL$7xJH&PBS_GQlD-AFmSb6;Uv`TjSeL%a0Pgf&U`&po;zAJevRufpPl+X9Dw ze|e`#4l*g|Rsap{FHB5#Ix%B=Ltc8o2>C^#gUs%9=*IRQK~;i6l627YI|QSFzSzHA z0gmXG<-F8O+Xkdx`jVWPo2K^;(;%M-`3zvv%MQzcIS=^ZOYb}^;2F#h%Q-^GUdT6sll4WY0V9pO7(mi|@?~s>dR-2Cth{EDE>e2*Q!*eo{fGXBqBY@$)ill<;QA@S z@Yiv4ge;s%{6>j4g8v3E{S=>(FkQDAz&+b~b~A!M129uo9u^>DVqu7KU~^}E*)gU7 z#=aJwbM6VUy$^$N7NnzRZ6IVTWTsxw)@}=VjYW#LAA+2)QIJ{(shH6yHW+}D1)o0v z{dq#|B1(|XLxS{dpe1KPer6A#Ixk16^Hu=Z_MLdFz>j?+z)ZXtTK$+(nRnwpvG0M* zAeQkEB|Bd-V#=qS1OPuV0YDb4!^$soj_CUaNX(Iae;OXXf`|B5Z-=YvT-a%=;_X}Ef5hlF3HcQ=!>@xs z$8wnsi#;a~ik^U?M64oFAb0uR&SA%5LcfN=Aexk}f!3Aq>2 z5f{M2WAHHb*Jt2h8%P(KeHQ$WEB}~~51zt+ESS0tQs1Cu%Ax%r3LD5QQ&K*G4n7B& z6AwY31~SW(<&e36S*E<<+A_s%AB19jfc+Jv6&Tv90CED(>}2!%l#t6%S}_$Kv=Cpb z2C)!d+ac2_#24P*N+G^5!z{KJ=1cMk4(Jrrivj}e=H$43=OE_vJ>ttxPnQg$#}{tP zAU^-R2^j>kKmljM&EprU3}VJ9lR*&s(LtIJ;sxASF+ad|kIjb#|3-#=7W}s*dShO69?uFd=I#{{K^4XH!3z<7{Ne97KK8#B`^=Vk2gV~av3Yn#l zj@S+lHCRvpC2_rv0gs5ORhX)Q)FqIL&xK{Xb1+-Rze46pT*jBcvOPMOE#sVTum^M* z`#kG%8Ec~tS6*b|TB!3o{o*$$Cg~*{4UO>Y|B-$eV%qi~R2Xp>sl-Dvq-3B*L4N_z zPXH=C@)a2rM#h%*E$nf~??>jmg1Gu+86M#4Vc+3pY%Kcg49eT4grvt03-kq z&D8#Ios~0$t13s92(LzgNb0qI9V5DZ2fH5%`qaNHudnR>UHZhmBFn=4-|yc4a)U;V z?`khA>9fILiRb^mUBc!O#qgdR8Bm|w4(PyH^i?q+sQVU&XRFW))Td6H-d$pWG0*>l z5IFj+ln1`@J9l|tsNp6P43KVe!2sC;HW;9t_+a$p9p>@9yL|AW?^Hf`oNGQf`FoWQ z9%tl(5k~^e?ZgLTzQhN&=N+buaK-lqMi@)O9{AqC2=m6bI6;06knXa=GfY@v>WEt; z^BI#lfw97cZnMJhJ&YHgA@jnd&#D*nG@eOm(>ub7eDnpXm%9&l=i!&-1wLR*2dU?S zl)^tKNS}9~m5+}B1<}w}r~R}o2mFhC?vM;IaIMk{K)yIcL4G=9AgBy6Fi0i73s-fJiYb9t77U|Dsm=F2Le7Ttw1Llo40#xRa|%hTc}{N= zHy%4d?K`oZm!L|=Y>e0uCoeunoF!VKZeUE?BIP$bPDb<+qU5&7%K*mlQmhOp;Ykko zr3T{|Rb@Z|i590}KZC+JcOk_Rn`-tt;wXDmZxscpj=`3Ww)P(pvgT3Bo?0(>RG5n1 z@Ef)QO0UA9y$goYIvmF9&yLY!;nQ=5)A|Ya+Tjdq%!W+cT>xGkZ!xMU&RFW4S9Gp1 zFN}Ol$Q3xO^GC}Zo`eJ0nx46KG?iamJX(?uDvwX%<7bm;sKIcxRYhm5td&w`S; ztzW3@6sA7ygWfGtJwc94~0be)4 zeFYH4eKmZoa$n<5Hut3&i|FeC9bJXJ0k7=I-P7s9LruKr)c6JBR=9sGYnXFLFl~Dh;MY+J%_T-f4lLKN4%h!=qR4?D z`W52WKd~!ByM2^FfujI2vL^hjDsT|yMzjtjFdL!7Ur~D7_l!bkyU@bqPmX(Tpg^pfKVMTI?83l+POT&$vNb{i{xt?=_Hz@L@*k@N){1F0KH2gZ5{T z?TcUe#R@ML#qHI-U1g?)GQHl z(L|7%CBicgGxU893|!TDAP2n1pLGA6nikSvdfh*-Y-1sT6#8@YC1(x72qa4PFR0OC zP;t*dNPLOS1fc~Yf5v(6x*VihhdfC4KWH~tbAQn0(8YH5KhVRr+T5RFbAJiV{l%N> zeE(g*ci#y0e3|7V`x;*b8>Eq;;2FJJakI+qeu@y#se2n`i5}1iQWpnk@teB0l}s)n zd9F6vKHmY;)$XSA3H2J@y$c&qRlAdYQkR3;Cw0M3BJF-JQb^e>MT1wv!*KXtQe}Af zxW_gV@-6)O{>A4EEjOuI=g9Z0n5&tR!ZV!)9zWTGhOL6+ThLL(*W0q0c< zZ=ez0I^KoIrOHLPR!_#JuLL2Z;8Uz13cVAwUT`s4pX0t z=tM3i65p2lPNPCPEr7?_UTxpXQ)5Hru3n-L%T=DlH{Gl4{()*X@p*Z(2brm^10+F} z$@c=G_YwRK8h!JR7E-tY@R9%T9U+OKp$cDtWc7Jgo|Ld*5#0#Npz+wYp~U-RjAA?i zOZxozoy-Rhn&uUyjJ1D{H1CAy?`fg7n&<=F|FhIOPr%oDZw}h}*h)vx8wwc;zk^07 z*x7;}zw^$HRIqymbAIQ&9YxdjV}Pr&cK*(2Rb|i^C9Mt8jRla~<_|TuKpFW0hKI%6 zfqxQ$6Q~Rtr*wcp3Gey?+%-YTpovOg_#@ESJ&+ij=n)*ge7A-2SA&1G_(h|;qZ~-& zzvJo0LV=8>E`-J*KeA`62_J&IsS_W9^qHHtKx;e|cW;3TJQax#0V1+P60nretwGZj zYfS%p;q%845?_>UFM$8H*I*RJqw-h$UxXCGL(ITCKz=h072o`9_dw=MNZS%&$yVIK zPpRK2eMDPDA&)~wcmw>g0>3eMkcVHybjZC3 zbFYB`&B5IEkb5iS?u3kJR86jh-29I{{cOKMF6t)JtGBJ=nfmWZyyF6?b`lAIOiq z_h&|vPOwnjNxcawwIlS5yo1Dc>h;$wls!>0}W z>D&SSl)$g=F<*9q;h{>yN+W3jxw@|e-!FWruY}GOaCARVB-FW}sXACld>3H^MajQ{ z@3U`dSr`ir*%IB^0*I^OFnJDY{f;%4bElm!hQi639O0!9e!6bKxR+~_WaJ0uti!;q zj=un490Lu2=?A@ojes*bjC~_4v8-p|RpQz0NZF~iz=C?ORsx~cSjY}L6M$!8x&6=t z7A0If=%W*n{hmmTtwL?9d=yd%8PPx94J-=ehTPT$Sd@wA-^v@N?jAsm&j3s~Y7Bec z1;U4k3~~DVDx?RbZBGGMA5;ZS5wwPJIHlE(8Ma_(Xxv?>qFh*rHTvIfs3C3wT4Na0 z7>>H@>)~~iL@jkJ4jTu#rKqRAez>6}aRV@xv+yoiZP@WtlDuimjL)oF{)ZE`*#K&0 zd}iIUi$hKO0v`5EWJYH$EXkC~r^1eGJQ{q#r(VxNqp|g46IrX#*s6UJYb_dEE11Mu zv9FqhzCK_uvA)gM4~`AqLIAF8q$!C{4th7441aEeU*9hn&6)i);8)GN3FPALE2e=} zecw^Au)_wLcvnGkCr`dDVD?+euB%sE1REwZCY zeJqpf`?fg)(5mmK6_EMBFEn!MT6i3|-GVf(?WQT<_&JpZS8H`|ajHv__T+id zF?*LF_P7U%K6q2d9;5wa?D43dhCOb%7qLgOg}lI9pwo-kL(D+z0WgjN10cm72EcjA z9DD49na$eO#(+IOy@!x@cnu_+Iri{?euOyyI1nG^!9(|Zv5{kwn8O$+G-993(Z~yJ z1vFAHnWK?alTj0$4U_^W^xU`f4b-=tyn!~i(>BmPx`9#* z_)$E5)eV$_8^{1C9lz=Z;xP6@(DAI#+Zi@cpL_K+fr>7C0}Z0v#X8l+cFCE_w~J?> zuw81W^6jz}9&B?1_;wi{C~TKQQ`vUe7|6HFt^jvWUAGTgeY-g29{(Ae()<|<+XZK3 zb4v4PENqt)b-UohGbXuC|NR)=58*W2Xt*W!5xdyKJ1sx62-Q zu)P|{w@Y`cuwC}4+okglAQQ7ACH%CHP6^YakRE?e`_LfAB@6F(>~nO83+;; z-)DT75bnhnaj`z@b2$}VQ9XL!7krqc1=3%E+|73%O}GEx+l~aDF;KTAx_aJc3xi}r zul=+gt@Jq`LFo0I&v}gR(DwT_58UrTup#o^*7y5ttGwTDwrczRZc1*a>cfu#*rolB z8B_rw6*s&AQrhq;C29173OO4|?Qft@7wtq}Ee{j2 z3X6~V#@J>+#y6mkw^ zL~n+kh#1lSzhb7en#+kYT$PiqRD|l@(#QUR72^3Qc51=(oyAsKKwN-4SYZ?&7vk zPl(0Yc5dibN&Wxg^d9fG+`|4Gmq!+e-i39hFyDZIqV&&H&<60I5y zY7z^>4!g`|VC5IIh?QR;vhq@>5&SAC)Cgv%Aw?ue#DP+<6HlUtHF2zKC*SU4=oQK5 z35~1raC>eY?XU zjZIz+62_g7<9o;_$$k`@91N9qLvGm1Q0Z9|K>FZC$1Em6%7Op3%K^jznPE!-q#ry) zAAAV9k0A3cezvvH_$QEIOA1xU_weB8kR~5J9(k4kX_Ujx2GH&lih5z#I*S7N+4ev_ z^}-O ziq0g}A!*WY5A&}+2E8BPanVs{nV7wVQ|H_5A~Rc}GPCet z`_j&-^QnI)5?DZJAh@gUiG`F4{-jl!{GtaH-hy4l}9PMGm*6V)#-c z&3;i@^EA7C%dG(As7Py`X18xy!=X|iOp`aVvwRG%-YG%ui8EwEkp~bHiX1bYC~^uZ zQsndmg&jvpa{Tb?&73ZsD9NwBK$)RY?04@pGPv&&BzPZ$HTIc6@cQ(W3El-gHG=me zWN^o)H_zZs2N*|adh-l!3Wu>Dg~gjy6K-H|=iMt0FK2MiLc!3R(65d7&=YEHrYx_$ z)CJ31P|7#ex(H!Ytt#c4Y9~C{z6j@=>R^Phsg9PiP1PZiZ>sc&e+A2XQMx-U@2xmb z73uD6qYxqOkjCy%LJBpYZ+&G55a?NS|n$Aw?+yq z??)=j>vO|gg>-yqE-Dyw?lceNL-6anRbfWqzYJuO;E|A1wI5d4IRn~ZDP?fmqb3O? z&fcOclJGJhJyEg?O+Ho4h0AJ_s&E;b+|#lqQIrf#K2Xc$-D;Dnyc?Tr|6GfjMA9BVpcPivM8usfe6ifQ7@d~l^>J2116gWN*>@s{<^N!TbhRm1) zij6p8p4W4`Gf=zjC1@z?dDPd=8TPy)8wA8E1(Tjfl3l2XTu97KzJ{<0p&|%!dhI}XHPJrCc0z4r1IySgZWyrLr z?+zh^BD;w%{2vZtg#pmSj-+r6hjD~w8n*uq#cJ68h1nD)`eOKZ6uRbnlhVa@1iE)C zWH??iXw-%L;M>!nXgJ|_3X}T2;awp=`gR4`>Ks&ei3W~}j=@b-2}UCJI!x*53ne$R z6>cxU3R|E8)$j4Wo$1GH#N5|nfW6s(2iCm`s(FR4eGgb5DDk~d35>|;tB~!G5&blF zWG*2i?gVknM#wz^88nu2EaVPL_Ol)Bt2oC3LpDK-1;!)pG!qNVRiK_`Vu2ar^_XZ) zNWu4Loaw9DpL+A|l74OrYhwGk6xQHQbrG)EG$wJXS>R!oa?*M5z28aa;fxjuO3sjU z9-`Z10s9NZ5NI%CQMGSaCy0I5}1sdygM--6aM!t?BIzxO;4MiQ-gusb0-_KfJ2+Of_5fG8u_W z%lCDq9WZM9IHP8-h1tuBiU+w9y#qMRELKMD1L+f#_`akh*$=^ktr|dTAvf$j7>s4` z5FHIWfy^Uh_zW~!g$LUM05ckL!!`rVRNN>JJ*bdb^O(?VBZ62H6!Hps{hI_J@2c)b z_srw&M&~AQLD!)KNzf%5-SRt$BMQB~a6aH(RAP*)bsB@wvRU}8v8La;Rj5pJ<9>NslARVCxhC1FS(`E-kr&=sJ&Vo#-S+&YHus%UY=s0_7bz3 zr}jnzjN|pJ=Bd5!IE>@c?B=PxJF+!u@6dcs?R7~#S=1f|e9an}>OQrXgB9LQHBfu2 zFt=;Ef!f1MvOSfY+FPA2T#g;9Xu%mq?Bj|SB)lp&a*TyFocRHDp3LK9YT!C`VQPsZ)*p@w(J03dPBo&=Y;r@M zOf~+PD^ra*FwR-C1{$cwRhSzx&_Feg5YSKzF;I<|VS69mRy{zV3c?A-h=+#Gfm{a$ z01!(k)%X>ZWyOxYP6rhsmAsBCyQzw4h=5g8@ug-bH+MMA(6W{0Z8f@0a!SU6M(l3J01csZnzl%`0Frt3BXr!nkN9i zW-t;WaYX=jH6jvM1mJECV~?$OA^@ZBgw0l4&j>%;T=>NOxciV^+X}gzf`e^)hBGpa zDI?ZX+UBG#;t?apr{(xek9Og#~K)wW^aTN`$&c4s>E4ABPY%ljpW4HQzK>K%=zFk zp}>|vB#Lai-oRlcb&8Mq>me&Sn5%woxa}3a%QZiS^LrDf#_T zGJ)28luV$lg0aqeVYGoj+k?61j5ZKxez_L%B!9a`potl_aZn`&pn5&Wb18w=d5l8x zA=gm_beLE|3AC9|dLa^M^A0LnsYakV44FEC_A<}a2sFO}nLzu10~iUkj|b{jKa@Zd zGibJrIb2(+CrK%s+#uSWt+%s`$32XUeS zkm6MXU`;M3(5!hN%NitD`5=KNW&m)XJdHq`wSW_7?ZyfOS}cdx2sAN6CeW@Bnq~yr zM*P~Gu?7Myfy0>)Xos-ED`O1=nsp)M28=flXtx7HP_U2_XbYfpKV(qZ-KvFLcK6J9 zuGsEBK@j5YT*!rZw@u)R?K38DN-i)+Ap?ca@ZQ|1*Fb5+W`qHV<9~?;IGe?41Vo`a z{!sF82rpB~Low}|JQSfQd1$ESf;^O}HBTN+=HMcEI9d1>jXa#mGo_PN&6G~o5}v7@ ztYSt)#6;m_l|b=il|a9p;6xtYAS`#4JQVX(@=(mv$U`YpzAUa47B;01#SEvjRV<`u ztC-Jdu#J;s`tYDI-!gr833Od7rS#!J8H?PW$LK@EV~0gpqz@0v zu&=3jOw6Zv%mBEI<1zczMNagg;|T2apE&#=!s*06;iJBX0xIg)IVC~MFvjkxNgxs(~fbqK@HscJSO^+^S1gmuk#=iuRg(y}G0gyE+ z<(jjEQ?7lcamw}LX$G<4#rzvg#EN)WKP1dQC2GYC*b#%-HtW@puM;;;lq)v0Rcr_; z*R66xsd*yhx?WhO=9H@lK`B=;qY27YQ&=QET>z&HQ}aRKf0v z4GJReg@^n{&~D^c9V`V`=^K825g$Wo85Bgs%}~f0zX}p11c|GK+!c@;KJjPZ`C-mS z?y_{U?}UfAr=VylSZ z8H=ZV(5*`Hi;xz~O_RHB<%|Y1Iko3p4EwPdGDXwV=qK|CslAvRK@I~FttI4nIA#g_W2G$o@c$3$@9ivFPJwLT&kNlZoJe) zMuv{;ox}^s6Syf}Xus2K@xswNk4Hw{^)Pjp z;?Vj(x4BLKIP^AVa0SdPA;*UzvHnVlY%bz#MLFJ5>SRSZKCo1)WsP9%v{Xa>G7=%K3QAWIYTt-{tI>*@_?@P%;IL1Sp?emz$@Yo-r>HLUy=J( zelwYs-*|52Cs`jNVIf%``tcq!>qBkXZ^C5{SjCmOfAnX7nscrq%u3L5Q7m4M!+!FI zf6*y}VA`+ZMuJt*ipJ914$8?`n!-_I=|b69+I}@*#?pg#a${+OD0IB!>49htP)X-t zsDZV(z)=af_X9<6L~(_(eUa)Lm5Cff1aYIagD7USb`Zsj)()bS%-TVej#)d1(j#jJ zQ8Z-jAc};n66Z>+?FEj}Dv7Q&hZUUsR+FzPg8zzF73RM}Eqp+Ry`Ltv#0n;!w@MN% z_-6FW>3fUd$QI7iPu9U;J_TPj8VA$ELmy1^Z^!+=dU)ug>EVH+36(5Q1JZvADwTQY z4sB_r5wsFy|DskZ^LU&)?7bao9K~9yPh0i6e+2hwt5-T z;w1F?LEXQuCg?Dh_>P)v%<|dZlaSKe;Lq-LR??}D?)JD-AD`D1=JvQ#AL?wR)bl5( za4&%M6TtdWF!Vm$sUOBBBt6vOo{q1WT!_*5HY8g}H9jaQ7P1(_@}Z~BLkFQ!bg*qK zWTK-^$txzMutcwzj7l2Uj8{xbGu`JzT#akSD<-W*MRwy{i0r5rQSt)wA{wy`y6j#E z2`h2;I;;)L^y@#!m4?aW2*ow1W;L$yPPyPF+ z=3^Y4^GXa;)82V%9w>31ny2-8K7sMD??U4F_8ctiyTQBPRk!D0wmrRxODBwx?9B`R%z!-JX-vg*D(k%1pdB%FB5TsF|{OZA!}%K7&Ne$k*q(!g@1)yP z%rM!WVlka41H5s2O7Kl=Px~RhJ@3vCrl!+lojkhQ_7wB! z_FN}V4c(rG%EI>aeJsS&c%a^!09$eB*({DgryyY~2BG#I+p$5ELMZ)g1B(yPsiPhr zpi@U3tRr=fU;5=v=J&r-7ooK-6pU`{F6i`M$KzAzLP1Rq+p$;+c?=)Q;w-u<$I<7R zD#v}0Nu}*~7|-1zr(^e7X zf-*0UUlloy2(UOC5b(TP4S=5r${!REojTlotMJiU?jFc>^c`hr;6f!^0tJR?!YJ`7 zUsmv=>+)K8T{fZFXSyJpQ0Y@wqN^pCbCAj0z~ha6YOniR#6+ESiGC_#ZMI4%hY3SYcgg@+J$h{*&LRg3g~*I?U^kU1LC z>056!(2w(-$j66or030E_~$5cgM3`Fox-o(?mqcQ=XWd4@0|7#gOmS$6f+mcW?8ub z#msR+F*lbxqnKTKwRR2X5ONdzcAAc|B_+^5q%%BIhFP1ma5`xyJce7GeE65XE>IS> zcbcI~&^yu>PuvI~j(P)J$4e|-jDSl4Mv|hScNCDKz%^y4MfmVw+WE11kRM5O9YCB# z*OKN!cBcb2i`u z@56d-Tk5-%-9EN+z#qI%^bQ@TkuTn%2o{Lmm%KyqmQi1kz3Ga4#0uEsXP_0I$A{cZ z3prw?P14Xk=hP`=IsAI}u*`c+3*7@L+NIX=Q(NA`))-A({=-hDUgrG+6NWLMADHYC z#fk7tw^I4EyVwn;_cubED@bT^Ie4bq(I9I2G8mT11wbDCi4PwB7Sg6Y$kdVKweE&m z-@;AjcF3iwCgc4rx~hr#L%o*H>?Fy+0nuuzCK4Q~niv38Rg-@_MV+&oQPi*c|K})b zl$2h~psn}p)@f_<7^AIo9>b`a z0i3q(7%0%zs~%&t_4GhaTW<^eSJ2jh!m_8DM4LMq6ywKfDwh(Rxa>Kgq;jeL{LKXW zp2rx${&iq0!7dZ*!_)^RQF`Wmg%K{lFfWNoRtr@Jf;1xB{94;9a4wD+}#*!Q;5D8j=if;=1C1XRGM+AH*ow_b^6b zdC-4`QJ|3o=OA4<2gySwbvAGaKXe7u_9T3>cQ-(zmnAEtU=O@2#A3Ctf(M&_u!Y%`R*CVJAP7P4~>1qrqv#a6~aD}|TxZ=Y-14R>rv9e1`&gz@Bb zKxa-?(1@K{FLP-x$3y3AS3)DD*vp6EHP*+WO0*@wo&yiIccJKc*1_^K?^DQZ`1S5% z$qhs*V-8Co34_g#xx$n9^y}M+_-q1ZqhdS!xpAdJEQyMrhx*q2kl8LC?gkNL^44WQ zCM)y&x-0Pf)GHvK8-9LQc*GMa@VW*sc-;6p2K+>5W%9O5wgF)hRQ(K8ntc7%ZS1ps zx&^}9Vgvcx%7wQLMz6f>q8YibJw)CWZrs76RPu2+aF=|Q10z&4iFTa7t5LgM!V+6i@?F4JMh0u4e z#cDBa;j1_9g^~;W(`Rp!HKi^|-860p4bzTaPd zJeQr>+1c6M**4pX@vazASu4fjodKRn)5|6-&iCe&tq7qcB@RP!FKpJIs zT*@xcp4tGHEA^9k<5`1&JUI0U12Rk?iX%7yTo+R-<_3X8`-Ko1Hq zP|_Cv6dZZ`M3gC=QxtX?5Gf(xxB-shJK$#ndiS&jrz{8T>*#$Q9PeV3Wq0dQHpD3V z0$J@;g;fC$imo;|QeWFya5>_gTz#+LFDP>oforff58Rz-?> zc*XKFepuR`y%<^Ad^R|?O*L@;U%+Y-s9T&&B!#{Iib`jExH zYm4xq+bBs)L&XZ0AVup@w&0g_4(QW1JtC!O30Q#xd_84mT&nJ0-1;*N-uHPanY7V8IJ-X(^89H9QC9?JOSv77u99d^zi&yp^R`=>Tg) zbegKG?_vAax0%uAbJ)K1ZDzFkX{y!*&1eT5^goJ>V$zI`QkoY^?D?AiP z^F4~3bB9Nfa{?Si&biH{FhNS;z?Z^6msJlM@kIx*G6W}n3<7orIMEGV>V1n1%|S$%h9e$8ynh%uG@OPC@#W_07Kl^MsB zU}b)%wXk~CKV>EBs2$cmgvHo7uPrA7bp4A~GPjZ!8K8T`3=|fy`iBf&Wb%5T+3UdY zR1B-%&02d0RMa%+WL%GmfrWj*M^5$K@8;enV0Jx5uPA0*w6pPObMv@+SLbXYeASAR z;kPub7qW&W2D%UBkGsZpvDKw<6Wxa_>a4X| zdS@AqS1SN{FZddVP8`XZchDZj1}HNGnDXX_%N4We74u4YC`9^oi1fnA+TMys?}&PPBL7tVV}E=B5_%fo0sdM@Qn?Ok-~^ zQzeQBREZ)2RU#EB6bcQ&A)}!1qF#YAX+!fa4=o5ZZZk3!P0L0A0vy}HVY0GIYSkmt zAHm5AF6cCVgccCuV}SY*dT%Y9_Cq!vEw@8zim*ySMHmRw$gFV()Y;qvMHTk_^hf|P zrreA~h3z~98r=a|I7qu|~1RO`aoo%Zl97NCbGr0C%x z3+ns4u+(@Grws21cvBy$zO-cOLsjHo$jHperg4h%=VS}S$rf0ou!0zc1!5GYi$rG; z2C5#y?7Z;2FabAy3N667?qsnx(fBDG@|8xTv}Z4Xvw{=bBpYngS$m~zdJs4g=O+I# z+w`Kn(l&h%vt|Qv8N=* z#>uN}6WnRi@EI|N%83(uI}j^|=FU;zwF|zSV6lONyl^}(8CILa*&z6Gni_&WnTuSH zEf6F0oLqw!4bh$NE(CZHgz979`r$&2>wcKMcY!ZwA`gE=^%q|CmWdrDIj0OkX-A2( z6)f+}fG=m4pBHXnej2@A=hGk2(wzY7qix~Kxo!x6R(R%I4(M~}^%D;ssRdXJ=9f?5 z%X!iepj90VP<|~;Ch)GTqP}?u<+Rl4U=A;s)g6vdwB_S_O4hBgG%yP?!6C}B)iZ8p zci={)ANJy#_Mv4)gLZr!!mL-Gva$&u6QN@&5X2e$S_51HOWkAb4bGskNM`L1&MQD- zjk3mk-FeGBHMK2g+~X^-Gx8Ol7}& z2H@t`ryW&@z+wZPtPff@b~-*7@XQFvp8LfzO)SvGc;P3ZwSy(C6Z?OX*46u*e6yj! z5AnziBuP`m{t-bkMKJi+_b>AO>!M-yIny{BykweaoRh*it^$ZyR9z1F3lVCX;@{sQKM6{S{gVmqOE42n&oNU9^&|dXYJagQ4 zk+We|E4p8R6>P<7#Up=Mv%x~q4^$bK&suc3_8@1Wo2zlEk1ljDci(ZGt%a{eKlF8B zaM2{VT@yHKG(iiuTMf6H!YQ-BhA~U?J*fJk10`%bmWwH_y(_qeb~#%J>XV&M(B0oW zrMa2o@fn(7<+loCEV>54FlcrWPLj2&hx-R-00U%_UD<#g_8K()L5~9VnUse>=&v6K zo6aNvA3@M{j%f0x!ld_O8_Ql>7%F6=EGVyO@MV8REgSL?guN!t6g4;7$tgHR;hY9( zMTxVk^Ti|70JPnZ+UZ{3&E~8obR5~eef(LkLx2u{7Q9A^rqbZma~@~+qt`N?@UZHI zrl721mr)iDeM%SjvOnU_2J#;Xe(#`voT9TPW0pvZ3;LKA@MUNC__JQQfPM+RCL6ra zZX{V-Ul0eGv$rdH4q>0gdi4hMHuSpS=d}_H-S?o^ErohAQEEQ`b|+%PEC#HyTy$;O zNfwyb!{TR7qV;1 zUTg?JU0bhyvTMuUY4I(ub%4HsUMDO*r7SiMXk#F;Lfq)AxIHHOF5K;zJ7a^mTqgT2 z43~RlgX)W$KDDveUIY6D^&=Xg_w-y^uFK;&U*Od$^I#=xE{NF~#r*B8 z&JVlU7QMn@VJ?p^^qixWKkLFG;1G7ota<1klJX-2{=4mz6<-8t2cZDHLsBv~a<=LV zyz&7YTeM8gm~)SLWS^ZCOz&WB5O0IeGZtuVD$qxv01pE`yLRE?r;*Woa982MrDg{x zzCD48@96D|?*B9(b7L6q$r~`vs-FaTCN1cYg}yMcm^D_g(LlR6~=aNmj3Sp`c@UXgCs4eD&B3fnG83MNMunx zwi##f^6)Meq2sF{TXH8*qpi*K!<~pE{Tc!u$r!}wi&g?X;SdLjCeNew@9)l=E89zW} zTw<%?2y0D8P1Sb*X&>@i4z0zA-I6MTWd2IZdl!(?RT%y0?u)9=0{r|JaVpH@Ai4-% zAodQfnD7L=7K0`99s_YCyb(#35Yuwz#y%dlJOxLn&UvqK_7;2%2JqitU=cb7xOfu_ zGuIfg3W`RN*tlG=KG@(Ujg>fEkpTc+j!ZlK!ANhi4&e&M=0Y?oKc=NEo3J zCP>0Nj41#|osDGv%=zC%2x+}{pN%>C_1B63ZA#)q6WEiPJ?=0}$IF7tfzuC|^N$BF zn%D2Y5zQVH70>a(gJh9F{+i#O(>T$0CW2T0fi_n81g}vK%2K6qAtcv;9hK|gVsdCL zWB6At3VXuldKB+YyCL3cp9{ZB+wABU_K6|f{ld>~TMR{C4Sp8GS2@B$%juaBM-?I! zH>v>o2rOPVojpKvL!d4nFt+alJy2-nRU&TD#{hayInW##2;F~YAm;exH06j&OR3&p z7T4gNwNGOc3e=bQ^7@e5Dvb*vZN>d9$VLNHvC!>UVvXm!dm$CBy5LY zZ^B#fo0afB{O0k5llVtTxP*VK3E$%%M}h)&^gK^O82<4l6v01P2_^9lgs4h?m4v$V z*P4(+e;o;(>8~fDAN}4L2sl$Xl!OJsVNF;q9FBx-!r@7HOE|mZuNw_Ip)`Xx4;c_HIN|z_WD_!1%GSZcmkRe^brlIOo5^`0iHKDuebR-N= zot}h|s?(b=Np)r=%vPPiZL#K764q;OYr;;=?MT?CxjhLVYHn}BInAAwa7}Xq(_eHz zNpMDLfHfgj2OJ5-b-kw%jX_-TN?~I6}VIy81TG5*?V` zf7pk`-v1d4li{u){*fwB;#JUfdA$9$0ibR_OWiNaMtZnecpRn;z+`MB5aKe@Yh{&kxPIRLPQlC!P zw0c$#ba3@uvT`^-((BnQtQ^_3?q=+ryQTMUL3-U;MBY!;WUO?i^o})zUQ6C_wHWJN zOM0urH1zI|-YxQKiD}*%s>J*dB>xaq;)e$or$A$&BB$RAv*7Y>!6Y5e(|40V>6QS@ z03iHIbmBG$F%(U4y8)5(D?n2KO1=SsSJ%?7VhWGsB}y0(#duCcbKDtK6n>NU_>jk^ z*b4iSpJ;~UUo^wxt-jrX)cX(1<9{Ta$Q3T+&k| z4dNMnMDDdF;SL&e&q##A8DR)Oq6L*Q=N=draigs0`d?8o}D1;SNYwFPR4i}czV zOJR$}{XU6Vz|L=jPY?^R!AC{<4M&DTEB4+YZ8$O&haLRoo zq1L4tYl+Y`gcbtS6(KL!*eiSv&;tnNAXKRgV>{KgvLOV~@&nD7;*g3udL zxE_0bSU7!N7ESpPNXGzG>KvcgivM5hA>o&s>M6+0VN3&8sqhV(W1g(i1=~9R(t~@$pTEV ztG417@XmFQtivj!V3MeH*dE1vyt*zc0;mQf_L;XL7JC(IBrEmC+h)xJ{;3ysn{gOV zgQFk#5biE6p`ztw9mj2oyd7HB6BEk8+6h(yG?g!svL-$ZSYaa1?w!ZjD|xa`;XX38 zPF1l%JlT$MjI|#pz0uyQdeki~^~SSys&@$1s?&(ifPQAup7*6yQTNumHHTHcQ|_g_&8(tO_JVdDON+@*n-|2-eTH09|ir>Xz4w|se6|q z?`=4P8ZW(Ze}>jjk@tkhp!0Z4dgC?^)q5X#CqK^F#K)!g(Q3N)hvfYsK2WetdZYbU z^`1-{5$%W2Qg{UwULSWd$5C3B&_>hDkynQhwKT-hdW291o6J$HJ0T`0ibQnZNQkFG zRm7$D34zvWff#j!5cp&aA($NxoI5Tiq4luPR+x;&N70V9!pwRXDC@@^$b2)>nhC(K z0$>jGG1#uDQ_6iVnwjpc&Mb%s0bo_T60FV)g)hQt^`~^vh6h}vaK+LII>*f;uq?(4 zbpd6H$DHD-oa1pJg0aG!1YIs5At=`;prK2l%*}#wA!xot2w*=r^i(`1=haDQzAf}w zN8gOHbfUbG0;F{^p<9Dy%lrCnT??=Let zP*hJG9xMYwJXj|0r;k`IpEF>CpJ~U~J?)9pj+JPZS+GSk9hsvyDa45!CQeHszdhYm zPUsE)Vz>5V?BV-~Q{h1yRkng>R}5dC3_=9eKD4V(9$h-TpEs-k zHq9kYxG|ZB&d*i;1DUuNTKCEGDH`10%rjrxqWqs|jQ%@0RoTkfk6WoY@QMH)djHdZ zOn;c;Kzkf~%hB08eGH?sulkq=@#?@!>*4)IXMu>CBM}0`s#FJ>KP2|`oj=s+Ylyi| zUsKGP?`~ECFh#5$b3Q~`%;h`b0i{CE`^CJguW{yb));l1BQ#r40wfx->dYk&ksdW} zEAn)vL`U7{8+En&42kY^U*I{DIp%!kO!*|bM>mRjx?jvM8Dsv?CuZD^?;kUrQqg1f zBQnQa8Rq6`jzW%pzA=~XXUy)F{R~m3IYRS(3lueC)kFs(GG({DGuT&SH$(iz?}fTH z-#%&&)(}5=#Y!6ZkB8)YBJozZh=q1Kil7cs7iojk(Nmy4Od;|g_5|$pGEKX^re%1I>->lsSP~I>Z{9 zcRwO?Bl|%giur+ozA?`nXl!J+<`Xp)IDe+U!5{ z7OZ`Fo`__w?jVNi7M-AV6z&gJ3P+(5gEYy-0HnzvAvhz!2M#g_Uf$tvF(H`{>yYDs zKt$%wcxM+kjssp8Wm^}~{*Bpg94))2jF@ueH_TpfJ;9f`Qbc+(891*MLS-wQllFb}5 z29cf}^NsmOQ_KlN%xbnKAk#I5nDZr)F+1NJ0_*idDa*zKcYkU<%R;`8YPJuAav_9I zj1Q$j-}E8Ag}rfzv9OO1F&DNPjk&N%a=ozqh|GF+>R~Fa;Gw=zmlQh|HWy}i2d~m3F=+!x3%!pNsD-e-6=Kio?1&Z>kZ_G)< zjEd4=m|0Q$#wvQ<(iJ5zkz5^M4*n{Y^oU`;**$NVF}wE+Gne!jxw;g(@0elH1F?pZ z4orjqR%`YOtmC{wIy(G8dAh_ztxd&3TR{yb9qkWdxDaB_DZ79bd=c>q?%DSb?wW*a zkw?o6K1Z6wOU2g`4VYS=S?KVduX_C)N@Ty?;dVWwYs)x z=1K?Kty-!B6UnHZPtV}&{TZ}6g61WEYO*)c>d0M9hFD`_8Tq{SHv2k4osv)?U+hYml)w2 zb<+{Xs0WQON8LUk*Y@V9+ZP!1(8<$*=g{CMvG%&a4mZhBXx#|kR^y0Cj2lKVCOQ1A zbrb_))m9^4A}t5Pp(V|86e{_!x|Hh>)wJ2e#zuPZ!-kmi9RAilVv1O`n&wMHG2?f1 zKIQ$3zA^7L#eDf;vkk`2;72V#V)X{XpU51uvY28{ctkCA8FSr7D6Y|b|D3xh^1hFl z%N_45@aKzIL+ccnNQ->oF$+dM=Mmqv^H(1+mi0NGsIjs2=Ss(`xE6I_BCV|5Ybf2( zBYoAZ#z4Ax~sE5ByQO_9ZThTU~qW;(?YCn4-aYd}5q6H?> zqW*C;Ww>jUZ`9>R8Kce}WsX|irDNubSVPo-iPScE_S>8t6T2#q(4X3c=Ri$6D*%~5 zX1}Vu&vE>)ZIo{joiGW@N1MkFg zA4i(GJdi(gL0#hg467&soEI2zM~3DY zz}Myg9VN-1u+ux7Er74hv_OPJ!yE~(VOvH5?j3{aa=!a2XAQS{Sete<)^xRbL8Y$! z4cPa~K-Fq9R1s(*5S-|E_G3yA9?x!$r{NRY&~ePpbR4sn2k)rwkB2f@Hislu$7H_c z=32JL;l;RssSm=%;n4 z7CQ-&_bPmCj=HHJwXziqj=Jge7KJ$~!ep<4WS`k9N_pwPhm;rn%9i%&|d}fY;49QZ8~ZXjmt>z?5{Bssy6@KL<{)HLsq9J%Ct`^U!`6v%+U< z%JFEF3yEFm$DD6NZ}u~Mw%WQEux}Fq?EBA+W7Qqj<(pzeZS-1ad=bZb1BErsil^@{ zK?q*nijTlhRW5D4`BWSW8Bd}lpOsFJD0e*b2<5&2ufs@q(S_x{(uL)|!G*h99ltDy z!``6Kcw+;*4g8vpR~uMmMkMPpULAz&0KdWGWpj&!9*1cK1gXua=p97G9BU~qs;RR@ z#$~t}TYQ!}PP-f2(Usi7#1Q>pUObw#zU>;rvK)F^E9;q2UeAo`lx#c%4?Hn5$my}- zssBUB-plOcq8Y2gFc<4toA`)Z|B;s@Y+ z5Ihn~L*MriIMU}zGW+GAFmD#J>H}VD3G2;+pQPOYUwG4Svl3q8QXa3N`4*}0@hSl- z5N&zeOlvW|Fie%VbQTo)HIg_u5w9ui0B~Y9IC_Jlc=8g3d9i~!9u%8$7_gN9krHEP ztQI&@FTH5qk{xa9IM_)b{IiE?^yI&UkBB znq{nGVPEvEWAMe4IWw$bKF_=WX%i$3UT@wg@BA((&b(0`N#lX4g!sb|f=^j{Z+Mv!@YN2I1CQ9UHlIfCM z$j!N39~`AxtvBaQ$l+jf*6^Gjk|g!uYV*eO&?|~9b?s{ZE$FGOmj^(uTyI7? zKM#sFADzIgdIfWJj4!D%S2fZnk#yJ^A5vp}>ZF*ZqkKd)WvNCw%bcsGREGvib!ebe zhXzV@sBfx6^G$WAZ>mG{O?9YmszdWlb*OKuL-R>B)Oo02NtJNE?vnTDsQ*wc9G?Ug zD#p9YYj#4vax&(|QwCZKxSm?TC!zIwU2g#&cBn1jbJzmzc9>eg^@bL312eaP2q$)g z0puQR0XKu=kZ%i!B-8?44VEonBd4JSyvAhaWe{Lv(jyWd2V^~fi_=TvfDE#8^Gh{&LBHQcU-CNlJ9(+b3BPyv zQq6G?Cf}E8I<*8blOO4#7Y5={T%V_EIxX+w_f$=%%`#l_h^0CMdMwDreP0XeGRyQ@ z&_aAIXzUB-U;$nW>N3alTF|omUkmDz&uc+}9?|I%lxXUz$_I^N9&gG*ya+0JVv3m> zFT6KV7n9VpC1LuQjhr1ujp!Uy+>7l|Vok{U7XVwjI8>+dfU!h`dAp&{67Z=7$m9;| z^=NQ*Xt~byYu^!(=z==_Ad+raZB|BT%}O3l_mMF*E1vzF)!nZ(E6HJM zvyu)2_S~n#OwG!tP)%pb;OfB22q%_cm!}EJU=yCR>Te0NV%< zi3h=v3y$Ki!W8E;co%tr2dBit80R=3Qo4cT95{+kg=sHZG2*5M2d8`o*j0e=W&x%` z2K4)T0IK-w>k1nLn1pJv-bL^?WgXDPy@B^J0!eXjcyWAI;X{Bb095=S1i)L!;ttt^ zQ;NW-`T`(QJ_X11*D+4`DUaUMED_#8;7G}Z`P4F`IRuW4=$H+}uOe|X_}Kt7vBi0~ z_cRhG0ZnhDnFEd?=(rb%$AF_;Ed1Pcx5$6&mt!B|h0Be5M`3j((jt(l1eC~@SUjy< zAu<+f21uVe^=*ZzJ~&>Ad(WOz!iY%YT{qF0y41V&DXgvZ2^ORgC5(tP-nySSmY4b~ zWOttQLN$+j*B)2Gh)CmI;*JAzSw+u)SrjLm?Jv&wPCX~4!bj7YR58patO zmtmaoXr>U-G|o_wrg6qoW@K;)BO>MTM8i14M2h1K6KQUuX`Hc8`uUDCjCdMn7!m3? z!zZw5objgg)5aM_ME>IpBNdG^e1hdO&M*bLlX1q{OueC_afT7$H_kA6(m2D2@Ed2m z0wW5Xv(q?Z5OzYZK&GF>amEa&PK#V(oN*X^lDv$q#=*m0__>^^w{kSjFd`Bs0qGee zwXXId#c_s-^tc!AKhVY*>G(#ykwD^W;4Agx8vAg=afXRoY7&gNea9Ji+h@`};4@Nf zR-Cnbn-y)GfyZ~LS+Uz}>U(3m;HP3`P@W^LXsb9*ajwE5GF@qJJAx*hFf;+$j-XwS zg^UB*9}M&(%=FLs(l-JV)vhW!{a!OYj$};qg~3ujqpD7iG8^c-`qG~T+IH1+`h{lx zt$gSWQ#Wjqc)NMfoL0m1ypG|=@HQ0gbuwKognXs2uVdJZyJzc}kCoVV92C4w8^9)h z4wT){JHQlC#B&JZ`N=;Xnjn@-HpSCFU_6gvJP!fo42nk|Gv?H?8RGdB;(5J_UpzEo ze9ausJYdwimdz)gEf|j-tbw~J9=%iVW{RiWLC$7Z^^1o(q87zW@f-w3J^bRifbl#F zl-DR8O*dN)GR4yk;^|b)FCH2?d}fa4XJ9ncFP`XUAf6Jy+4~GPcCE}l5%=g+K1e29 zGwe>`!51a*<5Gg+@GQG%r67$hptSO_*l@So55;CqGZ* zp_ymZgW+e)2r?^Yo|V+Sws~m(n;-L=&#AU+4DWp2%w1jZ(zt6YUh1zWjwVOi441(erR8XkM1IADYF=wg4 zob?@CP^jLfPzXWVX5NDfXN6pIj0^6VHRa~0ht)A(vgXLc>gdI}c8){jngO97`heDS zD=@zfU#TtDNXS6{(;u$ipfs|?{(VQy&Y0JQo|)rYfZOL7v}6AqL;1n_+;GJxi2)&2 zq!qaf_vo9n&i$<)^O(5?<|XEul|#Ri;EWkz-2BEI6ME9Vww$@X%!kc2s@|hU?y%%M z!z8)^A&zn=a=+fYZ@WJZQq~GaiE(-W>S(8opA) z9O63Ne%b|)TfT`#^od|tX`J{e_({Oi9esGI;SPKern~SG0M&`PusQ*2!HM&Ydm>P@ zy7OtZSW2BMAgPH~En=yOI)bF8myFO5a4$@hV#6PoQg`!{8rx_Pmy1OyPxwF7Rzcp)d1x3k}Tsnwjf&n5emV3Yc#`sTO`&ZgTRFr znOluT$9-B26+!$FAnLDIV;wA1XOVAi^fEFZzQ~*#3r&5k0b$+*_S##-e4!un*Nx0S z@L`TmqnVhi2qF0kBCDC*>yeuv`lg5BVt8@d1c3%VwEizSYGXy*=hZC|V>19hc5E%A z8C#!dVqXOl=0*6T_R}Shh7+RfqIkC{4qyD0-f{T8uj+nceki&bU3|LkHyevhOam(( zd{NmJof(d?L_;9aq9Kp~`_G1=o5%lbRNJP*L=V2GjKHBX3{hqL4f6Q}`fn5OZ!D>Q z<@;|4#bR5l!8ZG}A|BCt2y_&-9$W(d;ZUNb`jb($gIYBfYgU-8z{XK{izua=8pkjj zHIA`Y)Eas-aO^h?BH#QQ(&-cEzfHVVTpH#_SA zXqbe;qtS1y`go6i^(k(Ql2v8+` z298rJx%r;Wq~(CUvJ#(VYV5X?Z^XeeRMhu3)UHRv8 zO#4@n4PY^xVBeM4v)EowGxiI7mPdJ*&+YO=C(u%iM@?cpW)fq%F2)znGd5}trJ-|3 z0GimFb2;nUhNEtGM~Z@qrl}MI>3&}}ZXdx}%ZEAY-&mjf`=weU z`gf_NcxX6wM4Bw1D?SAzIbShm+7@IBcc9sZ7EQZ&JXA8 zp@%r;=%qTwN)#y1k%Gledsx=Hi-GIiMPt2F^ISan5`uU2&qw*g&Ekh5RjYU7<G5cG!vqWys~-oP`UhhK<4lgI*6U;2H z>81coW$HIk&^-PmH1y84P}X*sx2M2%kG#!6XF>NB4P!w|5pxgb7Zkn!s#xU% zwR6>>{NBL*@m^!6yO;l9=#Tf(kRTr~|4@G{uK#aCG5dE}5O(IhT!hV30*&M{m54p+ z@I_ESz(O$Sk1f|j2JEKVBEQ;7Y_XuMj!k5zF+a1OSX3qm9bB{aC z*jw;bdC2_y?7QU@_4!$QC`1`s2!2+;S7j1U!(~nL*b=Z9!V@KApH7e20w{#n=45uq zi;xLHUqd?!UzMZ6&ZgCI1naD0EVNTivD-yt%TW|OZ1_z@h6uxxoK=n@ktbY4_?d_= z{I2D|u*zAa@`RTw91FlX0SHOXlOVp3;BlUK=)Ru`p<}YIGj$A@?q1a&;`tdulPNRxgVgc zqc)C;1N^ZYh{Hw>+|s}qGK8_#L&(=WW7JznH8g2HbwmJ&Msn~)nDSSf3*OHv`Spw< z__GR`W<>C3l}&#|@Yu&U;uco$US(etYMLC1P^;*o&A8%EMxmR^TxehM^%BCG!i#UP zOZwUzaEdR+{4$ z1`NkOV5}j0#lN?puKB)i2xzL$cMh@GsEdqsy-4X?QQrT_L_i~;Fp_#Tv zb7-3^SypwUUI-wqE0!wqstPMs0CGB*BfKP2Z?y0sV~(N?&3;-q_`kAJ1a8JEn7uWn zhuq%iaZZDA;yL&l?ji*dN1vVoV3Td(c$ds!ff>(xzV9M zP#oSPH#(pXq#Ivope7DCb_{M6WWM>gKJmrpzF!i3oYMS*U(E4usGHG{QLQ)3iPm})|ETrs4ooC9kvTej%*5*|$aB&ghJ>zt z!<0}+W5U_+${_KUk1@|U3h;<-gIw=^pLH%{c@0K#k&`SR^0wo&}Zkl z4qhWLYIcc28ld@oXY`W*9u`sojqs+C@TQSa0xwLrX@J%xr-G;tqPQ!SE0_+^4g!Qn zkwijPDrDdMpQFVz=B(MP9=I}<^pk=jYp7F>_3$07O=Az~DSodF+w|d|m1oqbW z9#KcUSA*lx1AAH#hSkVs3Di_+rm13@vIHxEO) z4i6QZRPFDy!HUsF&R;@~gDbNwRO(q`KdCk@LkDjE_JpB|rp>wvJ!m*7sBo)V7}63# z*F_Faox>`;5EC6(<;C1L%_%tGb{63#7PJ?){R5nR1YeVmJU=T1sS5ZHuBi@e0FV>E z|HHu{2P;%9B)Ji z5vQ=ySqh$sxDz%A`La21m9gk+AWfWA_EY(=0otmN1!FNAE^vR^D5T{Y@!*N~aW(7x zlW8I@IGyhSADQ?5>CA^upoG5Ek2Bl-oRwbUAU?zf04<%;?GfAUORsQ<*>Mz2WlJx0 z6qqi6bVkB0#VLK=rX>s91t$w2osDp-Yz}cPRp6Fv{@Zf-UwLjLPaRmIoCaU%)_hZbo74Djq-CgY*%snCl%=%O*SXv6qs{TMm4^;psPM9w((h8c{# zS0$EJY)XB4YZsc)I>3Sfl2`1E{f9s@$FL{qPBmotuwbc8M;-2P@KoklS;ZSCz|TcL zRK?tdX37|LQ49}K43hx)2DDWb_ZpA`!9KqkzKUPePV_^MW*CNT4^LyG7i z`yqAJ*$4xf_gBV-|EiM>_8}WgWcD`e;#u^!&2gT=LOhi@>kXd_6FTmgYPT0*5GJ|S zfT7c#at!n!b~R&d;j3OYR2K*L?-JN^90YEPngRYoFnb*cW{*uM1QYmUOr74`GnM9| zvA51LcJDbLpYHmS9^#l%Uhy$aBI##9)(mKHJQ|11Be;<=5_wgh=0Y0TZdQNNr5ZtE ztDS<0BYf2#r&D}9bmCF23#)M#Z%UEWkGsAor?P#V*aDlfzcKc}Z-z7v&Ns~>mt*Tz zY zLrLj?Nl{Y}ia~CHDukg)IqM~oKkOnpF;F;0z_Zq291$2p)_M$pn*Su23o3j9n5BAl zp%&|LAmx;gnNN0QE&Wu@uB@dL9r0a?)E*h%%jzn?v!BwLLzTA`D+mIRUM=Y!$dh|M z=W-?RAcSan0v|*cV%_|}AXXh!EK@0pIYaGAsDlwGSM5qj9D&7HyOK<=%bPNPkW$N^T6Jxe zWd78uJ6X-2T6K}y6W*c>Fs;=wq7teQ-uB9CbxN!xY^NI_QFY71JZP90w&fG|3QRj1 zI@aJucZ?DOV107AT*C9xeMt_&Eb#;XzKL-Svs*2!&>Cx-S*n zbYChe0=R|B{2Tc91}*`XgU;|3j(6#X0dWH^pmG2aiH#Guk#iJPPyl2NwKv=6W{xR~ z$aL^23le8`nKc$LUmr(nud@m`2g28CEJxFct7TX0(pxM6EnMwpt=`7-dM*s+5+*Z8 z!Xi9{svC?ko}k#)LCnr=_-1?Cda`wRr#6i{_TPwRRfMT#x`nX@ACaAJ0!JeS{);Y@ zh1J2<8sL={5q2VJ`J?<^q_MEa_-wqe%pO$sJ`1y1Z6`n*4@pu-sRp4K&6@zv6VWu8 z7O&b(Cvc05MtKq>-3~yoMQy|_c!@(D8@?uF{T|>4h0gn!SmfBt!X-hR^}1C$z1E*p zXBx9rg3dcmTz|lVsx7p_I-{}@;IbcMq@GbO5h>n)a5?BNiZrOzr;*I&uwALd*+W4x z?qU&8p{=&Gs*D|wIHd)Y%*!N5mMREdEm73*7YQOPRo*55eAtkhV$FDwcT!k^Xas6M zMMZ?xRKdD-u`-NJe<7B|O||%kalH%GLuhmDu0Xg1zPJPS{0MQ?iq(D}24->P@HkL# zeuQE$dJ}5pCyjtGgQk@Mi0h*P%~=Lg)CW`bjlJ0k9)OMvG}uQ7?qrauJqI{{h}1bGw5OapU4l7PDn}|DQj!sJb(O$+rN(b);Ed^#?QJC%bhA-}_1E&Z1 z$p!{rTu`grj85zOE6@6dvQvt)zM?w4)WLOqgE~0Wy_f27G2)<|9MvI57GbXRbNblR zRIXyc3H~JN-x7k^ZHpmXoi`cV1Yg{0XFj_!H3lO5Y6?$l>EKp(3}LNv^qC7yHh-Lt z9Sc(~_!2kNxel|c1Q>O>&>rj(6U~^ybz$ChBa9^uycm|Ha2#q=u^02vr0S$eJs^U$@Wl=%!%IGNLWM<>ak{ixz;3ao!gy z;RX0&PvujKstbGiD8|;q7rO#mv-~R2tk1ZtN$v)tMYW3^S5N>!`|4;>>tZ{aXyqLF z-JM`l*o9|<-dd1v4#<;WUyh=aV8`GOOE@=*=9c!avt;ea{sn$|LKj{1fK^`wF)JN- zdGJ*~v1y^`yVj@%2w~atqVHQ}>1V$Tno_i$4B^MAl!?<_fjEI^<3X_wTo{&)2ZMWz92qbh=9Z_m=qha(<5j!tHfKWr`1NVipaE}~`Zf5k>c5*k=3xrA z)dzz^*I+45Hgw#lB%s_2(G5C-5)4v1ZoI4MbLU?*Y-s>`@upM8mJO^=oiU{s?{>Q6 zCacu%hz&-a;wpa}msLLNKQ2>q-|>b{*C_zqLUC;v3&KTRkJa(6TO)rW0Qtk?1-We= zIAYy0N7n;o7YR(_c)OGf9}IBel~c^N21w6!jS=G1b8Dm4%V+&Zt>2%Oqt?dsuz*qw zy5F#KrVPW|`n!ev?hI2FLzoU`R`?oPSm^I&WxpJPCJMY{?i$`^kvxX80gCk}aQ^@i zz`A1)F#QFbu=ZwOJk-tlbbXEn_bm^@e8Fms`o%47n}Kc>CLfJqnxR;&iK-K8O3B4r zKS&ZjlX>efb?GB0h;PQNN;ozK_cOHDfQ(N;AsqKa0Jsp=uz8T3Ui$%%UOZ7jX2UyA z`W2UPj=8|ueJX&{o1!UdoX1gLDbDEUEJ){x#LW)Tb1YcWz?XIzM9;N+djY}77E^63 zdY%RE_5sgjz0q^NWiVA+n&>SVBJaHnfj;Ny5^C*=dI2g{(Tnnji8K6{;shyOXO}MJ z!w&8z6~Jb<#ter5aE^4Kg7m@W?tw}Yz=)?-mq0M^kFH?=-ctc5hy5rYy~ftOBN}lll0!xp9X;m=_koy>H{9x+ffUm3#ML>cUZ3rCW{SjoK2xZt&B> z9$l=K^$baQMg>r@C)PIr#TrPUEF|M(14Ayo(NF?77b)Ld08@C%O56vyU`u{4r)JLC zBp#b3vus3$W%UY$HSMI3oBXxU0V;9F9JL6&YFWbW4?R)sSyB%YxH)tTsGvC=HZ0A%ofW`drMBU#4n56#5 zf1w=`-I)A07AsUc%e!DogfI0H$2_gN1}407ZxW0WrB-`MzZ@DHuhcJjOiC0?c<%v^ z`m87XmYT4^OjDvwaLOnkSqk_PMvuB#I{{TH(U-nSbjo?4uMYV7S=mU^Z>9O6l@b}z zrUUsYk3zMct`Q|CeZe())RojLJk<35NK!Kh&=9Cqrv}6YuBY6)))#~15kqdI_ zOUk$83YT=c1Z4RY4@nMwM@M4!m3oT@*LeGFGcwJEqb@D_2>5Eg0?|`@43gpA$K*E+ z?+--Cj5P&GOs&Y+b>j;Jh)sG5u)oT%T7i@Hpy7bUD)%tf1isV|C6H2tC{!z}s64Tk z;q4}Y2DHRL;R;@l*hJjV2@n!jZ*W-`743AX5lV^VhQH}Zmq6AmVMHYT3X=8*stlK+ zm`F?Z4mD9Gwt$wPf+W)9WwEx7jJ1F-^+{z~Ut?0V{ zQba%4A_ptL(~8*BF^Qn(6|tZ?il7B@SGnvn!57O&?Ia~Jiu6P$#`eRPT32!0SAakb!9BR8wBsDj4w!p zP6iP=8${?LMVO8vbQ2;(qCFtByD~!z4TL~FOak>V3)DjwXd(#nE()|l`MDs0RvH9a zWe{jJ2^6>TsE4Jlp{@QNu_r0@C0R%#x}!WBr99&Z+C;?}HPZmV5Qm`61Zk3QHA^mi z0bV1+=KaPEWxvr(E@IWaUy|NrF9%5O0L|(JT~jZ7)JUO@CcjLGH)KL#Lnah4>1t7# z9-*DZRQ0QplO@JVxTek9y#uw@`5pv*O(_h0NY0{4;v)If-G)f^P$X5GR+jDh>l9IX z_!SU49BAKE;t~%-b5I!&-tvG+Dhcz(djLvb0zci5=6NMLaUfvd21Mc(aC`=iy;8DWpQ=WIWUG>2w-2lo+z^2xLoa!ch@QsAjG$lBt>fK;g z0FN}@c_92LHGQL*2>X}?K(hhxC5#?*v)*we_pVv5zsrDFbSn z`j|G*dpuTKe~}@zloDFPh)8M+NqPkPn1i4)Mjz^9@Sk@P=5Up2U^le{pwi~diZz-{fUqgUT0g+f4M%~|nBfSLtTtn}dK)W6T zY!mc82#$Nf;q}6(F{vmF#76-nlC zZ`blywktl$#J}xU`Ya!0=|h|@gJLD_lGq~f)r^C>CmQs( zM1x+URvrBrgPO~;)bZC_)PN_4c7^480|jcSDM;dH5Trd&nXpN*FeB^LRgQg1ykn^3 zHP>XSalEO=VWhyu))XZ1JOsH5<1k{Aia^mel5w;|CWoc3ofIs7k9wf_ z8-6PEWGsECQg5z$uny^I+74Lk(WrL-H}(!J_J#gnvW72xtRki(Y7i|75jM{dcAVaQ zrH_~07fol=CyKs#gv+e~h9T$k3_GvZ&~d#0U;0c1=S)>w)E1pr`csA|W{J-0tJ3^1@k;wE$$4v6yEpPzw`r?W4Vl*O*|V zTl0Kfkt7bXp8<7E{>=~`&mE*ctLUR-L=@vK3tJVI(VUwJ%RUsASOMn$y#Wt2gW*rc z&-?X6pn1bfSj{s`(Io0heN{bas#PFOJ7MSx+FATCXG0E?cCHx(+PSfQ{@Pih!5wJls|^Ba z=k*3sJBv3gKs$@^+&k6Hb`9@TH=k@6NH?h+d%K}oH}#Cm{CTr)#ue=*TgNVxahUkT zs74~Ol~yCP5uleb={+T76HNNF#xm)<8yk|Yk`$InPi)xOSTScx?*ujRMnvMbjq^*q zkqi@Gr->o)TG6+s6ij^|+FSV2ds9jt-GEHizpM~j&Rl)zVu+rFW5S_Z6-6p zY0)#mWuZ*?sF~D%x5ZEYsi49wQN?%{REWg(&803F36gdfe1x)QIgKs6-7v==CCm!K zB=_C#qav%6(CSG(NUCI7;_%t9nvpHlTv{!La3>52M2hs4hPOr$k=O`=1b5?RMoFUq z8`DjM)qK#{7B!vZTq#FIf%1zvsx)`QvMi1BHuf`kS#g4uO)rU9vE88uD8O>r=hxv_ z058G{Pe{)WjGch5WUojvnyF8nNLzF-eCR|PmV2p&<)XmLG5A4TNYmrOeE*!@IH8^X zwCB%5XUEAIXFUWZ-VN{N@IDawASweiW@#J^*BTSoi%><>Eq|8=G4%;{aZ=kIHwa$} zf?&hZLaueou5T>bg&lHJG_4bqdBAT`AS7eBw4-_U+tGZZBhIGd#KUi6o z$RAwcXuc3kjo80&*1Yhqk-}+hz8tW{@NkEt`3BYLX}(Q$#x;Lkb$XlcS2?6LKcYHI zH~&N>DBt{Z)mfc64sW-!I79T~2dL3or+|}Ql(1T#Qk}NubHRBG34)qWxW-kXmJCpZ z0yV&@V;=*UkTvjg2EH0y5DrvR#^Ls z3S(N}A0%6P8#;czM@T{I%^&8)6W|!pQ&U&D-?c8+o~vtT-K1GU`UZ}HFFt1@>TrwXF8;o$P{AhpcD{mrPTqW+d0 zj!gk+YT4mJIq}dlFFOK-5{g=OgittOQOC6U79iI{zA)!HHalvrlb@C;$iz2OY}np* zdQcTOY_PGx(Ueq=Etx5%*sv{9VafnX5Lp7PdSPKtkhT-|C3Q3gwA-KZN zD zxUr81Knz(r!ltkp(65&7n&jOLe-k%Cj}{NeiU)To>>6MyBuA#a1P$v&fQy#|dAu;y zDmqe$@aBLcr9F6M0Jh=};GYMW*iOOT4e0Y5#N%OO?B(kEL)oKTt5)9ORhh%`tHj9NOXr{5z<)V4s=LY4(ML-?ZGV2hRC)?

jsF$_%q zrQ6y;abtyIWX0lpoRHuycBvSHVufNShRvkFpp$piv~%#&dIOw1Tw! z*-kQs0l2G(a6uh#Q&AXgD(XP@mxPN=L>@CCt2p{r@C+AgV%7l(e7w=V)-Ek0)GcY5!*LaW$q2Lqtq;kgmcI*|<6G zpNySMbL?b#z3SV^Oy)6JdVZ9U`GM{2u_vT(7{e=5RpBP-$$y@be{L!|7rv(_e~u~n zi%iKEelVcHL{y$GqrlMZo>ZgQ`5sp#5(j3(ia@7Y@y2B7pKg%2F-jbE`U!MS{=JHU zDf@1Q8tpJcv`z60uN17?OqJq81H~?Ja&|JmY(VZMqzMSDako=4c35Zn1s(N;EW_K! zsy!`BwZ`lMOEo}Z@{vD4RFir1VRh?V#Y8$nOk3x`O+E1x{>l#XePDPyd!;lh9zCEV zSKy}MarcR+rIpH9={9-fT>7wfgj=3Yj-%3z;&)oS0TgyJuZ_si-O$>sY!xKyOpYEn zhnne+o<}DVdBRUWkJTqvjEx+d=M<2ewCU~nd8!uN#kKgukBkfJR9NqIlY(Qre-a#pAZ68yueZW*}`>3@R zIhNZfk|v-=5^{XEQ5zA9>8o)>YSSX^{Q{r^NWS;eDK}TJ#TI)-?i^Gs^j7qof7^i_YJ=#YD?N&I=FbuT&57P(Q zOgxRoe-xjq@g=yTaAIg*`+2W<-ve)3mGHgl}R3vY0V3ytFO~_;)d6F zC<&An#L(lomsT22%}1o#KIq6>f@6FZKMv_Obe`ALW&;^xyfnMe!*ZZ*vDPt6xo66q<~7VAUbeyH>9En`-V8V&_jF7`zR#6Odhpmvq+(Rn@4RfPc7BI|hwz7a>?u3

XQch*}EbK3GyK5cda?$Vnc#*@!t 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

T64Do}@1z+G6(_8Qlr?JB;< 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'M6|AtY`{MVjzT<#9+>jqVm1f(hgy)p3Nxv@J~` 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

|y* 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