From aa4492d443d5b41e059f1e651ee22ec9bcf0bb70 Mon Sep 17 00:00:00 2001 From: Stanislav Hejny Date: Thu, 14 Aug 2025 09:29:57 +0100 Subject: [PATCH] Create API documentation --- AMQ_ADAPTER_DEVELOPER_GUIDE.md | 663 ++++ DEPLOYMENT.md | 182 ++ README.md | 8 +- api-doc/Makefile | 20 + api-doc/README.md | 51 + api-doc/_build/doctrees/environment.pickle | Bin 0 -> 576168 bytes api-doc/_build/doctrees/index.doctree | Bin 0 -> 5238 bytes .../doctrees/modules/amqp.adapter.doctree | Bin 0 -> 521995 bytes .../doctrees/modules/amqp.config.doctree | Bin 0 -> 41073 bytes api-doc/_build/doctrees/modules/amqp.doctree | Bin 0 -> 3459 bytes .../doctrees/modules/amqp.model.doctree | Bin 0 -> 275457 bytes .../doctrees/modules/amqp.rabbitmq.doctree | Bin 0 -> 96782 bytes .../doctrees/modules/amqp.router.doctree | Bin 0 -> 153515 bytes .../doctrees/modules/amqp.service.doctree | Bin 0 -> 231970 bytes api-doc/_build/html/.buildinfo | 4 + .../amqp/adapter/amq_route_factory.html | 193 ++ .../amqp/adapter/backpressure_handler.html | 466 +++ .../adapter/cleverthis_service_adapter.html | 948 ++++++ .../adapter/consul_global_id_generator.html | 214 ++ .../amqp/adapter/data_message_factory.html | 449 +++ .../_modules/amqp/adapter/data_parser.html | 325 ++ .../amqp/adapter/data_response_factory.html | 276 ++ .../_modules/amqp/adapter/file_handler.html | 561 ++++ .../_modules/amqp/adapter/logging_utils.html | 250 ++ .../amqp/adapter/pydantic_serializer.html | 304 ++ .../_modules/amqp/adapter/serializer.html | 216 ++ .../amqp/adapter/service_message_factory.html | 278 ++ .../amqp/adapter/trace_info_adapter.html | 126 + .../amqp/adapter/type_descriptor.html | 324 ++ .../amqp/config/amq_configuration.html | 383 +++ .../html/_modules/amqp/model/model.html | 589 ++++ .../amqp/model/service_message_type.html | 120 + .../_modules/amqp/model/snowflake_id.html | 204 ++ .../amqp/rabbitmq/rabbit_mq_client.html | 374 +++ .../user_management_service_client.html | 397 +++ .../_modules/amqp/router/route_database.html | 209 ++ .../_modules/amqp/router/router_base.html | 258 ++ .../_modules/amqp/router/router_consumer.html | 328 ++ .../_modules/amqp/router/router_producer.html | 362 +++ .../html/_modules/amqp/router/utils.html | 156 + .../amqp/service/amq_message_handler.html | 692 +++++ .../_modules/amqp/service/amq_service.html | 431 +++ .../html/_modules/amqp/service/tracing.html | 327 ++ api-doc/_build/html/_modules/index.html | 134 + api-doc/_build/html/_sources/index.rst.txt | 23 + .../_sources/modules/amqp.adapter.rst.txt | 77 + .../html/_sources/modules/amqp.config.rst.txt | 12 + .../html/_sources/modules/amqp.model.rst.txt | 22 + .../_sources/modules/amqp.rabbitmq.rst.txt | 17 + .../html/_sources/modules/amqp.router.rst.txt | 32 + .../_build/html/_sources/modules/amqp.rst.txt | 7 + .../_sources/modules/amqp.service.rst.txt | 22 + .../_sphinx_javascript_frameworks_compat.js | 123 + api-doc/_build/html/_static/basic.css | 906 ++++++ .../_build/html/_static/css/badge_only.css | 1 + .../_static/css/fonts/Roboto-Slab-Bold.woff | Bin 0 -> 87624 bytes .../_static/css/fonts/Roboto-Slab-Bold.woff2 | Bin 0 -> 67310 bytes .../css/fonts/Roboto-Slab-Regular.woff | Bin 0 -> 86285 bytes .../css/fonts/Roboto-Slab-Regular.woff2 | Bin 0 -> 66444 bytes .../_static/css/fonts/fontawesome-webfont.eot | Bin 0 -> 165719 bytes .../_static/css/fonts/fontawesome-webfont.svg | 2671 +++++++++++++++++ .../_static/css/fonts/fontawesome-webfont.ttf | Bin 0 -> 165525 bytes .../css/fonts/fontawesome-webfont.woff | Bin 0 -> 98019 bytes .../css/fonts/fontawesome-webfont.woff2 | Bin 0 -> 77159 bytes .../_static/css/fonts/lato-bold-italic.woff | Bin 0 -> 323338 bytes .../_static/css/fonts/lato-bold-italic.woff2 | Bin 0 -> 193307 bytes .../html/_static/css/fonts/lato-bold.woff | Bin 0 -> 309725 bytes .../html/_static/css/fonts/lato-bold.woff2 | Bin 0 -> 184907 bytes .../_static/css/fonts/lato-normal-italic.woff | Bin 0 -> 328407 bytes .../css/fonts/lato-normal-italic.woff2 | Bin 0 -> 195703 bytes .../html/_static/css/fonts/lato-normal.woff | Bin 0 -> 309189 bytes .../html/_static/css/fonts/lato-normal.woff2 | Bin 0 -> 182701 bytes api-doc/_build/html/_static/css/theme.css | 4 + api-doc/_build/html/_static/doctools.js | 149 + .../html/_static/documentation_options.js | 13 + api-doc/_build/html/_static/file.png | Bin 0 -> 285 bytes .../html/_static/fonts/Lato/lato-bold.eot | Bin 0 -> 256053 bytes .../html/_static/fonts/Lato/lato-bold.ttf | Bin 0 -> 600836 bytes .../html/_static/fonts/Lato/lato-bold.woff | Bin 0 -> 309725 bytes .../html/_static/fonts/Lato/lato-bold.woff2 | Bin 0 -> 184907 bytes .../_static/fonts/Lato/lato-bolditalic.eot | Bin 0 -> 266157 bytes .../_static/fonts/Lato/lato-bolditalic.ttf | Bin 0 -> 622530 bytes .../_static/fonts/Lato/lato-bolditalic.woff | Bin 0 -> 323338 bytes .../_static/fonts/Lato/lato-bolditalic.woff2 | Bin 0 -> 193307 bytes .../html/_static/fonts/Lato/lato-italic.eot | Bin 0 -> 268604 bytes .../html/_static/fonts/Lato/lato-italic.ttf | Bin 0 -> 639351 bytes .../html/_static/fonts/Lato/lato-italic.woff | Bin 0 -> 328407 bytes .../html/_static/fonts/Lato/lato-italic.woff2 | Bin 0 -> 195703 bytes .../html/_static/fonts/Lato/lato-regular.eot | Bin 0 -> 253460 bytes .../html/_static/fonts/Lato/lato-regular.ttf | Bin 0 -> 607681 bytes .../html/_static/fonts/Lato/lato-regular.woff | Bin 0 -> 309189 bytes .../_static/fonts/Lato/lato-regular.woff2 | Bin 0 -> 182701 bytes .../fonts/RobotoSlab/roboto-slab-v7-bold.eot | Bin 0 -> 79518 bytes .../fonts/RobotoSlab/roboto-slab-v7-bold.ttf | Bin 0 -> 170558 bytes .../fonts/RobotoSlab/roboto-slab-v7-bold.woff | Bin 0 -> 87624 bytes .../RobotoSlab/roboto-slab-v7-bold.woff2 | Bin 0 -> 67310 bytes .../RobotoSlab/roboto-slab-v7-regular.eot | Bin 0 -> 78330 bytes .../RobotoSlab/roboto-slab-v7-regular.ttf | Bin 0 -> 169016 bytes .../RobotoSlab/roboto-slab-v7-regular.woff | Bin 0 -> 86285 bytes .../RobotoSlab/roboto-slab-v7-regular.woff2 | Bin 0 -> 66444 bytes api-doc/_build/html/_static/jquery.js | 2 + api-doc/_build/html/_static/js/badge_only.js | 1 + api-doc/_build/html/_static/js/theme.js | 1 + api-doc/_build/html/_static/js/versions.js | 228 ++ api-doc/_build/html/_static/language_data.js | 191 ++ api-doc/_build/html/_static/minus.png | Bin 0 -> 89 bytes api-doc/_build/html/_static/plus.png | Bin 0 -> 89 bytes api-doc/_build/html/_static/pygments.css | 75 + api-doc/_build/html/_static/searchtools.js | 635 ++++ .../_build/html/_static/sphinx_highlight.js | 154 + api-doc/_build/html/genindex.html | 1389 +++++++++ api-doc/_build/html/index.html | 230 ++ api-doc/_build/html/modules/amqp.adapter.html | 2119 +++++++++++++ api-doc/_build/html/modules/amqp.config.html | 276 ++ api-doc/_build/html/modules/amqp.html | 115 + api-doc/_build/html/modules/amqp.model.html | 1055 +++++++ .../_build/html/modules/amqp.rabbitmq.html | 443 +++ api-doc/_build/html/modules/amqp.router.html | 810 +++++ api-doc/_build/html/modules/amqp.service.html | 905 ++++++ api-doc/_build/html/objects.inv | Bin 0 -> 3731 bytes api-doc/_build/html/py-modindex.html | 296 ++ api-doc/_build/html/search.html | 126 + api-doc/_build/html/searchindex.js | 1 + api-doc/conf.py | 82 + api-doc/index.html | 77 + api-doc/index.rst | 23 + api-doc/make.bat | 35 + api-doc/modules/amqp.adapter.rst | 77 + api-doc/modules/amqp.config.rst | 12 + api-doc/modules/amqp.model.rst | 22 + api-doc/modules/amqp.rabbitmq.rst | 17 + api-doc/modules/amqp.router.rst | 32 + api-doc/modules/amqp.rst | 7 + api-doc/modules/amqp.service.rst | 22 + pydoc-markdown.yml | 32 + 135 files changed, 24386 insertions(+), 5 deletions(-) create mode 100644 AMQ_ADAPTER_DEVELOPER_GUIDE.md create mode 100644 DEPLOYMENT.md create mode 100644 api-doc/Makefile create mode 100644 api-doc/README.md create mode 100644 api-doc/_build/doctrees/environment.pickle create mode 100644 api-doc/_build/doctrees/index.doctree create mode 100644 api-doc/_build/doctrees/modules/amqp.adapter.doctree create mode 100644 api-doc/_build/doctrees/modules/amqp.config.doctree create mode 100644 api-doc/_build/doctrees/modules/amqp.doctree create mode 100644 api-doc/_build/doctrees/modules/amqp.model.doctree create mode 100644 api-doc/_build/doctrees/modules/amqp.rabbitmq.doctree create mode 100644 api-doc/_build/doctrees/modules/amqp.router.doctree create mode 100644 api-doc/_build/doctrees/modules/amqp.service.doctree create mode 100644 api-doc/_build/html/.buildinfo create mode 100644 api-doc/_build/html/_modules/amqp/adapter/amq_route_factory.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/backpressure_handler.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/cleverthis_service_adapter.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/consul_global_id_generator.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/data_message_factory.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/data_parser.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/data_response_factory.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/file_handler.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/logging_utils.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/pydantic_serializer.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/serializer.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/service_message_factory.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/trace_info_adapter.html create mode 100644 api-doc/_build/html/_modules/amqp/adapter/type_descriptor.html create mode 100644 api-doc/_build/html/_modules/amqp/config/amq_configuration.html create mode 100644 api-doc/_build/html/_modules/amqp/model/model.html create mode 100644 api-doc/_build/html/_modules/amqp/model/service_message_type.html create mode 100644 api-doc/_build/html/_modules/amqp/model/snowflake_id.html create mode 100644 api-doc/_build/html/_modules/amqp/rabbitmq/rabbit_mq_client.html create mode 100644 api-doc/_build/html/_modules/amqp/rabbitmq/user_management_service_client.html create mode 100644 api-doc/_build/html/_modules/amqp/router/route_database.html create mode 100644 api-doc/_build/html/_modules/amqp/router/router_base.html create mode 100644 api-doc/_build/html/_modules/amqp/router/router_consumer.html create mode 100644 api-doc/_build/html/_modules/amqp/router/router_producer.html create mode 100644 api-doc/_build/html/_modules/amqp/router/utils.html create mode 100644 api-doc/_build/html/_modules/amqp/service/amq_message_handler.html create mode 100644 api-doc/_build/html/_modules/amqp/service/amq_service.html create mode 100644 api-doc/_build/html/_modules/amqp/service/tracing.html create mode 100644 api-doc/_build/html/_modules/index.html create mode 100644 api-doc/_build/html/_sources/index.rst.txt create mode 100644 api-doc/_build/html/_sources/modules/amqp.adapter.rst.txt create mode 100644 api-doc/_build/html/_sources/modules/amqp.config.rst.txt create mode 100644 api-doc/_build/html/_sources/modules/amqp.model.rst.txt create mode 100644 api-doc/_build/html/_sources/modules/amqp.rabbitmq.rst.txt create mode 100644 api-doc/_build/html/_sources/modules/amqp.router.rst.txt create mode 100644 api-doc/_build/html/_sources/modules/amqp.rst.txt create mode 100644 api-doc/_build/html/_sources/modules/amqp.service.rst.txt create mode 100644 api-doc/_build/html/_static/_sphinx_javascript_frameworks_compat.js create mode 100644 api-doc/_build/html/_static/basic.css create mode 100644 api-doc/_build/html/_static/css/badge_only.css create mode 100644 api-doc/_build/html/_static/css/fonts/Roboto-Slab-Bold.woff create mode 100644 api-doc/_build/html/_static/css/fonts/Roboto-Slab-Bold.woff2 create mode 100644 api-doc/_build/html/_static/css/fonts/Roboto-Slab-Regular.woff create mode 100644 api-doc/_build/html/_static/css/fonts/Roboto-Slab-Regular.woff2 create mode 100644 api-doc/_build/html/_static/css/fonts/fontawesome-webfont.eot create mode 100644 api-doc/_build/html/_static/css/fonts/fontawesome-webfont.svg create mode 100644 api-doc/_build/html/_static/css/fonts/fontawesome-webfont.ttf create mode 100644 api-doc/_build/html/_static/css/fonts/fontawesome-webfont.woff create mode 100644 api-doc/_build/html/_static/css/fonts/fontawesome-webfont.woff2 create mode 100644 api-doc/_build/html/_static/css/fonts/lato-bold-italic.woff create mode 100644 api-doc/_build/html/_static/css/fonts/lato-bold-italic.woff2 create mode 100644 api-doc/_build/html/_static/css/fonts/lato-bold.woff create mode 100644 api-doc/_build/html/_static/css/fonts/lato-bold.woff2 create mode 100644 api-doc/_build/html/_static/css/fonts/lato-normal-italic.woff create mode 100644 api-doc/_build/html/_static/css/fonts/lato-normal-italic.woff2 create mode 100644 api-doc/_build/html/_static/css/fonts/lato-normal.woff create mode 100644 api-doc/_build/html/_static/css/fonts/lato-normal.woff2 create mode 100644 api-doc/_build/html/_static/css/theme.css create mode 100644 api-doc/_build/html/_static/doctools.js create mode 100644 api-doc/_build/html/_static/documentation_options.js create mode 100644 api-doc/_build/html/_static/file.png create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-bold.eot create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-bold.ttf create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-bold.woff create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-bold.woff2 create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-bolditalic.eot create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-bolditalic.ttf create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-bolditalic.woff create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-bolditalic.woff2 create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-italic.eot create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-italic.ttf create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-italic.woff create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-italic.woff2 create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-regular.eot create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-regular.ttf create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-regular.woff create mode 100644 api-doc/_build/html/_static/fonts/Lato/lato-regular.woff2 create mode 100644 api-doc/_build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.eot create mode 100644 api-doc/_build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.ttf create mode 100644 api-doc/_build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff create mode 100644 api-doc/_build/html/_static/fonts/RobotoSlab/roboto-slab-v7-bold.woff2 create mode 100644 api-doc/_build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.eot create mode 100644 api-doc/_build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.ttf create mode 100644 api-doc/_build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff create mode 100644 api-doc/_build/html/_static/fonts/RobotoSlab/roboto-slab-v7-regular.woff2 create mode 100644 api-doc/_build/html/_static/jquery.js create mode 100644 api-doc/_build/html/_static/js/badge_only.js create mode 100644 api-doc/_build/html/_static/js/theme.js create mode 100644 api-doc/_build/html/_static/js/versions.js create mode 100644 api-doc/_build/html/_static/language_data.js create mode 100644 api-doc/_build/html/_static/minus.png create mode 100644 api-doc/_build/html/_static/plus.png create mode 100644 api-doc/_build/html/_static/pygments.css create mode 100644 api-doc/_build/html/_static/searchtools.js create mode 100644 api-doc/_build/html/_static/sphinx_highlight.js create mode 100644 api-doc/_build/html/genindex.html create mode 100644 api-doc/_build/html/index.html create mode 100644 api-doc/_build/html/modules/amqp.adapter.html create mode 100644 api-doc/_build/html/modules/amqp.config.html create mode 100644 api-doc/_build/html/modules/amqp.html create mode 100644 api-doc/_build/html/modules/amqp.model.html create mode 100644 api-doc/_build/html/modules/amqp.rabbitmq.html create mode 100644 api-doc/_build/html/modules/amqp.router.html create mode 100644 api-doc/_build/html/modules/amqp.service.html create mode 100644 api-doc/_build/html/objects.inv create mode 100644 api-doc/_build/html/py-modindex.html create mode 100644 api-doc/_build/html/search.html create mode 100644 api-doc/_build/html/searchindex.js create mode 100644 api-doc/conf.py create mode 100644 api-doc/index.html create mode 100644 api-doc/index.rst create mode 100644 api-doc/make.bat create mode 100644 api-doc/modules/amqp.adapter.rst create mode 100644 api-doc/modules/amqp.config.rst create mode 100644 api-doc/modules/amqp.model.rst create mode 100644 api-doc/modules/amqp.rabbitmq.rst create mode 100644 api-doc/modules/amqp.router.rst create mode 100644 api-doc/modules/amqp.rst create mode 100644 api-doc/modules/amqp.service.rst create mode 100644 pydoc-markdown.yml diff --git a/AMQ_ADAPTER_DEVELOPER_GUIDE.md b/AMQ_ADAPTER_DEVELOPER_GUIDE.md new file mode 100644 index 0000000..85309b4 --- /dev/null +++ b/AMQ_ADAPTER_DEVELOPER_GUIDE.md @@ -0,0 +1,663 @@ +# AMQ Adapter Developer Guide + +## Overview + +The AMQ Adapter library enables FastAPI-based Business Services to communicate with the CleverMicro platform via RabbitMQ. This guide demonstrates how to build your own service using the AMQ Adapter, following the pattern established by the OTDemo application. + +## Table of Contents + +1. [Architecture Overview](#architecture-overview) +2. [Prerequisites](#prerequisites) +3. [Project Structure](#project-structure) +4. [Implementation Steps](#implementation-steps) +5. [Configuration](#configuration) +6. [Creating Your Adapter](#creating-your-adapter) +7. [Frontend Integration](#frontend-integration) +8. [Backend Processing](#backend-processing) +9. [Testing and Deployment](#testing-and-deployment) +10. [Advanced Features](#advanced-features) + +## Architecture Overview + +The AMQ Adapter follows a layered architecture: + +``` +┌─────────────────────────────────────────────────────────────┐ +│ Business Service │ +├─────────────────────────────────────────────────────────────┤ +│ FastAPI Endpoints │ Your Custom Adapter │ Backend │ +│ │ │ Processing │ +└─────────────────────┼───────────────────────┼───────────────┘ + │ │ +┌─────────────────────┼───────────────────────┼───────────────┐ +│ AMQ Adapter Library │ │ +├─────────────────────────────────────────────────────────────┤ +│ CleverThisServiceAdapter │ AMQService │ Router │ +│ (Base Class) │ │ │ +└─────────────────────┼───────────────────────┼───────────────┘ + │ │ +┌─────────────────────┼───────────────────────┼───────────────┐ +│ RabbitMQ │ │ +│ Exchanges │ Queues │ Routing Keys │ │ +└─────────────────────────────────────────────────────────────┘ +``` + +### Key Components + +- **Your Custom Adapter**: Extends `CleverThisServiceAdapter` to handle service-specific logic +- **AMQService**: Manages RabbitMQ connections and message routing +- **Router**: Routes incoming AMQP messages to appropriate endpoints +- **Configuration**: Defines service settings, routing, and RabbitMQ connection details + +## Prerequisites + +Before building your service, ensure you have: + +1. **Python 3.8+** installed +2. **RabbitMQ** server running (or access to CleverMicro platform) +3. **FastAPI** knowledge +4. **AMQ Adapter library** installed in your project + +### Dependencies + +Add the following to your `requirements.txt`: + +```txt +fastapi>=0.111.0 +uvicorn[standard]>=0.29.0 +python-multipart>=0.0.20 +aio-pika>=9.0.0 +pydantic>=2.0.0 +# Add your AMQ Adapter library dependency +``` + +## Project Structure + +Follow this recommended structure for your Business Service: + +``` +your-business-service/ +├── main.py # FastAPI application entry point +├── requirements.txt # Python dependencies +├── config/ +│ ├── frontend.properties # Frontend service configuration +│ └── backend.properties # Backend service configuration +├── adapter/ +│ └── your_adapter.py # Your custom AMQ adapter +├── backend/ +│ └── backend_processor.py # Backend message processing +└── tests/ + └── test_your_service.py +``` + +## Implementation Steps + +### Step 1: Create Your Configuration Files + +Create configuration files for both frontend and backend services. + +**`config/frontend.properties`**: +```properties +# ==================================================================== +# CleverMicro AMQ Adapter settings +# ==================================================================== +[CleverMicro-AMQ] +cm.amq-adapter.service-name=your-service +cm.amq-adapter.generator-id=1 +cm.amq-adapter.route-mapping=your-service:your-exchange:your-queue-1:api.cm.dev.cleverthis.localhost.test.python.frontend.#:5:0 +cm.amq-adapter.require-authenticated-user=false +cm.amq-adapter.callbacks-enabled=True + +# CleverMicro AMQ Adapter dispatcher settings +cm.dispatch.use-dlq=true +cm.dispatch.amq-host=localhost +cm.dispatch.amq-port=5672 +cm.dispatch.amq-port-tls=5671 +cm.dispatch.download-dir=/tmp/downloaded_files + +# Backpressure settings +cm.backpressure.threshold=1 +cm.backpressure.time-window=150 +cm.backpressure.cpu-overload-duration=300 +cm.backpressure.cpu-idle-duration=300 +``` + +**`config/backend.properties`**: +```properties +# ==================================================================== +# CleverMicro AMQ Adapter settings +# ==================================================================== +[CleverMicro-AMQ] +cm.amq-adapter.service-name=your-service-backend +cm.amq-adapter.generator-id=1 +cm.amq-adapter.route-mapping=your-service-backend:your-exchange:your-queue-2:your-service-backend.#:5:0 +cm.amq-adapter.require-authenticated-user=false +cm.amq-adapter.callbacks-enabled=False + +# CleverMicro AMQ Adapter dispatcher settings +cm.dispatch.use-dlq=true +cm.dispatch.amq-host=localhost +cm.dispatch.amq-port=5672 +cm.dispatch.amq-port-tls=5671 +cm.dispatch.download-dir=/tmp/downloaded_files + +# Backpressure settings +cm.backpressure.threshold=1 +cm.backpressure.time-window=150 +cm.backpressure.cpu-overload-duration=300 +cm.backpressure.cpu-idle-duration=300 +``` + +### Step 2: Create Your Custom Adapter + +Create your custom adapter by extending `CleverThisServiceAdapter`: + +```python +""" +Your Business Service AMQP Adapter for handling API requests via AMQP. +This adapter is specific to your business service and handles service-specific logic. +""" + +from threading import Thread +from typing import Any, List + +from fastapi.routing import APIRoute + +from amqp.adapter.cleverthis_service_adapter import CleverThisServiceAdapter +from amqp.config.amq_configuration import AMQConfiguration +from amqp.service.amq_service import AMQService + + +class YourServiceAmqpAdapter(CleverThisServiceAdapter): + """ + Your Business Service AMQP Adapter. Implements service-specific logic that overrides + common logic defined by the AMQ Adapter library. + + Key responsibilities: + 1. Handle authentication and user management + 2. Process incoming AMQP messages + 3. Route messages to appropriate endpoints + 4. Manage service-specific business logic + """ + + def __init__(self, amq_configuration: AMQConfiguration, routes: List[APIRoute]): + super().__init__(amq_configuration, routes=routes, session=None) + self.amq_service: AMQService = AMQService(amq_configuration, self) + self.thread = Thread(target=self.amq_service.run) + self.thread.start() + + async def get_current_user(self, token: str) -> str: + """ + Override the default get_current_user method to handle authentication. + In this example, we simply return the token, but you should implement + proper JWT token validation and user extraction. + + :param token: JWT token from the AMQP message + :return: User identifier or user object + """ + # TODO: Implement proper JWT token validation + # Example: return await your_auth_service.validate_token(token) + return token + + def get_endpoint(self, endpoint: Any) -> Any: + """ + Override to provide custom endpoint selection logic. + For example, you might want to use JSON wrapper endpoints + or implement custom routing logic. + + :param endpoint: The original endpoint callable + :return: The endpoint callable to use (original or modified) + """ + return endpoint +``` + +### Step 3: Create Your FastAPI Application + +Create your main FastAPI application with endpoints: + +```python +""" +Your Business Service FastAPI Application +""" + +import os +from fastapi import FastAPI, File, Form, UploadFile +from fastapi.routing import APIRoute + +from amqp.config.amq_configuration import AMQConfiguration +from adapter.your_adapter import YourServiceAmqpAdapter + + +# Create FastAPI application +app = FastAPI( + title="Your Business Service", + description="A FastAPI application using AMQ Adapter for CleverMicro communication", + version="1.0.0" +) + +# Initialize your AMQ adapter +# This should be done after all routes are defined +your_adapter = None + + +@app.post("/api/v1/items") +async def create_item( + name: str = Form(...), + description: str = Form(...), + file: UploadFile = File(...) +): + """ + Create a new item with file upload. + This endpoint will be available via both REST and AMQP. + """ + # Your business logic here + result = { + "message": "Item created successfully", + "name": name, + "description": description, + "filename": file.filename + } + + # Example: Send a command to backend via AMQP + if your_adapter: + your_adapter.amq_service.command( + "your-service-backend", + "process_item", + item_name=name, + item_description=description + ) + + return result + + +@app.get("/api/v1/items") +async def get_items(): + """ + Retrieve all items. + This endpoint will be available via both REST and AMQP. + """ + # Your business logic here + items = [ + {"id": "1", "name": "Item 1", "description": "Description 1"}, + {"id": "2", "name": "Item 2", "description": "Description 2"} + ] + + return {"items": items} + + +@app.get("/health") +async def health_check(): + """ + Health check endpoint. + """ + return {"status": "healthy", "service": "your-business-service"} + + +# Initialize the AMQ adapter after all routes are defined +def initialize_amq_adapter(): + global your_adapter + config = AMQConfiguration("config/frontend.properties") + your_adapter = YourServiceAmqpAdapter(config, app.routes) + + +# Initialize adapter when the application starts +@app.on_event("startup") +async def startup_event(): + initialize_amq_adapter() + + +if __name__ == "__main__": + import uvicorn + uvicorn.run(app, host="0.0.0.0", port=8000) +``` + +### Step 4: Create Backend Processing + +Create a backend processor for handling AMQP messages: + +```python +""" +Backend processor for your business service. +Handles AMQP messages and performs background processing. +""" + +import asyncio +from amqp.config.amq_configuration import AMQConfiguration +from amqp.model.model import AMQRoute, DataMessage +from adapter.your_adapter import YourServiceAmqpAdapter + + +def process_item_static(item_name: str, item_description: str) -> str: + """ + Static function to process an item. + """ + print(f"STATIC Processing item: {item_name} - {item_description}") + return f"STATIC PROCESSED: {item_name}" + + +class BackendProcessor: + """ + Backend processor class for handling business logic. + """ + + def process_item(self, item_name: str, item_description: str) -> str: + """ + Process an item using instance method. + """ + print(f"CLASS Processing item: {item_name} - {item_description}") + return f"CLASS PROCESSED: {item_name}" + + +async def processing_loop(): + """ + Main processing loop for handling AMQP messages. + """ + # Wait for AMQ adapter to initialize + while not otadapter.amq_service.future.done(): + await asyncio.sleep(0.1) + + # Find the route for backend processing + route: AMQRoute = otadapter.amq_service.router.find_route_by_service("your-service-backend") + generator = otadapter.amq_service.data_message_generator(route) + + print(f"Data message generator created: {generator}") + + # Start the generator + message = await generator.asend(None) + + # Process messages + while True: + print(f"Received message: {message}") + if message is None: + break + + data_message: DataMessage = message + + # Extract message attributes + print(f"Message attributes: {data_message.method()} {data_message.domain()} {data_message.path()}") + + # Process based on message path + if data_message.path() == "process_item_static": + item_name = data_message._base64body.decode("utf-8") + process_item_static(item_name, "Static processing") + elif data_message.path() == "process_item": + item_name = data_message._base64body.decode("utf-8") + processor = BackendProcessor() + processor.process_item(item_name, "Class processing") + + # Get next message + message = await generator.asend(True) + + +if __name__ == "__main__": + # Initialize backend adapter + otadapter = YourServiceAmqpAdapter(AMQConfiguration("config/backend.properties"), []) + + # Run the processing loop in the AMQ service event loop + asyncio.run_coroutine_threadsafe(processing_loop(), otadapter.amq_service.loop) + + # Keep the program running + otadapter.thread.join() +``` + +## Configuration + +### Configuration Parameters + +The configuration file contains several key sections: + +#### AMQ Adapter Settings (`cm.amq-adapter.*`) + +- **`service-name`**: Unique identifier for your service +- **`generator-id`**: Unique ID for message generation (usually 1) +- **`route-mapping`**: RabbitMQ routing configuration +- **`require-authenticated-user`**: Whether authentication is required +- **`callbacks-enabled`**: Whether to enable callback functionality + +#### Dispatch Settings (`cm.dispatch.*`) + +- **`amq-host`**: RabbitMQ host address +- **`amq-port`**: RabbitMQ port (5672 for non-TLS, 5671 for TLS) +- **`use-dlq`**: Whether to use Dead Letter Queue +- **`download-dir`**: Directory for downloaded files + +#### Backpressure Settings (`cm.backpressure.*`) + +- **`threshold`**: Backpressure threshold value +- **`time-window`**: Time window for backpressure calculation +- **`cpu-overload-duration`**: Duration for CPU overload detection +- **`cpu-idle-duration`**: Duration for CPU idle detection + +### Route Mapping Format + +The route mapping follows this format: +``` +service-name:exchange:queue:routing-key:prefetch:durable +``` + +Example: +``` +your-service:your-exchange:your-queue-1:api.cm.dev.cleverthis.localhost.test.python.frontend.#:5:0 +``` + +## Frontend Integration + +### Key Integration Points + +1. **Adapter Initialization**: Initialize your adapter after defining all FastAPI routes +2. **Message Handling**: The adapter automatically routes AMQP messages to your endpoints +3. **Command Sending**: Use `amq_service.command()` to send commands to backend services + +### Example Integration + +```python +# In your FastAPI application +@app.post("/api/v1/process") +async def process_data(data: dict): + # Your business logic + result = {"status": "processing", "data": data} + + # Send command to backend + your_adapter.amq_service.command( + "your-service-backend", + "process_data", + **data + ) + + return result +``` + +## Backend Processing + +### Message Processing Pattern + +1. **Initialize Adapter**: Create adapter with backend configuration +2. **Wait for Connection**: Wait for RabbitMQ connection to be established +3. **Find Route**: Locate the route for your backend service +4. **Create Generator**: Create message generator for the route +5. **Process Messages**: Continuously process incoming messages + +### Example Processing + +```python +async def process_messages(): + # Wait for connection + while not adapter.amq_service.future.done(): + await asyncio.sleep(0.1) + + # Get route and generator + route = adapter.amq_service.router.find_route_by_service("your-service-backend") + generator = adapter.amq_service.data_message_generator(route) + + # Process messages + message = await generator.asend(None) + while message: + # Process the message + await handle_message(message) + message = await generator.asend(True) +``` + +## Testing and Deployment + +### Local Testing + +1. **Start RabbitMQ**: Ensure RabbitMQ is running locally +2. **Run Frontend**: Start your FastAPI application +3. **Run Backend**: Start your backend processor +4. **Test Endpoints**: Use tools like curl or Postman to test REST endpoints +5. **Monitor AMQP**: Check RabbitMQ management interface for message flow + +### Docker Deployment + +Create a `Dockerfile` for your service: + +```dockerfile +FROM python:3.9-slim + +WORKDIR /app + +COPY requirements.txt . +RUN pip install -r requirements.txt + +COPY . . + +EXPOSE 8000 + +CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"] +``` + +### Docker Compose + +Create a `docker-compose.yml` for local development: + +```yaml +version: '3.8' + +services: + rabbitmq: + image: rabbitmq:3-management + ports: + - "5672:5672" + - "15672:15672" + environment: + RABBITMQ_DEFAULT_USER: guest + RABBITMQ_DEFAULT_PASS: guest + + your-service-frontend: + build: . + ports: + - "8000:8000" + environment: + - RABBITMQ_HOST=rabbitmq + depends_on: + - rabbitmq + + your-service-backend: + build: . + command: ["python", "backend/backend_processor.py"] + environment: + - RABBITMQ_HOST=rabbitmq + depends_on: + - rabbitmq +``` + +## Advanced Features + +### Authentication + +Implement proper JWT token validation in your adapter: + +```python +async def get_current_user(self, token: str) -> User: + """ + Validate JWT token and extract user information. + """ + try: + # Decode and validate JWT token + payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"]) + user_id = payload.get("sub") + + # Fetch user from database + user = await get_user_by_id(user_id) + return user + except jwt.InvalidTokenError: + raise HTTPException(status_code=401, detail="Invalid token") +``` + +### Error Handling + +Implement comprehensive error handling: + +```python +async def handle_message(self, message: DataMessage): + """ + Handle incoming messages with proper error handling. + """ + try: + # Process message + result = await self.process_message(message) + return result + except ValidationError as e: + logging.error(f"Validation error: {e}") + # Handle validation errors + except ProcessingError as e: + logging.error(f"Processing error: {e}") + # Handle processing errors + except Exception as e: + logging.error(f"Unexpected error: {e}") + # Handle unexpected errors +``` + +### Monitoring and Logging + +Implement proper logging and monitoring: + +```python +import logging +from opentelemetry import trace, metrics + +# Configure logging +logging.basicConfig(level=logging.INFO) +logger = logging.getLogger(__name__) + +# Configure tracing +tracer = trace.get_tracer(__name__) + +# Configure metrics +meter = metrics.get_meter(__name__) +message_counter = meter.create_counter("messages_processed_total") + +async def process_message(self, message: DataMessage): + """ + Process message with tracing and metrics. + """ + with tracer.start_as_current_span("process_message"): + logger.info(f"Processing message: {message.id()}") + + # Your processing logic here + + message_counter.add(1, {"service": "your-service"}) + logger.info(f"Message processed successfully: {message.id()}") +``` + +## Troubleshooting + +### Common Issues + +1. **Connection Errors**: Ensure RabbitMQ is running and accessible +2. **Route Not Found**: Check route mapping configuration +3. **Message Not Processed**: Verify endpoint method signatures match expected parameters +4. **Authentication Failures**: Check JWT token validation logic + +### Debugging Tips + +1. **Enable Debug Logging**: Set logging level to DEBUG +2. **Check RabbitMQ Management**: Use RabbitMQ management interface to monitor queues +3. **Trace Message Flow**: Use OpenTelemetry tracing to follow message flow +4. **Validate Configuration**: Ensure all configuration parameters are correct + +## Conclusion + +This guide provides a comprehensive overview of building a Business Service using the AMQ Adapter library. By following the patterns established in the OTDemo application, you can create robust, scalable services that integrate seamlessly with the CleverMicro platform. + +For more detailed information, refer to the AMQ Adapter library documentation and the OTDemo source code examples. diff --git a/DEPLOYMENT.md b/DEPLOYMENT.md new file mode 100644 index 0000000..4feef14 --- /dev/null +++ b/DEPLOYMENT.md @@ -0,0 +1,182 @@ +# FastAPI Demo - Docker Swarm Deployment + +This guide explains how to deploy the FastAPI demo application to an existing Docker Swarm cluster. + +## Prerequisites + +- Docker Swarm cluster already running +- Docker CLI installed and configured +- Access to the swarm manager node + +## Files Created + +1. **`Dockerfile.demo`** - Docker image for the FastAPI application +2. **`docker-stack.yml`** - Docker Swarm stack configuration +3. **`prometheus.yml`** - Prometheus configuration for metrics collection +4. **`deploy-stack.sh`** - Automated deployment script + +## Quick Deployment + +### Option 1: Using the deployment script (Recommended) + +```bash +./deploy-stack.sh +``` + +This script will: +- Check if Docker is running +- Initialize Docker Swarm if needed +- Build the Docker image +- Deploy the stack +- Show service status and access URLs + +### Option 2: Manual deployment + +1. **Build the Docker image:** + ```bash + docker build -f Dockerfile.demo -t fastapi-demo:latest . + ``` + +2. **Deploy the stack:** + ```bash + docker stack deploy -c docker-stack.yml fastapi-demo + ``` + +## Services Deployed + +The stack deploys the following services: + +### 1. FastAPI Demo Application (`fastapi-demo`) +- **Ports:** 8000 (app), 8001 (metrics) +- **Image:** `fastapi-demo:latest` +- **Features:** + - FastAPI application with OpenTelemetry integration + - Prometheus metrics endpoint + - File upload functionality + - Health checks + - Resource limits and reservations + +### 2. Jaeger Tracing (Optional) +- **Ports:** 16686 (UI), 4317 (OTLP gRPC) +- **Image:** `jaegertracing/all-in-one:latest` +- **Purpose:** Distributed tracing visualization + +### 3. Prometheus Monitoring (Optional) +- **Ports:** 9090 (UI) +- **Image:** `prom/prometheus:latest` +- **Purpose:** Metrics collection and visualization + +## Access URLs + +After successful deployment: + +- **FastAPI Application:** http://localhost:8000 +- **FastAPI Documentation:** http://localhost:8000/docs +- **Prometheus Metrics:** http://localhost:8001/metrics +- **Jaeger UI:** http://localhost:16686 +- **Prometheus UI:** http://localhost:9090 + +## Configuration + +### Environment Variables + +The FastAPI demo service uses these environment variables: + +- `OTEL_EXPORTER_OTLP_ENDPOINT`: Jaeger OTLP endpoint (default: http://jaeger:4317) +- `OTEL_DEBUG_CONSOLE_TRACES`: Enable console trace output (default: false) +- `OTEL_EXPORTER_PROMETHEUS_HOST`: Prometheus metrics host (default: 0.0.0.0) +- `OTEL_EXPORTER_PROMETHEUS_PORT`: Prometheus metrics port (default: 8001) + +### Properties File + +The `otdemo/otdemo.properties` file is automatically included in the Docker image and available at the relative path `./otdemo/otdemo.properties` within the container. + +## Management Commands + +### View Stack Status +```bash +docker stack services fastapi-demo +``` + +### View Service Logs +```bash +docker service logs fastapi-demo_fastapi-demo +``` + +### Scale Services +```bash +docker service scale fastapi-demo_fastapi-demo=2 +``` + +### Update Stack +```bash +docker stack deploy -c docker-stack.yml fastapi-demo +``` + +### Remove Stack +```bash +docker stack rm fastapi-demo +``` + +## Monitoring + +### Health Checks +The FastAPI service includes health checks that verify the application is responding: +- **Endpoint:** `/docs` +- **Interval:** 30 seconds +- **Timeout:** 10 seconds +- **Retries:** 3 + +### Resource Limits +- **CPU:** 0.5 cores (limit), 0.25 cores (reservation) +- **Memory:** 512MB (limit), 256MB (reservation) + +### Metrics +The application exposes Prometheus metrics at `/metrics` including: +- `documents_uploaded_total` +- `documents_metadata_processed_total` +- `documents_retrieved_total` +- `internal_api_call_duration_seconds` + +## Troubleshooting + +### Service Not Starting +1. Check service logs: `docker service logs fastapi-demo_fastapi-demo` +2. Verify image was built: `docker images | grep fastapi-demo` +3. Check resource availability on nodes + +### Port Conflicts +If ports 8000, 8001, 16686, or 9090 are already in use, modify the `docker-stack.yml` file to use different ports. + +### Network Issues +The stack creates an overlay network `demo-network`. If you need to connect to external services, ensure they're on the same network or configure network routing appropriately. + +## Customization + +### Adding New Services +To add new services to the stack: + +1. Add the service definition to `docker-stack.yml` +2. Include it in the `demo-network` +3. Configure appropriate resource limits and health checks + +### Modifying Configuration +- **Application config:** Modify `demo.py` and rebuild the image +- **Prometheus config:** Modify `prometheus.yml` +- **Stack config:** Modify `docker-stack.yml` + +### Environment-Specific Deployments +Create environment-specific stack files: +- `docker-stack.dev.yml` +- `docker-stack.prod.yml` +- `docker-stack.staging.yml` + +## Security Considerations + +- The demo runs with minimal security for development purposes +- For production, consider: + - Using secrets for sensitive configuration + - Implementing proper authentication + - Using HTTPS/TLS + - Restricting network access + - Running with non-root user diff --git a/README.md b/README.md index 36ba7ce..9d0bc09 100644 --- a/README.md +++ b/README.md @@ -82,7 +82,7 @@ python_multipart ``` Go to amq-dapter-python repo source code, and copy the service specific directory, e.g. `/cleverswarm` -directory to your service's sources. For the CleverSwarm service, the file is `cleverswarm/clever_swarm.py`, +directory to your service's sources. For the CleverSwarm service, the file is `cleverswarm/clever_swarm.py`, and contains the AMQ Adapter to CleverSwarm service custom facade, implemented as ```python class CleverSwarmAmqpAdapter(CleverThisServiceAdapter): @@ -94,7 +94,7 @@ to instatiate and initialize the AMQ adapter, add following line to the init rou ``` and ensure that the `adapter` stays in the context of the service, so it is not garbage collected. -At version 0.2.21, AMQ Adapter uses local configuration file, relative path to which is passed +At version 0.2.21, AMQ Adapter uses local configuration file, relative path to which is passed to the AMQConfiguration constructor. This may change in the future, when the central configuration service will become available in CleverMicro, but for now please ensure correct relative path wrt the current working directory. @@ -104,8 +104,7 @@ For the config entries, please refer to the wiki page: [AMQ Adapter Config](htt The AMQ Adapter uses the following environment variables to configure the service: -PARALLEL_WORKERS - number of parallel workers to use for processing incoming requests. This is currently mandatory value, -shall be greater than 0. +MAX_AVAILABILITY - For backpressure management, indicates max capacity for processing incoming requests. If set, shall be greater than 0. AMQ_VERBOSE_LOGGING - if set to 1, the adapter will indicate in the log next to the message itself also module name, line and function name where the message was generated @@ -148,4 +147,3 @@ To remove volumes as well: ```bash docker-compose down -v ``` - diff --git a/api-doc/Makefile b/api-doc/Makefile new file mode 100644 index 0000000..d4bb2cb --- /dev/null +++ b/api-doc/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = . +BUILDDIR = _build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/api-doc/README.md b/api-doc/README.md new file mode 100644 index 0000000..9f0153a --- /dev/null +++ b/api-doc/README.md @@ -0,0 +1,51 @@ +# AMQ Adapter Python API Documentation + +This directory contains the generated HTML API documentation for the AMQ Adapter Python library. + +## Viewing the Documentation + +1. **Open the main page**: Open `_build/html/index.html` in your web browser +2. **Browse modules**: Use the navigation menu to explore different modules: + - **Configuration** (`amqp.config`) - Configuration classes and settings + - **Adapter** (`amqp.adapter`) - Core adapter classes and utilities + - **Service** (`amqp.service`) - Service layer and message handling + - **Router** (`amqp.router`) - Routing and service discovery + - **Model** (`amqp.model`) - Data models and message structures + - **RabbitMQ** (`amqp.rabbitmq`) - RabbitMQ client implementations + +## Features + +- **Search functionality**: Use the search box to find specific classes, methods, or functions +- **Module index**: Browse all modules alphabetically +- **Class inheritance**: View class hierarchies and inheritance relationships +- **Source code**: Click "View page source" to see the actual Python code +- **Cross-references**: Navigate between related classes and methods + +## Rebuilding the Documentation + +To regenerate the documentation after code changes: + +```bash +cd api-doc +make html +``` + +## Documentation Structure + +The documentation is organized by module: + +- **amqp.config**: Configuration management and settings +- **amqp.adapter**: Core adapter functionality and service integration +- **amqp.service**: Service layer, message handling, and tracing +- **amqp.router**: Routing, service discovery, and queue management +- **amqp.model**: Data models, message structures, and serialization +- **amqp.rabbitmq**: RabbitMQ client implementations and utilities + +## Key Classes + +- `CleverThisServiceAdapter`: Base class for service adapters +- `AMQService`: Main service class for AMQP operations +- `AMQConfiguration`: Configuration management +- `DataMessage`: Message structure for AMQP communication +- `RouterConsumer`: Service discovery and routing +- `RabbitMQClient`: RabbitMQ connection management diff --git a/api-doc/_build/doctrees/environment.pickle b/api-doc/_build/doctrees/environment.pickle new file mode 100644 index 0000000000000000000000000000000000000000..f4d2aaea4002cec7c7a7fadbee8a431eb704f0d3 GIT binary patch literal 576168 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 literal 0 HcmV?d00001 diff --git a/api-doc/_build/doctrees/index.doctree b/api-doc/_build/doctrees/index.doctree new file mode 100644 index 0000000000000000000000000000000000000000..56064c1a00bf50f2fcbe15a8b29413d0759531b4 GIT binary patch literal 5238 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
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.adapter.amq_route_factory
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.adapter.amq_route_factory

+from amqp.adapter.logging_utils import logging_error
+from amqp.model.model import AMQRoute
+
+# record separator
+RS = ":"
+# null route, in lieu of None value
+NULL_ROUTE = {
+    "componentName": "",
+    "exchange": None,
+    "queue": None,
+    "routingKey": "#",
+    "timeout": 1,
+    "validUntil": 0,
+}
+
+
+

+[docs]
+class AMQRouteFactory:
+    """
+    Define the methods to create and validate AMQRoute objects.
+    """
+
+

+[docs]
+    @staticmethod
+    def from_string(data):
+        """
+        Builds the AMQRoute from its string form.
+        :param data: route string
+        :return: AMQRoute object
+        """
+        try:
+            _keys = data.split(RS)
+            if len(_keys) >= 5:
+                _i = 0
+                _component_name = _keys[_i]
+                _i += 1
+                _exchange = _keys[_i]
+                _i += 1
+                _queue = _keys[_i] if _i < len(_keys) else ""
+                _i += 1
+                _routing_key = _keys[_i] if _i < len(_keys) else ""
+                _i += 1
+                _timeout = int(_keys[_i]) if _i < len(_keys) else 0
+                _i += 1
+                _valid_until = int(_keys[_i]) if _i < len(_keys) else 0
+                return AMQRoute(
+                    component_name=_component_name,
+                    exchange=_exchange,
+                    queue=_queue,
+                    key=_routing_key,
+                    timeout=_timeout,
+                    valid_until=_valid_until,
+                )
+            logging_error(
+                "AMQRoute incorrect format. AMQRoute expects input as: "
+                "'Component-Name:AMQExchange-Name:Queue-Name:Routing-Key:Timeout:Valid-Until', "
+                "got: ['%s']",
+                data,
+            )
+        except Exception as err:
+            logging_error(
+                "%s: AMQRoute incorrect format. AMQRoute expects input as: "
+                "'Component-Name:AMQExchange-Name:Queue-Name:Routing-Key:Timeout:Valid-Until', "
+                "got: ['%s']",
+                err,
+                data,
+            )
+        return NULL_ROUTE

+
+
+

+[docs]
+    @staticmethod
+    def validate(route_str):
+        """
+        Validates the route string.
+        :param route_str: route string
+        :return: boolean validity indicator
+        """
+        if route_str is not None:
+            return route_str.count(":") > 4
+        return False

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/backpressure_handler.html b/api-doc/_build/html/_modules/amqp/adapter/backpressure_handler.html new file mode 100644 index 0000000..b29f3b2 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/backpressure_handler.html @@ -0,0 +1,466 @@ + + + + + + + + amqp.adapter.backpressure_handler — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.adapter.backpressure_handler
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.adapter.backpressure_handler

+import asyncio
+import json
+import time
+from asyncio import AbstractEventLoop
+from threading import Thread
+from typing import Optional
+
+from aio_pika import Message
+from aio_pika.abc import AbstractRobustChannel
+
+from amqp.adapter.logging_utils import logging_info, logging_warning
+from amqp.config.amq_configuration import AMQConfiguration
+from amqp.model.model import ScalingRequestAlert
+from amqp.router.utils import await_future, await_result
+
+
+

+[docs]
+class ScaleRequestV1:
+
+

+[docs]
+    def __init__(
+        self,
+        serviceId: str,
+        taskId: str,
+        max_availability: int,
+        current_availability: int,
+        requestType: ScalingRequestAlert,
+    ):
+        self.version = 1  # Version of the request, currently 1
+        self.serviceId = serviceId
+        self.taskId = taskId
+        self.max_availability = max_availability
+        self.current_availability = current_availability
+        self.requestType = requestType
+        self.thread = None

+
+
+

+[docs]
+    def to_json(self) -> str:
+        """Converts the object to a JSON string matching the Java structure"""
+        return json.dumps(
+            {
+                "version": self.version,
+                "serviceId": self.serviceId,
+                "taskId": self.taskId,
+                "maxAvailability": self.max_availability,
+                "currentAvailability": self.current_availability,
+                "requestType": self.requestType.value,  # Using .value for Enum serialization
+            },
+            indent=2,
+        )

+

+
+
+
+

+[docs]
+class BackpressureHandler:
+    # Track the number of messages currently being processed
+    current_availability = 0
+    # helps detect IDLE condition
+    # helps prevent flooding the system with backpressure events
+    last_backpressure_event_time = 0
+    last_backpressure_event = ScalingRequestAlert.UPDATE
+    # _callback_list is used in unit tests to record the invoked callbacks
+    _callback_list = None
+
+

+[docs]
+    def __init__(
+        self,
+        channel: AbstractRobustChannel,
+        loop: AbstractEventLoop,
+        config: AMQConfiguration,
+    ):
+        self.lock = None
+        self.channel = channel
+        self.loop = loop
+        self.config = config
+        self.exchange = None
+        self.swarm_service_id = self.config.amq_adapter.swarm_service_id
+        self.swarm_task_id = self.config.amq_adapter.swarm_task_id
+        self.do_loop = -1
+        self._resource_usage_changed = 0
+        self._resource_average_value = 0
+        self._last_resource_max_value = 100  # Default max value for CPU usage
+        self.max_availability = -1
+        self.current_availability = 1
+        self.max_load = 1
+        self.current_load = 0
+        self.idle_state_detected_time = 0

+
+
+

+[docs]
+    def increase_current_load(self):
+        """Increase the number of parallel executions, or current_availability load"""
+        logging_info(
+            "Backpressure: Increase current load (%s) by 1",
+            self.current_load,
+        )
+        self.current_load += 1

+
+
+

+[docs]
+    def decrease_current_load(self):
+        """Decrease the number of parallel executions, or current load"""
+        logging_info(
+            "Backpressure: Decrease current load(%s) by 1",
+            self.current_load,
+        )
+        if self.current_load > 0:
+            self.current_load -= 1

+
+
+

+[docs]
+    def update_current_availability(self, count: int):
+        """Update the number of parallel executions, or current load"""
+        self.current_availability = count

+
+
+

+[docs]
+    def update_last_backpressure_event_time(self):
+        # logging_info("Backpressure: Update last data message time")
+        """Update the last data message time"""
+        self.last_backpressure_event_time = time.time()

+
+
+

+[docs]
+    async def update_backpressure_value(self, current_availability: int, maximum: int):
+        """
+        Update the current backpressure value and check for overload conditions.
+        This method is called by the AMQService.backpressure() method to update
+        the current parallel executions count and check for overload conditions.
+
+        Args:
+            current_availability: Current value of the backpressure metric
+            maximum: Maximum value of the backpressure metric
+        """
+        logging_info(
+            "Backpressure: Updating backpressure value, current_availability=%s, maximum=%s",
+            current_availability,
+            maximum,
+        )
+        if maximum > 0 and maximum > self.max_availability:
+            self.max_availability = maximum
+        # Update the current_availability / parallel executions count
+        self.update_current_availability(current_availability)
+        # Check for overload conditions
+        await self.check_overload_condition()

+
+
+

+[docs]
+    def start_backpressure_monitor(self) -> Optional[Thread]:
+        # Start the Backpressure monitor loop
+        self.thread = Thread(target=self.backpressure_monitor_loop)
+        self.thread.daemon = True  # This makes it a daemon thread
+        self.thread.start()
+        return self.thread

+
+
+

+[docs]
+    async def check_overload_condition(self):
+        """
+        Check if the current_availability availability is too low (OVERLOAD)
+        or if the service has been idle for too long with high availability (IDLE).
+
+        Note: current_availability represents available capacity, not used capacity.
+        - Low availability (close to 0) means OVERLOAD
+        - High availability (close to maximum) with no activity means IDLE
+        """
+        current_time = time.time()
+        last_event_delta: float = current_time - self.last_backpressure_event_time
+
+        # logging_info(
+        #    "Backpressure: Check conditions, current_availability=%s, max=%s, last_activity=%s",
+        #    self.current_availability,
+        #    self.max_availability,
+        #    last_event_delta,
+        # )
+
+        # Check for OVERLOAD condition - low availability (less than 20% of maximum)
+        if self.current_availability <= round(0.1 * self.max_availability):
+            # Check if the last backpressure event was not an overload
+            if (
+                self.last_backpressure_event != ScalingRequestAlert.OVERLOAD
+                or last_event_delta > self.config.backpressure.idle_duration
+            ):
+                # Trigger the overload event
+                await self.handle_backpressure_overload_event()
+                # update / reset time-window so that the OVERLOAD is not sent too often
+                self.last_backpressure_event_time = current_time
+                self.last_backpressure_event = ScalingRequestAlert.OVERLOAD
+
+        # Check for IDLE condition - high availability (more than 80% of maximum) with no activity
+        elif self.current_availability >= round(0.8 * self.max_availability):
+            idle_duration = self.config.backpressure.idle_duration
+            # Check if service has been idle for longer than the configured duration
+            if (
+                current_time - self.idle_state_detected_time > idle_duration
+                and self.last_backpressure_event == ScalingRequestAlert.IDLE
+            ):
+                logging_info(
+                    "Backpressure: Service has been idle for %s seconds (threshold: %s seconds)",
+                    last_event_delta,
+                    idle_duration,
+                )
+
+                # Trigger the idle event
+                await self._handle_backpressure_idle_event()
+                # update / reset time-window so that the IDLE is not sent too often
+                self.last_backpressure_event_time = current_time
+                self.idle_state_detected_time = current_time
+                # send IDLE even only once
+                self.last_backpressure_event = ScalingRequestAlert.UPDATE
+            else:
+                # Don't send IDLE right away when the availability increases, but wait for a while, send UPDATE instead
+                self.last_backpressure_event = ScalingRequestAlert.IDLE
+                if current_time - self.idle_state_detected_time > idle_duration:
+                    self.idle_state_detected_time = current_time
+                if last_event_delta > self.config.backpressure.time_window:
+                    _scaling_request: ScaleRequestV1 = ScaleRequestV1(
+                        self.swarm_service_id,
+                        self.swarm_task_id,
+                        self.max_availability,
+                        self.current_availability,  # Current availability is passed directly
+                        ScalingRequestAlert.UPDATE,
+                    )
+                    # Address the message to any adapter capable of supporting BACKPRESSURE request
+                    await self.publish_backpressure_request(_scaling_request)
+                    self.last_backpressure_event_time = current_time
+
+        # If neither OVERLOAD nor IDLE, and it's time for an update, send UPDATE event
+        elif last_event_delta > self.config.backpressure.time_window:
+            _scaling_request: ScaleRequestV1 = ScaleRequestV1(
+                self.swarm_service_id,
+                self.swarm_task_id,
+                self.max_availability,
+                self.current_availability,  # Current availability is passed directly
+                ScalingRequestAlert.UPDATE,
+            )
+            # Address the message to any adapter capable of supporting BACKPRESSURE request
+            await self.publish_backpressure_request(_scaling_request)
+            self.last_backpressure_event_time = current_time
+            self.last_backpressure_event = ScalingRequestAlert.UPDATE

+
+
+    async def _backpressure_monitor(self):
+        """Periodically monitor the backpressure conditions and trigger events accordingly"""
+        _monitor_interval = 0.5  # Monitor every 500ms
+        while self._do_loop():
+            await self.check_overload_condition()
+            await asyncio.sleep(_monitor_interval)
+
+

+[docs]
+    def backpressure_monitor_loop(self):
+        _loop = asyncio.new_event_loop()
+        _loop.run_until_complete(self._backpressure_monitor())

+
+
+

+[docs]
+    async def handle_backpressure_overload_event(self):
+        logging_warning("Backpressure: Capacity close to depleted!")
+        # Send an Overload event to the Management service
+        scaling_request: ScaleRequestV1 = ScaleRequestV1(
+            self.swarm_service_id,
+            self.swarm_task_id,
+            self.max_availability,
+            self.current_availability,  # Current availability is passed directly
+            ScalingRequestAlert.OVERLOAD,
+        )
+        # Address the message to any management service instance capable of supporting BACKPRESSURE request
+        await self.publish_backpressure_request(scaling_request)

+
+
+    async def _handle_backpressure_idle_event(self):
+        logging_warning("Backpressure: Service is idle.")
+        # Send an Idle event to the Management service
+        scaling_request: ScaleRequestV1 = ScaleRequestV1(
+            self.swarm_service_id,
+            self.swarm_task_id,
+            self.max_availability,
+            self.current_availability,  # Current availability is passed directly
+            ScalingRequestAlert.IDLE,
+        )
+        # Address the message to any adapter capable of supporting BACKPRESSURE request
+        await self.publish_backpressure_request(scaling_request)
+
+

+[docs]
+    async def publish_backpressure_request(self, scaling_request: ScaleRequestV1):
+        # Publish the backpressure request to the management service
+        logging_info(
+            f"Publishing backpressure for {scaling_request.serviceId} with request type {scaling_request.requestType}"
+        )
+        if not self.exchange:
+
+            async def _wrap_rabbit_mq_api_init(channel):
+                _exchange = await channel.get_exchange(name="cleverthis.clevermicro.management")
+                return _exchange
+
+            if BackpressureHandler._callback_list is not None:
+                BackpressureHandler._callback_list["_wrap_rabbit_mq_api_init"] = 1
+            self.exchange = await await_result(
+                asyncio.run_coroutine_threadsafe(_wrap_rabbit_mq_api_init(self.channel), self.loop)
+            )
+
+        if self.exchange:
+
+            async def _wrap_rabbit_mq_api():
+                if not self.channel.is_closed:
+                    binary_content: bytes = scaling_request.to_json().encode("utf-8")
+                    pika_message: Message = Message(
+                        body=binary_content,
+                        content_encoding="utf-8",
+                        delivery_mode=2,
+                        content_type="application/octet-stream",
+                        headers=None,
+                        priority=0,
+                        correlation_id=None,
+                    )
+                    await self.exchange.publish(
+                        message=pika_message, routing_key="backpressure-scaling-v1"
+                    )
+                    logging_info(
+                        "Service Message Published to %s, msg: %s",
+                        self.exchange.name,
+                        str(binary_content),
+                    )
+                    return True
+                return False
+
+            if BackpressureHandler._callback_list is not None:
+                BackpressureHandler._callback_list["_wrap_rabbit_mq_api"] = 1
+            await await_future(asyncio.run_coroutine_threadsafe(_wrap_rabbit_mq_api(), self.loop))

+
+
+    def _do_loop(self) -> bool:
+        """
+        Helper function for unit tests to perform several loops only. Check if the loop should continue running.
+        Positive value of do_loop indicates the number of iterations left.
+        Negative value indicates the loop should run indefinitely.
+        """
+        _val = self.do_loop != 0
+        if self.do_loop > 0:
+            self.do_loop -= 1
+        return _val

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/cleverthis_service_adapter.html b/api-doc/_build/html/_modules/amqp/adapter/cleverthis_service_adapter.html new file mode 100644 index 0000000..26e3179 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/cleverthis_service_adapter.html @@ -0,0 +1,948 @@ + + + + + + + + amqp.adapter.cleverthis_service_adapter — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.adapter.cleverthis_service_adapter
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.adapter.cleverthis_service_adapter

+"""
+The layer that interfaces with the CleverThis service that this Adapter is integrating with.
+Methods here will invoke the actual CleverThis Service code, which are passed as Callable object.
+"""
+
+import asyncio
+import enum
+import inspect
+import json
+import pathlib
+import re
+from asyncio import AbstractEventLoop
+from collections import defaultdict
+from typing import Any, Callable, Coroutine, Dict, List
+
+from aio_pika.abc import (
+    AbstractExchange,
+    AbstractRobustChannel,
+    AbstractRobustConnection,
+)
+from aiohttp import ClientResponse, ClientSession
+from fastapi import HTTPException, UploadFile
+from fastapi.params import File
+from fastapi.routing import APIRoute
+from fastapi.security import OAuth2PasswordRequestForm
+from pydantic import BaseModel
+from starlette.datastructures import Headers
+from starlette.responses import FileResponse
+
+from amqp.adapter import serializer
+from amqp.adapter.data_parser import AMQDataParser
+from amqp.adapter.data_response_factory import DataResponseFactory
+from amqp.adapter.file_handler import FileHandler, StreamingFileHandler
+from amqp.adapter.logging_utils import (
+    logging_debug,
+    logging_error,
+    logging_info,
+    logging_warning,
+)
+from amqp.adapter.pydantic_serializer import python_type_to_json
+from amqp.adapter.type_descriptor import TypeDescriptor
+from amqp.config.amq_configuration import AMQConfiguration
+from amqp.model.model import AMQErrorMessage, AMQMessage, DataMessage, DataResponse
+from amqp.router.router_base import AMQ_REPLY_TO_EXCHANGE
+from amqp.router.utils import await_result
+
+g_extra_init_data: dict = dict()
+
+
+async def _create_reply_exchange_and_queue(
+    connection: AbstractRobustConnection,
+) -> tuple[AbstractRobustChannel, AbstractExchange, str]:
+    """
+    Create objects for reply.
+    Return (channel for reply queue, exchange for reply, reply queue name)
+    """
+
+    # Wrap calls to RabbitMQ API to make it Awaitable, so it can be run thread-safe with
+    # correct event loop. This is needed because the RabbitMQ API is not thread-safe and needs
+    # to be called in the context of event loop the first RabbitMQ connection was created with.
+    _channel = await connection.channel()
+    _exchange_name: str = AMQ_REPLY_TO_EXCHANGE
+    _exchange = await _channel.get_exchange(name=_exchange_name, ensure=True)
+    _queue = await _channel.declare_queue(exclusive=False)  # Declare a unique, non-exclusive queue
+    _queue_name = _queue.name
+    await _queue.bind(
+        exchange=_exchange_name,
+        routing_key=_queue_name,  # Use queue name as routing key
+    )
+    logging_debug(f"Publishing to exchange: {_exchange_name}, q: {_queue_name}")
+    return _channel, _exchange, _queue_name
+
+
+async def _convert_file_response(
+    obj: FileResponse,
+    connection: AbstractRobustConnection,
+    file_handler: FileHandler,
+    loop: AbstractEventLoop | None,
+) -> str:
+    """
+    Converts a FileResponse object to a JSON string containing the filename and stream name.
+    The file content itself is transmitted through the named stream (which is implemented as
+    temporary dedicated queue.
+    """
+    # All calls to RabbitMQ API have to be called threadsafe, because those appear to be attached
+    # to parent event loop, and need to execute at that event loop, not the current_availability one
+    # allow coroutine to execute. calling _future.result() will block the entire thread
+    # and the coroutine will never execute
+    _channel, _exchange, _routing_key = await await_result(
+        asyncio.run_coroutine_threadsafe(_create_reply_exchange_and_queue(connection), loop)
+    )
+    # publish_file also needs RabbitMQ API, ensure the loop is passed as argument
+    (_stream_name, _file_size) = await file_handler.publish_file(
+        _exchange, obj.path, _routing_key, loop
+    )
+    # as above, but luckily this time we don't need to wait for the result
+    asyncio.run_coroutine_threadsafe(_channel.close(), loop)
+    return json.dumps(
+        {
+            "files": [
+                {
+                    "filename": obj.filename,
+                    "mediaType": "application/octet-stream",
+                    "streamName": _stream_name,
+                    "fileSize": _file_size,
+                }
+            ]
+        }
+    )
+
+
+

+[docs]
+def is_likely_json(text: str) -> bool:
+    """Quick test to see if should convert the response string to JSON format."""
+    if not isinstance(text, str):
+        return False
+    _text = text.strip()
+    return (_text.startswith("{") and _text.endswith("}")) or (
+        _text.startswith("[") and _text.endswith("]")
+    )

+
+
+
+# =============  CleverThisServiceAdapter =============
+

+[docs]
+class CleverThisServiceAdapter:
+    """
+    A base class for CleverThis service adapter that handles the incoming AMQP messages and routes
+    them to the appropriate CleverThisService API endpoint.
+    IMPORTANT: This class is not intended to be used directly. It should be subclassed for
+    each CleverThis service and override the methods to handle the specific API calls.
+    """
+
+

+[docs]
+    def __init__(
+        self,
+        amq_configuration: AMQConfiguration,
+        routes: List[APIRoute],
+        session: ClientSession = None,
+        authenticated_user_arg_name: str = "authenticated_user",
+        extra_init_data=None,
+    ):
+        """
+        Initializes the CleverThisServiceAdapter with the given AMQ configuration and optional HTTP
+        session. The HTTP session is for the case when the adapter uses loose coupling with
+        the CleverThis service via HTTP REST API.
+        """
+        if extra_init_data is None:
+            extra_init_data = dict()
+        self.authenticated_user_arg_name = authenticated_user_arg_name
+        self.amq_configuration = amq_configuration
+        self.session = session
+        self.service_host = self.amq_configuration.dispatch.service_host
+        self.service_port = self.amq_configuration.dispatch.service_port
+        self.loop: AbstractEventLoop | None = None
+        self.require_authenticated_user = (
+            self.amq_configuration.amq_adapter.require_authenticated_user
+        )
+        self.routes = self.group_routes_by_method(api_routes=routes)
+        global g_extra_init_data
+        g_extra_init_data = extra_init_data or {}

+
+
+

+[docs]
+    def get_endpoint(self, endpoint: Any) -> Any:
+        """
+        Optionally, Service can override this method to alter the endpoint mapping.
+        This is useful for example when the CleverThis service has a JSON wrapper
+        around the endpoint, like CleverSwarm, which might be the preferred endpoint to call.
+
+        :param endpoint: The original endpoint to be called.
+        :return: The actual endpoint to be called.
+        """
+        return endpoint

+
+
+

+[docs]
+    def clone_and_adapt_route(self, original_route: APIRoute) -> APIRoute:
+        """
+        Creates a clone of APIRoute. Checks if there's preferred endpoint with json serialization.
+        It also adjusts the path regex to ensure it matches the path in different API versions.
+        """
+
+        # Need to adapt also the path regex to ensure it matches the path in different API versions
+        # Ensures the leading '^' is followed by any match and there's no '/' before final '$'
+        _new_regex_string = "^.*" + original_route.path_regex.pattern.lstrip("^").rstrip("/$") + "$"
+        _new_route: APIRoute = APIRoute(
+            path=original_route.path,
+            endpoint=self.get_endpoint(
+                original_route.endpoint
+            ),  # Service can alter the endpoint mapping here
+            response_model=original_route.response_model,
+            status_code=original_route.status_code,
+            tags=original_route.tags.copy() if original_route.tags else None,
+            dependencies=(
+                original_route.dependencies.copy() if original_route.dependencies else None
+            ),
+            summary=original_route.summary,
+            description=original_route.description,
+            response_description=original_route.response_description,
+            responses=(original_route.responses.copy() if original_route.responses else None),
+            deprecated=original_route.deprecated,
+            name=original_route.name,
+            methods=original_route.methods.copy() if original_route.methods else None,
+            operation_id=original_route.operation_id,
+            response_model_include=original_route.response_model_include,
+            response_model_exclude=original_route.response_model_exclude,
+            response_model_by_alias=original_route.response_model_by_alias,
+            response_model_exclude_unset=original_route.response_model_exclude_unset,
+            response_model_exclude_defaults=original_route.response_model_exclude_defaults,
+            response_model_exclude_none=original_route.response_model_exclude_none,
+            include_in_schema=original_route.include_in_schema,
+            response_class=original_route.response_class,
+            dependency_overrides_provider=original_route.dependency_overrides_provider,
+            callbacks=(original_route.callbacks.copy() if original_route.callbacks else None),
+            openapi_extra=(
+                original_route.openapi_extra.copy() if original_route.openapi_extra else None
+            ),
+            generate_unique_id_function=original_route.generate_unique_id_function,
+        )
+        _new_route.path_regex = re.compile(_new_regex_string)
+        return _new_route

+
+
+

+[docs]
+    def group_routes_by_method(self, api_routes: List[APIRoute]) -> Dict[str, List[APIRoute]]:
+        """
+        Groups API routes by their HTTP method. This is important to ensure that URLPath is matched
+        correctly, as different methods may share the same URLPath (e.g. GET, POST PUT, DELETE).
+        """
+        _method_to_routes = defaultdict(list)  # Automatically initializes new lists for new keys
+        for _route in api_routes:
+            if (
+                isinstance(_route, APIRoute) and _route.methods
+            ):  # Ensure methods exist (should always be true for valid routes)
+                for method in _route.methods:
+                    _method_to_routes[method].append(self.clone_and_adapt_route(_route))
+
+        return dict(_method_to_routes)

+
+
+

+[docs]
+    def get_content_type(self, message_headers: Dict[str, List[str]]) -> str:
+        """
+        Pull the value of the Content-Type header from the message headers.
+        :param message_headers: The headers of the message.
+        return: The content type of the message.
+        """
+        for header, values in message_headers.items():
+            if header.lower() == "content-type":
+                return values[0].split(";")[0]
+        return "application/json"

+
+
+

+[docs]
+    async def get_current_user(self, token: str) -> object:
+        """
+        To Be Overriden in subclass for given CleverThis Service, to return the current_availability user based
+        on the token, in format appropriate for the service.
+
+        :param token: The token to be used for authentication.
+
+        :return: A user object or None if the user is not authenticated.
+        """
+        return None

+
+
+

+[docs]
+    async def on_message(self, message: AMQMessage) -> DataResponse:
+        """
+        Called when a message is received from the AMQP.
+        :param message:
+        :return: AMQP response class with operation status code and optional error details.
+        """
+        _auth_user: Any | None = None
+        _amq_response: Any | None = None
+
+        logging_debug(f"on_message: require_authenticated_user={self.require_authenticated_user}")
+        if self.require_authenticated_user:
+            _auth: str = message.headers().get("Authorization", "")
+            logging_debug(f"Auth: {_auth}")
+            if isinstance(_auth, List):
+                _auth = _auth[0]
+            if "Bearer" in _auth:
+                try:
+                    token = _auth.split(" ")[1]
+                    logging_info(f"Token: {token}")
+                    _auth_user = await self.get_current_user(token)
+                except Exception as error:
+                    logging_error(f"on_message: Error getting user: {error}")
+
+        if _auth_user or not self.require_authenticated_user or message.path().endswith("/login"):
+            method = message.method().lower()
+            if method == "get":
+                _amq_response = await self.get(message, _auth_user)
+            elif method == "put":
+                _amq_response = await self.put(message, _auth_user)
+            elif method == "post":
+                _amq_response = await self.post(message, _auth_user)
+            elif method == "head":
+                _amq_response = await self.head(message, _auth_user)
+            elif method == "delete":
+                _amq_response = await self.delete(message, _auth_user)
+            else:
+                raise ValueError(f"Unexpected HTTP method: {message.method()}")
+        else:
+            _amq_response = DataResponseFactory.of_error_message(
+                message.id(),
+                AMQErrorMessage(401, "Unauthorized", "Unauthorized"),
+                message.trace_info(),
+            )
+        logging_info(
+            f"ALL DONE in on_message id:{message.id()}, resp code:{_amq_response.response_code()}"
+        )
+        return _amq_response

+
+
+    async def _authorize_forward_request(
+        self, message: DataMessage, request_coroutine, auth_user: Any
+    ) -> DataResponse:
+        """
+        This method is used to authorize the request and forward it to the CleverThis Service API.
+        Used only for loose / 3rd party mode of coupling with the Service
+        """
+        # AMQDataParser.parse_request_body(message)
+        # TODO: implement authorization logic here - ensure the security related headers are set
+        # This depends on what kind of security is required by the CleverThis service.
+        # However at this time there is no loosely coupled Service.
+
+        return await request_coroutine
+
+    # ==============================================================================================
+    # =====================  C l e v e r T h i s    A P I    m e t h o d s  ========================
+    # ==============================================================================================
+
+

+[docs]
+    async def get(self, message: AMQMessage, auth_user: Any) -> DataResponse:
+        """
+        Handles the GET requests for the CleverThis API. In tight coupling (self.session is None),
+        use path, path params and query string to determine the endpoint method to invoke.
+        In loose coupling (self.session is not None), forward the request as REST request using
+        the session, i.e. attempt to call the REST endpoint directly using HTTP protocol.
+
+        :param message: message from the AMQP that contains the GET request
+        :param auth_user: user authenticated by the API Gateway, as UserSchem
+
+        :return: DataResponse to be sent back to the API Gateway via AMQP
+        """
+
+        if self.session is None:
+            return await self.handle_no_body_payload(message, auth_user, "GET")
+
+        # Forwards as REST - try to invoke the service directly on this path
+        url = f"http://{self.service_host}:{self.service_port}{message.path()}"
+        headers = {**message.headers(), **message.trace_info()}
+        logging_info(
+            f"SEND HEADERS out: {', '.join(f'{k}={v}' for k, v in headers.items())}, REQ={url}"
+        )
+        _http_resp: ClientResponse = await self.session.get(url, headers=headers)
+        return DataResponseFactory.of(
+            message.id(),
+            _http_resp.status,
+            _http_resp.content_type,
+            await _http_resp.read(),
+            message.trace_info(),
+        )

+
+
+

+[docs]
+    async def put(self, message: AMQMessage, auth_user: Any) -> DataResponse:
+        """
+        Handles the PUT requests for the CleverThis API. Uses path, path params, query string and
+        body payload to determine the endpoint method to invoke and its input arguments
+        In loose coupling (self.session is not None), attempt to call the REST endpoint directly
+        using HTTP protocol.
+
+        :param message: message from the AMQP that contains the PUT request
+        :param auth_user: user authenticated by the API Gateway, as UserSchem
+
+        :return: DataResponse to be sent back to the API Gateway via AMQP
+        """
+        if self.session is None:
+            return await self.handle_body_payload(message, auth_user, "PUT")
+
+        # Forwards as REST - try to invoke the service directly on this path
+        return await self._authorize_forward_request(
+            message,
+            self.session.put(
+                f"http://{self.service_host}:{self.service_port}{message.path()}",
+                data=message.body(),
+                headers={**message.headers(), **message.trace_info()},
+            ),
+            auth_user,
+        )

+
+
+

+[docs]
+    async def post(self, message: AMQMessage, auth_user: Any) -> DataResponse:
+        """
+        Handles the POST requests for the CleverThis API. Uses path, path params, query string and
+        body payload to determine the endpoint method to invoke and its input arguments
+        In loose coupling (self.session is not None), attempt to call the REST endpoint directly
+        using HTTP protocol.
+
+        :param message: message from AMQP that contains the POST request, including body and headers
+        :param auth_user: user authenticated by the API Gateway, as UserSchem
+
+        :return: DataResponse to be sent back to the API Gateway via AMQP
+        """
+        if self.session is None:
+            return await self.handle_body_payload(message, auth_user, "POST")
+
+        return await self._authorize_forward_request(
+            message,
+            self.session.post(
+                f"http://{self.service_host}:{self.service_port}{message.path()}",
+                data=message.body(),
+                headers={**message.headers(), **message.trace_info()},
+            ),
+            auth_user,
+        )

+
+
+

+[docs]
+    async def head(self, message: AMQMessage, auth_user: Any) -> DataResponse:
+        """
+        Handles the HEAD requests for the CleverThis API. In tight coupling (self.session is None),
+        use path, path params and query string to determine the endpoint method to invoke.
+        In loose coupling (self.session is not None), HEAD call is not supported.
+
+        :param message: message from AMQP containing the HEAD request, including body and headers
+        :param auth_user: user authenticated by the API Gateway, as UserSchema
+
+        :return: DataResponse to be sent back to the API Gateway via AMQP
+        """
+        if self.session is None:
+            return await self.handle_no_body_payload(message, auth_user, "HEAD")
+
+        raise NotImplementedError

+
+
+

+[docs]
+    async def delete(self, message: AMQMessage, auth_user: Any) -> DataResponse:
+        """
+        Handles the DELETE requests for the CleverThis API.
+
+        :param message: message from AMQP that contains the DELETE request, including body & headers
+        :param auth_user: user authenticated by the API Gateway, as UserSchema
+
+        :return: DataResponse to be sent back to the API Gateway via AMQP
+        """
+        if self.session is None:
+            return await self.handle_no_body_payload(message, auth_user, "DELETE")
+
+        return await self._authorize_forward_request(
+            message,
+            self.session.post(
+                f"http://{self.service_host}:{self.service_port}{message.path()}",
+                data=message.body(),
+                headers={**message.headers(), **message.trace_info()},
+            ),
+            auth_user,
+        )

+
+
+

+[docs]
+    async def options(self, message: AMQMessage, auth_user: Any) -> DataResponse:
+        """
+        Handles the OPTIONS requests. In tight coupling (self.session is None),
+        use path, path params and query string to determine the endpoint method to invoke.
+        In loose coupling (self.session is not None), forward the request as REST request using
+        the session, i.e. attempt to call the REST endpoint directly using HTTP protocol.
+
+        :param message: message from AMQP that contains the OPTIONS request, including headers
+        :param auth_user: user authenticated by the API Gateway, as UserSchema
+
+        :return: DataResponse to be sent back to the API Gateway via AMQP
+        """
+        if self.session is None:
+            return await self.handle_no_body_payload(message, auth_user, "OPTIONS")
+
+        raise NotImplementedError

+
+
+

+[docs]
+    async def patch(self, message: AMQMessage, auth_user: Any) -> DataResponse:
+        """
+        Handles the PATCH requests for the CleverBRAG API.
+
+        :param message: message from AMQP that contains the PATCH request, including body & headers
+        :param auth_user: user authenticated by the API Gateway, as UserSchema
+
+        :return: DataResponse to be sent back to the API Gateway via AMQP
+        """
+        if self.session is None:
+            return await self.handle_no_body_payload(message, auth_user, "PATCH")
+
+        return await self._authorize_forward_request(
+            message,
+            self.session.post(
+                f"http://{self.service_host}:{self.service_port}{message.path()}",
+                data=message.body(),
+                headers={**message.headers(), **message.trace_info()},
+            ),
+            auth_user,
+        )

+
+
+    # ==============================================================================================
+    # =================  C l e v e r S w a r m   p a y l o a d   h a n d l e r s  ==================
+    # ==============================================================================================
+
+

+[docs]
+    async def handle_no_body_payload(
+        self, message: AMQMessage, auth_user: Any, method: str
+    ) -> DataResponse:
+        """
+        Handles the requests that do not have a body payload.
+        :param message: message from the AMQP that contains the request
+        :param auth_user: user authenticated by the API Gateway, as UserSchem
+        :return: DataResponse to be sent back to the API Gateway via AMQP
+        """
+        _routes = self.routes.get(method, [])
+        _path, _args = AMQDataParser.parse_get_url(message.path())
+        for _route in _routes:
+            # TODO: here the regex will match with path prefix,
+            #  but it might not be a stable feature that we could rely on.
+            #  Need to figure out something stable for the prefix path.
+            _match = _route.path_regex.match(_path)
+            if _match:
+                _args.update(_match.groupdict())
+                _signature_args = inspect.signature(_route.endpoint).parameters
+                if self.authenticated_user_arg_name in _signature_args.keys():
+                    _args[self.authenticated_user_arg_name] = auth_user
+                # If the path matches, call the corresponding function
+                return await self.call_cleverthis_api(
+                    message,
+                    _args,
+                    api_method=_route.endpoint,
+                    success_code=_route.status_code,
+                )
+
+        return DataResponseFactory.of(
+            message.id(),
+            404,
+            "text/plain",
+            str(f"Destination location [{message.path()}] does not exists").encode("utf-8"),
+            message.trace_info(),
+        )

+
+
+

+[docs]
+    async def handle_body_payload(
+        self, message: AMQMessage, auth_user: Any, method: str
+    ) -> DataResponse:
+        """
+        Handles the requests that have a body payload, including Multipart data.
+        :param message: message from the AMQP that contains the request
+        :param auth_user: user authenticated by the API Gateway, as UserSchem
+        :param method: HTTP method (POST, PUT, etc.)
+        :return: DataResponse to be sent back to the API Gateway via AMQP
+        """
+        _form_data = AMQDataParser.parse_request_body(message)
+        _routes = self.routes.get(method, [])
+        _path, _query_args = AMQDataParser.parse_get_url(message.path())
+        for _route in _routes:
+            _match = _route.path_regex.match(_path)
+            if _match:
+                # If the path matches, call the corresponding function
+                _form_data.update(_match.groupdict())
+                _form_data.update(_query_args)
+                for _body_param in _route.dependant.body_params:
+                    if _body_param.name in _form_data:
+                        _file_data = _form_data.get(_body_param.name, None)
+                        actual_filepath = message.extra_data.get(_body_param.name, None)
+                        _form_data[_body_param.name] = (
+                            (
+                                _body_param.type_.__name__ == "UploadFile"
+                                or isinstance(_body_param.field_info, File)
+                            )
+                            and _file_data is not None
+                            and actual_filepath is not None
+                            and UploadFile(
+                                file=pathlib.Path(actual_filepath).open("rb"),
+                                size=_file_data.get("size"),
+                                filename=_file_data.get("filename"),
+                                headers=Headers({"Content-Type": _file_data.get("mediaType")}),
+                            )
+                            or _form_data[_body_param.name]
+                        )
+
+                _verified_args = {}
+                _required_args = getattr(_route.endpoint, "__annotations__", {})
+                _signature_args = inspect.signature(_route.endpoint).parameters
+                for arg in _required_args:
+                    if arg in _form_data:
+                        _verified_args[arg] = _form_data[arg]
+                    else:
+                        # needed for CleverSwarm /login  input
+                        if _required_args[arg].__name__ == "OAuth2PasswordRequestForm":
+                            try:
+                                _verified_args[arg] = OAuth2PasswordRequestForm(**_form_data)
+                            except Exception as e:
+                                print(f"Error: {e}")
+                if self.authenticated_user_arg_name in _signature_args.keys():
+                    _verified_args[self.authenticated_user_arg_name] = auth_user
+
+                return await self.call_cleverthis_api(
+                    message,
+                    _verified_args,
+                    api_method=_route.endpoint,
+                    success_code=_route.status_code if _route.status_code else 200,
+                )
+
+        return DataResponseFactory.of(
+            message.id(),
+            404,
+            "text/plain",
+            str(f"Destination location [{message.path()}] does not exists").encode("utf-8"),
+            message.trace_info(),
+        )

+
+
+    def _verify_and_instantiate_arguments(
+        self,
+        args: Any,
+        api_method: Callable[[Any, Any], Coroutine],
+    ) -> dict:
+        """
+        Check the provided arguments against the API method signature and convert the incoming string value
+        into correct expected input object.
+        The logic used FastAPI annotation and would use the value from 'default_factory' invocation (where defined)
+        or 'default' value, as defined in the FastAPI annotation, to create default value in case the object is not in
+        the input values provided by the caller.
+
+        """
+        _verified_args = {}
+        try:
+            _sig = inspect.signature(api_method)
+            _required_args = list(_sig.parameters.values())
+            # _required_args = getattr(api_method, '__annotations__', {})
+            for arg in _required_args:
+                if arg.name in args:
+                    _annotation = arg.annotation
+                    _str_annotation = str(_annotation)
+                    # convert to another type if arg is not a str
+                    if arg.name == self.authenticated_user_arg_name:
+                        _verified_args[arg.name] = args.get(arg.name)
+                    elif _annotation == int:
+                        _verified_args[arg.name] = int(args.get(arg.name))
+                    elif _annotation == float:
+                        _verified_args[arg.name] = float(args.get(arg.name))
+                    elif _annotation == bool:
+                        _verified_args[arg.name] = serializer.str_to_bool(args.get(arg.name))
+                    elif (
+                        "Optional" in _str_annotation
+                        or _str_annotation.lower().startswith("list")
+                        or _str_annotation.startswith("typing.List")
+                        or "class" in _str_annotation
+                    ):
+                        _type_descr = TypeDescriptor(
+                            _str_annotation, extra_init_data=g_extra_init_data
+                        )
+                        try:
+                            _payload = args.get(arg.name, "")
+                            _verified_args[arg.name] = _type_descr.instantiate(
+                                _payload, is_json=is_likely_json(_payload)
+                            )
+                        except Exception as err:
+                            logging_error(
+                                f"Could not instantiate argument {arg}, defaulting to its string value",
+                                err,
+                            )
+                            _verified_args[arg.name] = args.get(arg.name, None)
+                    else:
+                        _temp = args.get(arg.name)
+                        if isinstance(arg.annotation, enum.EnumType) or isinstance(
+                            arg.annotation, enum.Enum
+                        ):
+                            try:
+                                _temp = arg.annotation[_temp]
+                            except KeyError as ke:
+                                # some enums have string value different to key spelling, try different thing
+                                try:
+                                    _temp = arg.annotation(_temp)
+                                except ValueError as ve:
+                                    logging_warning(
+                                        f"cannot convert '{_temp}' to Enum type {arg.annotation}, {ke}, {ve}"
+                                    )
+                            print(f"ENUM -> {_temp}")
+                        _verified_args[arg.name] = _temp
+                else:
+                    if hasattr(arg, "default"):
+                        _temp = arg.default
+                        if hasattr(_temp, "default_factory") and _temp.default_factory is not None:
+                            _temp = _temp.default_factory()
+                        elif hasattr(_temp, "default"):
+                            _temp = _temp.default
+                        if not str(_temp) == "<class 'inspect._empty'>":
+                            _verified_args[arg.name] = _temp
+                    else:
+                        logging_warning(
+                            f"{api_method.__name__}: Missing required argument: {arg.name}"
+                        )
+        except Exception as e:
+            logging_error("Failed to validate and instantiate input args", e)
+
+        return _verified_args
+
+

+[docs]
+    async def call_cleverthis_api(
+        self,
+        message: AMQMessage,
+        args: Any,
+        api_method: Callable[[Any, Any], Coroutine],
+        success_code: int,
+    ) -> DataResponse:
+        """
+        Handles POST and PUT requests, which typically contain possibly complex payload data,
+        passed as a dictionary. Invokes the provided API method with the given arguments and
+        authenticated user, and returns the response as DataResponse.
+
+        :param message: DataMessage containing the details of the call and the payload
+        :param args: map of the arguments to pass to the API method
+        :param api_method: Callable - the method to invoke. Last parameter is the authenticated user
+        :param success_code: HTTP code to be returned when operation suceeds
+
+        :return: DataResponse class
+        """
+        try:
+            _verified_args = self._verify_and_instantiate_arguments(
+                args=args, api_method=api_method
+            )
+            logging_info(
+                "INVOKE ENDPOINT: [%s], ARGS: {%s}",
+                api_method.__name__,
+                ", ".join(f"{k}={v}" for k, v in _verified_args.items()),
+            )
+            _result: Any = await api_method(**_verified_args)
+            logging_info(f"ENDPOINT RESULT: [{api_method.__name__}], RESULT: {str(_result)}")
+
+            if isinstance(_result, FileResponse):
+                _json_result, _content_type = (
+                    await _convert_file_response(
+                        _result,
+                        message.connection,
+                        file_handler=StreamingFileHandler(),
+                        loop=self.loop,
+                    ),
+                    "application/octet-stream",
+                )
+            elif isinstance(_result, BaseModel):
+                _json_result = _result.json()
+                _content_type = "application/json"
+            else:
+                if isinstance(_result, str):
+                    _json_result = _result
+                else:
+                    _json_result = python_type_to_json(_result)
+                _content_type = "application/json"
+
+            _binary_result = (
+                _json_result.encode("utf-8")
+                if hasattr(_json_result, "encode")
+                else (
+                    _json_result.body
+                    if hasattr(_json_result, "body")
+                    else (_json_result.read() if hasattr(_json_result, "read") else _json_result)
+                )
+            )
+            logging_info(
+                f"ALL DONE in call_cleverthis_api id:{message.id()}, resp code:{success_code}"
+            )
+            return DataResponseFactory.of(
+                message.id(),
+                success_code,
+                _content_type,
+                _binary_result,
+                message.trace_info(),
+            )
+        except HTTPException as http_error:
+            logging_error(f"Service REST endpoint invocation failed: {http_error}")
+            _content = str(http_error.detail)
+            if not is_likely_json(_content):
+                return DataResponseFactory.of_error_message(
+                    message.id(),
+                    AMQErrorMessage(
+                        http_error.status_code,
+                        "Service Invocation Failed",
+                        _content,
+                    ),
+                    message.trace_info(),
+                )
+            return DataResponseFactory.of(
+                message.id(),
+                http_error.status_code,
+                "application/json",
+                _content.encode("utf-8"),
+                message.trace_info(),
+            )
+        except Exception as error:
+            logging_error(f"Service endpoint invocation failed: {error}")
+            _content = str(error)
+            if not is_likely_json(_content):
+                return DataResponseFactory.of_error_message(
+                    message.id(),
+                    AMQErrorMessage(
+                        500,
+                        "Service Invocation Failed",
+                        _content,
+                    ),
+                    message.trace_info(),
+                )
+            return DataResponseFactory.of(
+                message.id(),
+                500,
+                "application/json",
+                _content.encode("utf-8"),
+                message.trace_info(),
+            )

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/consul_global_id_generator.html b/api-doc/_build/html/_modules/amqp/adapter/consul_global_id_generator.html new file mode 100644 index 0000000..ff838e1 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/consul_global_id_generator.html @@ -0,0 +1,214 @@ + + + + + + + + amqp.adapter.consul_global_id_generator — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.adapter.consul_global_id_generator
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.adapter.consul_global_id_generator

+import logging
+import os
+import random
+import socket
+import time
+
+import consul_kv
+
+from amqp.config.amq_configuration import AMQAdapter
+
+logger = logging.getLogger(__name__)
+
+
+

+[docs]
+def get_config_values(config: AMQAdapter) -> tuple:
+    """
+    Get configuration values from AMQConfiguration or environment variables.
+
+    Returns:
+        tuple: (consul_host, consul_port, consul_counter_key, max_retries, retry_delay_seconds)
+    """
+    try:
+        consul_host = config.consul_host
+        consul_port = config.consul_port
+        consul_counter_key = config.consul_counter_key
+        max_retries = config.consul_max_retries
+        retry_delay_seconds = config.consul_initial_retry_delay
+        return consul_host, consul_port, consul_counter_key, max_retries, retry_delay_seconds
+    except Exception as e:
+        logger.warning(f"Failed to load configuration: {str(e)}. Using default values.")
+        return (
+            os.environ.get("CONSUL_HOST", consul_kv.settings.DEFAULT_ENDPOINT.split(":")[0]),
+            int(os.environ.get("CONSUL_PORT", consul_kv.settings.DEFAULT_ENDPOINT.split(":")[1])),
+            os.environ.get("CONSUL_COUNTER_KEY", "service/ids/counter"),
+            int(os.environ.get("CONSUL_MAX_RETRIES", 5)),
+            float(os.environ.get("CONSUL_RETRY_DELAY_SECONDS", 0.2)),
+        )

+
+
+
+

+[docs]
+def generate_fallback_id() -> int:
+    """
+    Generate a fallback ID when Consul is not available.
+    Uses a combination of timestamp, hostname hash, and random number.
+
+    Returns:
+        int: A reasonably unique integer ID
+    """
+    timestamp = int(time.time() * 1000)
+    hostname = socket.gethostname()
+    hostname_hash = hash(hostname) % 10000
+    random_part = random.randint(0, 9999)
+    unique_id = (timestamp * 100000000) + (hostname_hash * 10000) + random_part
+    logger.warning(f"Using fallback ID generation method: {unique_id}")
+    return unique_id

+
+
+
+

+[docs]
+def get_unique_instance_id(config: AMQAdapter) -> int:
+    """
+    Get a globally unique ID from Consul.
+    Uses Consul's atomic Compare-And-Set operations to safely increment a counter.
+    Falls back to a local generation method if Consul is unavailable.
+
+    Returns:
+        int: A globally unique integer ID
+    """
+    consul_host, consul_port, consul_counter_key, max_retries, retry_delay_seconds = (
+        get_config_values(config)
+    )
+    try:
+        c = consul_kv.Connection(endpoint=f"{consul_host}:{consul_port}", timeout=5)
+        index, data = c.get(consul_counter_key)
+        if data is None:
+            logger.info(f"Initializing Consul counter at {consul_counter_key}")
+            if c.put(consul_counter_key, "1", cas=1):
+                return 1
+            else:
+                logger.error("Failed to initialize Consul counter")
+                return generate_fallback_id()
+        current_value = int(data["Value"].decode("utf-8"))
+        new_value = current_value + 1
+        for attempt in range(max_retries):
+            success = c.put(consul_counter_key, str(new_value), cas=data["ModifyIndex"])
+            if success:
+                logger.debug(f"Successfully obtained unique ID: {new_value}")
+                return new_value
+            logger.debug(f"CAS update failed on attempt {attempt + 1}, retrying...")
+            if attempt < max_retries - 1:
+                time.sleep(retry_delay_seconds * (1 << attempt))  # Exponential backoff
+                index, data = c.get(consul_counter_key)
+                if data is None:
+                    logger.error("Counter disappeared during update")
+                    return generate_fallback_id()
+                current_value = int(data["Value"].decode("utf-8"))
+                new_value = current_value + 1
+        logger.error(f"Failed to update counter after {max_retries} attempts")
+        return generate_fallback_id()
+    except Exception as e:
+        logger.error(f"Error accessing Consul: {str(e)}")
+        return generate_fallback_id()

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/data_message_factory.html b/api-doc/_build/html/_modules/amqp/adapter/data_message_factory.html new file mode 100644 index 0000000..c59ac31 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/data_message_factory.html @@ -0,0 +1,449 @@ + + + + + + + + amqp.adapter.data_message_factory — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.adapter.data_message_factory
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.adapter.data_message_factory

+"""
+methods to create, serialize and deserialize DataMessage objects.
+"""
+
+import base64
+import json
+import re
+from datetime import datetime, timezone
+from io import BytesIO
+from typing import Any, Dict, List
+
+import amqp.adapter.file_handler
+from amqp.adapter.file_handler import FileHandler, StreamingFileHandler
+from amqp.adapter.pydantic_serializer import python_type_to_json
+from amqp.adapter.serializer import (
+    map_as_string,
+    map_with_list_as_string,
+    parse_map_list_string,
+    parse_map_string,
+)
+from amqp.model.model import DataMessage, DataMessageMagicByte
+from amqp.model.snowflake_id import SnowflakeId
+from amqp.router.utils import sanitize_as_rabbitmq_name
+
+
+

+[docs]
+class DataMessageFactory:
+    SNOWFLAKE_ID_BITS = 80
+    SEQUENCE_BITS = 12
+    MACHINE_ID_BITS = 24
+    TIMESTAMP_BITS = SNOWFLAKE_ID_BITS - SEQUENCE_BITS - MACHINE_ID_BITS
+
+    MACHINE_ID_MASK = (1 << MACHINE_ID_BITS) - 1
+    SEQUENCE_MASK = (1 << SEQUENCE_BITS) - 1
+
+    _instance = None
+    snowflake_epoch = datetime(2024, 10, 1, 0, 0, tzinfo=timezone.utc).timestamp()
+
+

+[docs]
+    def __init__(self, machine_id: int):
+        self.machine_id = (machine_id & self.MACHINE_ID_MASK) << self.SEQUENCE_BITS
+        self.snowflake_sequence = 0
+        self.snowflake_last_timestamp = 0

+
+
+

+[docs]
+    @classmethod
+    def get_instance(cls, machine_id: int):
+        """
+        return reusable factory instance
+        :param machine_id: a generator ID, should be unique for each component to prevent duplicate IDs
+        :return: factory instance
+        """
+        if cls._instance is None:
+            cls._instance = DataMessageFactory(machine_id)
+        return cls._instance

+
+
+

+[docs]
+    def generate_snowflake_id(self) -> SnowflakeId:
+        """
+        Generate an unique ID following the SnowflakeID structure, see https://en.wikipedia.org/wiki/Snowflake_ID
+        :return: 80-bit wide ID
+        """
+        timestamp = int(datetime.now(timezone.utc).timestamp() * 1000)
+
+        if timestamp < self.snowflake_last_timestamp:
+            raise RuntimeError("Clock moved backwards. Refusing to generate id")
+
+        if timestamp == self.snowflake_last_timestamp:
+            self.snowflake_sequence = (self.snowflake_sequence + 1) & self.SEQUENCE_MASK
+            if self.snowflake_sequence == 0:
+                while timestamp == self.snowflake_last_timestamp:
+                    timestamp = int(datetime.now(timezone.utc).timestamp() * 1000)
+                self.snowflake_last_timestamp = timestamp
+        else:
+            self.snowflake_sequence = 0
+            self.snowflake_last_timestamp = timestamp
+
+        time = timestamp - 1000 * int(DataMessageFactory.snowflake_epoch)
+        return SnowflakeId(
+            time >> (64 - self.SEQUENCE_BITS - self.MACHINE_ID_BITS),
+            (
+                (time << (self.SEQUENCE_BITS + self.MACHINE_ID_BITS))
+                | self.machine_id
+                | self.snowflake_sequence
+            )
+            & 0xFFFFFFFFFFFFFFFF,
+        )

+
+
+

+[docs]
+    def create_request_message(
+        self,
+        method: str,
+        domain: str,
+        path: str,
+        headers: Dict[str, List[str]],
+        message,
+    ) -> DataMessage:
+        """
+        Encapsulate / hide the system level inputs, create the AMQ message from business relevant input
+        :param method: a method requested (e.g. HTTP method like GET, POST in case of REST request)
+        :param domain: service host name
+        :param path: path at the service
+        :param headers: HTTP headers
+        :param message: payload
+        :return: DataMessage object
+        """
+        serializable_headers = headers.copy() if headers else {}
+        payload = base64.b64encode(message.encode("utf-8") if isinstance(message, str) else message)
+        trace_info = {}
+        return DataMessage(
+            DataMessageMagicByte.HTTP_REQUEST.value,
+            self.generate_snowflake_id(),
+            method,
+            domain,
+            path,
+            serializable_headers,
+            trace_info,
+            payload,
+        )

+
+
+

+[docs]
+    def safe_rsplit(self, fq_method_name, default="_"):
+        """
+        Safely split a fully qualified method name into package, class, and method
+
+        Args:
+            fq_method_name (str): Fully qualified method name
+            default (str, optional): Default value for missing tokens. Defaults to ''.
+
+        Returns:
+            tuple: (package, class_name, method)
+        """
+        if not fq_method_name:
+            return default, default, default
+        parts = fq_method_name.rsplit(".", 2)
+        # Pad with default values if insufficient tokens
+        while len(parts) < 3:
+            parts.insert(0, default)
+        return tuple(parts)

+
+
+

+[docs]
+    def create_rpc_message(
+        self,
+        fq_method_name: str,
+        swarm_id: str,
+        args: Dict[str, Any] = None,
+    ) -> DataMessage:
+        """
+        Create a RPC message with the given parameters.
+        :param fq_method_name: fully qualified method name (e.g. 'com.example.ServiceClass.method_name')
+        :param args: arguments whose serialized form will form the request body
+        :return: DataMessage object
+        """
+        package, class_name, method = self.safe_rsplit(fq_method_name)
+        headers = {"Content-Type": ["application/octet-stream"], "Return-Address": [swarm_id]}
+        trace_info = {}
+        body = python_type_to_json(args).encode(encoding="utf-8") if args else b""
+        print(
+            f"Creating RPC message for method: {fq_method_name}, args: {args} body: {body.decode('utf-8') if body else 'None'}"
+        )
+
+        return DataMessage(
+            DataMessageMagicByte.RPC_REQUEST.value,
+            self.generate_snowflake_id(),
+            package,
+            class_name,
+            method,
+            headers,
+            trace_info,
+            body,
+        )

+
+
+

+[docs]
+    @staticmethod
+    def amq_message_routing_key(message: DataMessage) -> str:
+        """
+        Constructs the message specific routing key.
+        :param message: DataMessage input
+        :return: routing key (as string) compliant to RabbitMQ allowed character set.
+        """
+        return sanitize_as_rabbitmq_name(f"{message.domain()}.{message.path()}")

+
+
+

+[docs]
+    @staticmethod
+    def get_timestamp_from_id(_id: SnowflakeId) -> int:
+        """
+        Helper method - retrieve the timestamp from the ID
+        :param _id: SnowflakeID (includes encoded timestamp)
+        :return: the message timestamp
+        """
+        bits = _id.get_bits()
+        low = bits[0] >> (DataMessageFactory.SEQUENCE_BITS + DataMessageFactory.MACHINE_ID_BITS)
+        high = bits[1] << (
+            64 - DataMessageFactory.SEQUENCE_BITS - DataMessageFactory.MACHINE_ID_BITS
+        )
+        return (high | low) + DataMessageFactory.snowflake_epoch * 1000

+
+
+

+[docs]
+    @staticmethod
+    def to_string(message: DataMessage) -> str:
+        """
+        Human-readable representation.
+        :param message: DataMessage input
+        :return: as string
+        """
+        return (
+            f"DataMessage{{"
+            f"id={message.id()}, "
+            f"method='{message.method()}', "
+            f"domain='{message.domain()}', "
+            f"path='{message.path()}', "
+            f"headers={{{map_with_list_as_string(message.headers())}}}, "
+            f"traceInfo={{{map_as_string(message.trace_info())}}}, "
+            f"base64body={message.base64body().decode()}"
+            f"}}"
+        )

+
+
+

+[docs]
+    @staticmethod
+    def serialize(message: DataMessage) -> bytes:
+        """
+        Converts DataMessage to byte array
+        :param message: message to serialize
+        :return: messages as bytes
+        """
+        id_bytes = str(message.id()).encode()
+        prolog = (
+            f"|m={message.method()}|d={message.domain()}|p={message.path()}|h={{{map_with_list_as_string(message.headers())}}}|t={{{map_as_string(message.trace_info())}}}|b="
+        ).encode("utf-8")
+        header_length = 1 + len(id_bytes) + len(prolog)
+        prolog_len = header_length.to_bytes(2, byteorder="big")
+        msg_length = 2 + header_length + len(message.base64body())
+        baos = BytesIO(bytearray(msg_length))
+        baos.write(prolog_len)
+        baos.write(message.magic().encode("utf-8"))
+        baos.write(id_bytes)
+        baos.write(prolog)
+        baos.write(message.base64body())
+        return baos.getvalue()

+
+
+

+[docs]
+    @staticmethod
+    def from_bytes(input_bytes: bytes) -> DataMessage:
+        """
+        Builds the DataMessage from its serialized (byte array) form.
+        :param input_bytes: serialized message
+        :return: DataMessage instance
+        """
+        prolog_len = (input_bytes[0] << 8) + input_bytes[1]
+        metadata = input_bytes[2 : prolog_len + 2].decode()
+
+        pattern = re.compile(
+            r"([AR])"
+            r"([0-9A-Fa-f]+)\|"
+            r"m=([^|]*)\|"
+            r"d=([^|]*)\|"
+            r"p=([^|]*)\|"
+            r"h=(\{[^}]*\})\|"
+            r"t=(\{[^}]*\})\|"
+            r"b="
+        )
+        match = pattern.match(metadata)
+        if not match:
+            raise ValueError(
+                f"DataMessage format does not match expected format. "
+                f"Input string [{metadata}] does not match pattern: {pattern.pattern}"
+            )
+
+        id_str = match.group(2)
+        method = match.group(3)
+        domain = match.group(4)
+        path = match.group(5)
+        headers_str = match.group(6)
+        trace_info_str = match.group(7)
+        body_b64 = input_bytes[prolog_len + 2 :]
+
+        headers = parse_map_list_string(headers_str)
+        trace_info = parse_map_string(trace_info_str)
+
+        return DataMessage(
+            match.group(1),  # Magic byte (R for RPC, A for HTTP)
+            SnowflakeId.from_hex(id_str),
+            method,
+            domain,
+            path,
+            headers,
+            trace_info,
+            body_b64,
+        )

+
+
+

+[docs]
+    @staticmethod
+    async def from_stream(
+        stream: bytes,
+        rabbitmq_url: str,
+        loop,
+        file_handler: FileHandler = StreamingFileHandler(),
+    ) -> DataMessage | None:
+        """
+        Builds the DataMessage from its serialized (byte array) form.
+        :param stream: serialized message
+        :param rabbitmq_url: RabbitMQ connection URL
+        :param loop: event loop
+        :param file_handler: file handler for downloading the message
+        :return: DataMessage instance
+        """
+        # async implementation
+        _message_data = json.loads(stream.decode())
+        _req_info = _message_data.get("req-info", "")
+        if _req_info:
+            (body, eof) = await file_handler.download_buffer(
+                loop=loop, rabbitmq_url=rabbitmq_url, queue_name=_req_info
+            )
+            if eof == amqp.adapter.file_handler.END_OF_FILE:
+                return DataMessageFactory.from_bytes(body)
+        return None

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/data_parser.html b/api-doc/_build/html/_modules/amqp/adapter/data_parser.html new file mode 100644 index 0000000..9c596f9 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/data_parser.html @@ -0,0 +1,325 @@ + + + + + + + + amqp.adapter.data_parser — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.adapter.data_parser

+import io
+import json
+from typing import Dict, Tuple
+from urllib.parse import parse_qs, urlparse
+from xml.etree import ElementTree
+
+import python_multipart
+from fastapi import UploadFile
+from python_multipart.multipart import Field, File
+
+from amqp.adapter.logging_utils import logging_debug, logging_error
+from amqp.model.model import AMQMessage
+
+
+

+[docs]
+class MultipartFormDataParser:
+    """
+    Parses multipart/form-data content and extracts form fields (key/value pairs) and files.
+    Note: multipart message that contains file(s) to upload are converted to CleverMicro JSON-based streaming format,
+    where files are transmitted separately via stream using dedicated queue, so the message content is no longer
+    the HTTP multipart format, but the Content-Type is being preserved for compatibility with the original message.
+    This class supports both formats (multipart and JSON) depending on the message content, because if no file is
+    included, the message is transmitted in the unchanged multipart/form-data format.
+    """
+
+

+[docs]
+    def __init__(self, message: AMQMessage):
+        self.form_data: dict = {}
+        self.is_multipart = False
+        self.is_json = False
+        self.is_valid = True
+        # Convert each list of strings to a single string joined by newline, then to bytes
+        _headers = {
+            key: "\n".join(value).encode("utf-8") for key, value in message.headers().items()
+        }
+        try:
+            if (
+                hasattr(message, "extra_data")
+                and isinstance(message.extra_data, dict)
+                and len(message.extra_data) > 0
+            ):
+                try:
+                    self.form_data = json.loads(message.body())
+                    self.is_json = True
+                    if self.form_data["files"] is not None and self.form_data["form"] is not None:
+                        self.form_data = AMQDataParser.process_form_data(self.form_data)
+                except Exception as jsonerror:
+                    logging_error(f"Parsing JSON: {jsonerror}")
+                    self.is_valid = False
+            else:
+                python_multipart.parse_form(
+                    _headers, io.BytesIO(message.body()), self.on_field, self.on_file
+                )
+                self.is_multipart = True
+        except Exception as e:
+            __error = f"Error parsing multipart/form-data: {e}. Trying parsing as JSON."
+            try:
+                self.form_data = json.loads(message.body())
+                self.is_json = True
+                if self.form_data["files"] is not None and self.form_data["form"] is not None:
+                    self.form_data = AMQDataParser.process_form_data(self.form_data)
+            except Exception as jsonerror:
+                logging_error(__error)
+                logging_error(f"Parsing JSON: {jsonerror}")
+                self.is_valid = False

+
+
+

+[docs]
+    def on_field(self, field: Field):
+        logging_debug(str(field))
+        self.form_data[field.field_name.decode("utf-8")] = field.value

+
+
+

+[docs]
+    def on_file(self, file: File):
+        logging_debug(str(file))
+        file.file_object.seek(0)
+        self.form_data[file.field_name.decode("utf-8")] = UploadFile(
+            file.file_object, size=file.size, filename=file.file_name.decode("utf-8")
+        )

+

+
+
+
+

+[docs]
+class AMQDataParser:
+    """
+    A class for parsing AMQ data messages. It provides methods to parse form data,
+    """
+
+

+[docs]
+    @staticmethod
+    def process_form_data(json_input) -> dict:
+        """
+        Processes the input JSON to extract form data. The JSON has two top entries: 'files' and 'form'.
+        This is part of the file stream implementation in AMQ adapter to stream large files in chunks.
+        'files' contains information about the AMQ queue from which read the file, while 'form' contains
+        additional non-file form values.
+        This function combines the file and values at the top level in the returned dictionary.
+        Args:
+            json_input: JSON string or dict containing the form and files data
+
+        Returns:
+            dict: Processed form data with files data overriding non-empty values
+        """
+        # Load JSON if input is string
+        if isinstance(json_input, str):
+            data = json.loads(json_input)
+        else:
+            data = json_input
+
+        result = {}
+
+        # Process form data - take first element of each list
+        for key, value in data["form"].items():
+            if value:  # Only process if list is not empty
+                result[key] = value[0]
+
+        # Override with files data where available
+        for key, value in data["files"].items():
+            if value:  # Only override if files data is non-empty
+                result[key] = value[0]
+        return result

+
+
+

+[docs]
+    @staticmethod
+    def parse_get_url(url: str) -> Tuple[str, Dict[str, str]]:
+        """
+        Parses an HTTP GET URL and returns (context_path, query_params_dict)
+
+        Args:
+            url: The URL string to parse (e.g., "http://example.com/path?foo=1&bar=2&foo=3")
+
+        Returns:
+            tuple: (context_path, query_params_dict)
+            - context_path: The path part of the URL (e.g., "/path")
+            - query_params_dict: Query parameters where values are str for single value or list of str for multivalue
+        """
+        _parsed = urlparse(url)
+        _query_params = parse_qs(_parsed.query)
+        # Convert values from lists to single values when there's only one value
+        _simplified_params = {k: v[0] if len(v) == 1 else v for k, v in _query_params.items()}
+        return _parsed.path, _simplified_params

+
+
+

+[docs]
+    @staticmethod
+    def parse_request_body(message: AMQMessage):
+        """
+        Parses the HTTP POST request body based on the MIME type.
+        This is typically called fom the concrete CleverThis Service to extract parameters from the message body.
+        Args:
+            message (DataMessage): Contains raw request and MIME headers.
+
+        Returns:
+            dict: Parsed data as a dictionary.
+        """
+        _content_type = message.headers().get("Content-Type", "")
+        if not _content_type:
+            raise ValueError("Content-Type header is required")
+        content_type = _content_type[0]
+        # Parse JSON
+        if content_type == "application/json":
+            try:
+                return json.loads(message.body() or "{}")
+            except json.JSONDecodeError as e:
+                logging_error(f"Invalid JSON: {e}")
+                raise ValueError(f"Invalid JSON: {e}")
+
+        # Parse URL-encoded form data
+        elif content_type == "application/x-www-form-urlencoded":
+            try:
+                _form_data: dict = {
+                    k: v[0] if len(v) == 1 else v for k, v in parse_qs(message.body()).items()
+                }
+                if len(_form_data) == 0 and len(message.body()) > 0:
+                    _form_data = json.loads(message.body())
+                    if _form_data["files"] is not None and _form_data["form"] is not None:
+                        _form_data = AMQDataParser.process_form_data(_form_data)
+                return _form_data
+            except Exception as e:
+                logging_error(f"Invalid URL-encoded form data: {e}")
+                raise ValueError(f"Invalid URL-encoded form data: {e}")
+
+        # Parse multipart/form-data
+        elif content_type.startswith("multipart/form-data"):
+            try:
+                parser: MultipartFormDataParser = MultipartFormDataParser(message)
+                return parser.form_data
+            except Exception as e:
+                logging_error(f"Invalid multipart/form-data: {e}")
+                raise ValueError(f"Invalid multipart/form-data: {e}")
+
+        # Parse plain text
+        elif content_type == "text/plain":
+            return {"text": message.body()}
+
+        # Parse XML
+        elif content_type == "application/xml":
+            try:
+                _root = ElementTree.fromstring(message.body())
+                return {elem.tag: elem.text for elem in _root}
+            except ElementTree.ParseError as e:
+                raise ValueError(f"Invalid XML: {e}")
+
+        else:
+            raise ValueError(f"Unsupported Content-Type: {content_type}")

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/data_response_factory.html b/api-doc/_build/html/_modules/amqp/adapter/data_response_factory.html new file mode 100644 index 0000000..84d2a6f --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/data_response_factory.html @@ -0,0 +1,276 @@ + + + + + + + + amqp.adapter.data_response_factory — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.adapter.data_response_factory
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.adapter.data_response_factory

+"""
+method to create, serialize and deserialize DataResponse message
+"""
+
+import base64
+import re
+from io import BytesIO
+
+from amqp.adapter.serializer import map_as_string, parse_map_string
+from amqp.model.model import AMQErrorMessage, DataMessageMagicByte, DataResponse
+from amqp.model.snowflake_id import SnowflakeId
+
+
+

+[docs]
+class DataResponseFactory:
+
+

+[docs]
+    @staticmethod
+    def create_async_response_message(_id: SnowflakeId) -> DataResponse:
+        """
+        Helper method to create standard OK response.
+        :param _id: ID
+        :return: Response message
+        """
+        return DataResponseFactory.of(
+            id=_id,
+            response_code=200,
+            content_type="application/text",
+            body="OK".encode("utf-8"),
+            trace_info={},
+            error="",
+            error_cause="",
+        )

+
+
+

+[docs]
+    @staticmethod
+    def of(
+        id: SnowflakeId,
+        response_code: int,
+        content_type: str,
+        body: bytes,
+        trace_info: dict[str, str],
+        error: str | None = None,
+        error_cause: str | None = None,
+    ) -> DataResponse:
+        """
+        Create the DataResponse message supplying all key values
+        :param id: SnowflakeID
+        :param response_code: HTTP response code
+        :param content_type: MIME content type
+        :param body: payload
+        :param trace_info: Jaeger trace info (id)
+        :return: DataResponseMessage object
+        """
+        return DataResponse(
+            magic=DataMessageMagicByte.HTTP_REQUEST.value,
+            id=id,
+            response_code=str(response_code),
+            content_type=content_type,
+            error=error,
+            error_cause=error_cause,
+            headers={},
+            trace_info=trace_info,
+            base64body=base64.b64encode(body),
+        )

+
+
+

+[docs]
+    @staticmethod
+    def of_error_message(
+        id: SnowflakeId,
+        error_message: AMQErrorMessage,
+        trace_info: dict[str, str],
+    ) -> DataResponse:
+        return DataResponseFactory.of(
+            id=id,
+            response_code=error_message.response_code,
+            content_type=error_message.content_type,
+            body=error_message.serialize(),
+            trace_info=trace_info,
+            error=error_message.error,
+            error_cause=error_message.detail,
+        )

+
+
+

+[docs]
+    @staticmethod
+    def serialize(response: DataResponse) -> bytes:
+        """
+        Serialize the message to byte array (to be sent over RabbitMQ)
+        :param response: Object to serialize
+        :return: byte array as serialized message
+        """
+        id_bytes = response.id().as_string().encode("utf-8")
+        prolog = (
+            f"|r={response.response_code()}|c={response.content_type()}|e={response.error()}|f={response.error_cause()}|t={{{map_as_string(response.trace_info())}}}|b="
+        ).encode("utf-8")
+        header_length = 1 + len(id_bytes) + len(prolog)
+        prolog_len = header_length.to_bytes(2, byteorder="big")
+        msg_length = 2 + header_length + len(response.base64body())
+        with BytesIO(bytearray(msg_length)) as baos:
+            baos.write(prolog_len)
+            baos.write(DataMessageMagicByte.HTTP_REQUEST.value.encode("utf-8"))
+            baos.write(id_bytes)
+            baos.write(prolog)
+            baos.write(response.base64body())
+            return baos.getvalue()

+
+
+

+[docs]
+    @staticmethod
+    def from_bytes(input_bytes: bytes) -> DataResponse:
+        """
+        Buil;ds the DataResponse object from its serialized form
+        :param input_bytes: byte array - serialized response
+        :return: DataResponse object
+        """
+        prolog_len = (input_bytes[0] << 8) + input_bytes[1]
+        metadata = input_bytes[2 : prolog_len + 2].decode()
+
+        pattern = re.compile(
+            f"{DataMessageMagicByte.HTTP_REQUEST.value}"
+            r"([0-9A-Fa-f]+)\|"
+            r"r=([^|]*)\|"
+            r"c=([^|]*)\|"
+            r"e=([^|]*)\|"
+            r"f=([^|]*)\|"
+            r"t=(\{[^}]*\})\|"
+            r"b="
+        )
+        match = pattern.match(metadata)
+        if not match:
+            raise ValueError(
+                f"DataResponse format does not match expected format. "
+                f"Input string [{metadata}] does not match pattern: {pattern.pattern}"
+            )
+
+        id_str = match.group(1)
+        response_code = int(match.group(2))
+        content_type = match.group(3)
+        error = match.group(4)
+        error_cause = match.group(5)
+        trace_info_str = match.group(6)
+        body_b64 = input_bytes[prolog_len + 2 :]
+
+        trace_info = parse_map_string(trace_info_str)
+
+        return DataResponseFactory.of(
+            id_str,
+            response_code,
+            content_type,
+            base64.b64decode(body_b64),
+            trace_info,
+            error,
+            error_cause,
+        )

+

+
+
+
+# Ensure backward compatibility
+AMQResponseFactory = DataResponseFactory
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/file_handler.html b/api-doc/_build/html/_modules/amqp/adapter/file_handler.html new file mode 100644 index 0000000..bd66a50 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/file_handler.html @@ -0,0 +1,561 @@ + + + + + + + + amqp.adapter.file_handler — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.adapter.file_handler

+"""
+implements the file downloader for the amqp adapter, where file is sent in chunks over RabbitMQ
+"""
+
+import asyncio
+import json
+import logging
+import os
+from asyncio import AbstractEventLoop
+from collections import defaultdict
+from pathlib import Path
+
+from aio_pika import Message, connect_robust
+from aio_pika.abc import (
+    AbstractExchange,
+    AbstractIncomingMessage,
+    AbstractQueue,
+    AbstractRobustChannel,
+    DeliveryMode,
+)
+
+from amqp.adapter.logging_utils import logging_debug, logging_error, logging_info
+from amqp.router.utils import await_result
+
+# Global dictionary to track completed downloads
+download_locations = defaultdict(str)
+IN_PROGRESS = 0
+END_OF_FILE = 1
+CANCELLED = 2
+
+
+

+[docs]
+class FileHandler:
+    """
+    The abstract base class for file handling. This is mainly to make the code testable, as there are only 2
+    options for pushing (uploading) a file(s) to a service: as HTTP multipart message delivered via RabbitMQ
+    or via stream in RabbitMQ. Downloading a file is always done via RabbitMQ stream. Thus the method signiture
+    is tighly coupled to the RabbitMQ API in v1. Only alternative implementation is a mock object in unittests.
+    """
+
+

+[docs]
+    def __init__(self):
+        pass

+
+
+

+[docs]
+    def ensure_directory_exists(self, filepath) -> str:
+        """
+        Ensures that the directory for the given filepath exists, and handles file versioning.
+
+        Args:
+            filepath: The path to the file.
+
+        Returns:
+            The original filepath if the file does not exist, or a modified filepath
+            pointing to the next available version of the file if it does.
+        """
+        # 1. Ensure directory exists
+        directory = os.path.dirname(filepath)
+        if directory and not os.path.exists(directory):
+            os.makedirs(directory)
+
+        # 2. Handle file versioning
+        if not os.path.exists(filepath):
+            return filepath  # File doesn't exist, return original path
+
+        # File exists, find next available version
+        base, ext = os.path.splitext(filepath)
+        version = 1
+        while True:
+            new_filepath = f"{base}.{version}{ext}"
+            if not os.path.exists(new_filepath):
+                return new_filepath  # Found a free version, return this path
+            version += 1

+
+
+

+[docs]
+    async def download_buffer(self, loop, rabbitmq_url, queue_name) -> (bytearray, int):
+        """
+        Asynchronously downloads a bytearray from RabbitMQ based on the provided file information.
+        It assumes entire array is in the first (and only) chunk
+        Args:
+            loop: The asyncio event loop.
+            rabbitmq_url: The RabbitMQ connection URL.
+            queue_name (str): The directory where the file should be saved.
+        """
+        raise NotImplementedError("Subclasses must implement this method.")

+
+
+

+[docs]
+    async def download_file(
+        self, loop, rabbitmq_url, file_info, message_data, output_dir
+    ) -> (int, int):
+        """
+        Asynchronously downloads a file from RabbitMQ based on the provided file information.
+        takes the file_info and message_data and output_dir, creates queue consumer and waits for the file
+        to be downloaded. File may consist of multiple chunks, so the function will wait until all chunks are received.
+        Args:
+            loop: The asyncio event loop.
+            rabbitmq_url: The RabbitMQ connection URL.
+            file_info (dict): A dictionary containing file metadata
+            message_data (dict): The entire message
+            output_dir (str): The directory where the file should be saved.
+        """
+        raise NotImplementedError("Subclasses must implement this method.")

+
+
+

+[docs]
+    async def on_message(
+        self,
+        message: AbstractIncomingMessage,
+        json_data: bytes,
+        rabbitmq_url: str,
+        loop,
+        output_dir="downloaded_files",
+    ) -> defaultdict:
+        """
+        Asynchronous callback function for handling messages from the 'amq-cleverswarm' queue.
+
+        Args:
+            message: The incoming RabbitMQ message.
+            rabbitmq_url: The RabbitMQ connection URL.
+        """
+        raise NotImplementedError("Subclasses must implement this method.")

+
+
+

+[docs]
+    async def publish_file(
+        self,
+        exchange: AbstractExchange,
+        file_path: Path,
+        routing_key: str,
+        loop: AbstractEventLoop,
+        max_chunk_size: int = 2**20,  # 1MB default chunk size
+        content_type: str = "application/octet-stream",  # Default content type
+        delivery_mode: DeliveryMode = DeliveryMode.PERSISTENT,
+    ) -> tuple[str, int]:
+        """
+        Reads a file from the file system and publishes its content to a RabbitMQ exchange
+        in chunks.  It declares a queue with a random name, binds it to the specified
+        exchange, and uses the queue name as the routing key.
+
+        Args:
+            exchange: The aio_pika RobustChannel to use for communication with RabbitMQ.
+            file_path: The path to the file to publish.
+            max_chunk_size: The maximum size of each chunk (in bytes).
+            routing_key: The name of the RabbitMQ exchange routing key to publish to correct queue.
+            loop: correct event loop
+            max_chunk_size: chunk size to send
+            content_type: The content type of the file data.
+            delivery_mode: The delivery mode (e.g., PERSISTENT or TRANSIENT).
+
+        Returns:
+            The name of the randomly generated queue where the file content was published.
+        """
+        raise NotImplementedError("Subclasses must implement this method.")

+

+
+
+
+# The StreamingFileHandler class is a subclass of FileHandler that implements the download_file method
+

+[docs]
+class StreamingFileHandler(FileHandler):
+    """
+    Handles file downloads from RabbitMQ streams.
+    """
+
+

+[docs]
+    def __init__(self):
+        super().__init__()

+
+
+    # This method MUST NOT be static.
+    # For testing purpose, we will mock this method and inject a mock connection.
+    async def _get_connection(self, rabbitmq_url, loop):
+        return await connect_robust(rabbitmq_url, loop=loop)
+
+    async def _download_from_queue_to_file(
+        self, rabbitmq_url, queue_name, filepath, loop
+    ) -> tuple[int, int] | None:
+        """
+        Internal method for downloading a file from a queue to disk.
+        Return (file size, eof status).
+        """
+        # Here the normal mock doesn't work since this method
+        # is async and will be run in another loop,
+        # out of the scope of method mock.
+        connection = await self._get_connection(rabbitmq_url, loop=loop)
+        _file_size = 0
+        _eof = IN_PROGRESS
+        try:
+            channel: AbstractRobustChannel = await connection.channel()
+            queue: AbstractQueue = await channel.get_queue(queue_name, ensure=False)
+            logging_debug(f"Awaiting all file chunks being downloaded for {filepath}")
+            async with queue.iterator() as queue_iter:
+                async for message in queue_iter:
+                    async with message.process():
+                        with open(filepath, "ab") as f:
+                            f.write(message.body)
+                        _file_size = _file_size + message.body_size
+                        _eof = int(message.headers.get("eof", END_OF_FILE))
+                        if _eof != IN_PROGRESS:
+                            break
+        except Exception as e:
+            logging_error(f"File download failed: {e}")
+        finally:
+            await connection.close()
+
+        return _file_size, _eof
+
+

+[docs]
+    async def download_file(
+        self, loop, rabbitmq_url, file_info, message_data, output_dir
+    ) -> (int, int):
+        """
+        Asynchronously downloads a file from RabbitMQ based on the provided file information.
+        takes the file_info and message_data and output_dir, creates queue consumer and waits for the file to be downloaded
+        Args:
+            loop: The asyncio event loop.
+            rabbitmq_url: The RabbitMQ connection URL.
+            file_info (dict): A dictionary containing file metadata
+            message_data (dict): The entire message
+            output_dir (str): The directory where the file should be saved.
+        """
+        filename = file_info["filename"]
+        size = file_info["size"]
+        stream_name = file_info["streamName"]
+        queue_name = file_info["queue_name"]
+        filepath = os.path.join(output_dir, filename)
+        filepath = self.ensure_directory_exists(
+            filepath
+        )  # if filename exists, create a new (next) version
+        download_locations[file_info["key"]] = filepath
+        filename = os.path.basename(
+            filepath
+        )  # if a new version was created, ensure to use that new version
+        file_info["filename"] = filename
+
+        logging_debug(
+            f"Downloading file: {filename} (size: {size} bytes) from stream: {stream_name}:{queue_name} to {filepath}"
+        )
+
+        if queue_name:
+            _local_file_size, _local_eof = await await_result(
+                asyncio.run_coroutine_threadsafe(
+                    self._download_from_queue_to_file(rabbitmq_url, queue_name, filepath, loop),
+                    loop=loop,
+                )
+            )
+            return _local_file_size, _local_eof
+
+        return 0, CANCELLED

+
+
+    async def _download_from_queue_to_buffer(
+        self, rabbitmq_url, queue_name, loop
+    ) -> tuple[bytearray, int]:
+        """
+        Internal method for downloading a file from a queue to RAM.
+        Return (bytearray, eof status).
+        """
+        _connection = await self._get_connection(rabbitmq_url, loop=loop)
+        _eof = IN_PROGRESS
+        _res = bytearray()
+        try:
+            channel: AbstractRobustChannel = await _connection.channel()
+            queue: AbstractQueue = await channel.get_queue(queue_name, ensure=False)
+            logging_debug(f"Awaiting all buffer chunks being downloaded for {queue_name}")
+            async with queue.iterator() as queue_iter:
+                async for message in queue_iter:
+                    async with message.process():
+                        _res.extend(message.body)
+                        _eof = message.headers.get("eof", END_OF_FILE)
+                        if _eof != IN_PROGRESS:
+                            break
+            logging_info(f"Finished downloading buffer {queue_name}")
+        except Exception as e:
+            logging_error(f"Downloading buffer: {e}")
+
+        await _connection.close()
+        return _res, _eof
+
+

+[docs]
+    async def download_buffer(self, loop, rabbitmq_url, queue_name: str | None) -> (bytearray, int):
+        """
+        Asynchronously downloads a bytearay from RabbitMQ based on the provided file information.
+        It assumes entire array is in the first (and only) chunk
+        Args:
+            loop: The asyncio event loop.
+            rabbitmq_url: The RabbitMQ connection URL.
+            queue_name (str): The directory where the file should be saved.
+        """
+        logging_debug(f"Downloading buffer from stream: {queue_name}")
+        if queue_name:
+            _local_res, _local_eof = await await_result(
+                asyncio.run_coroutine_threadsafe(
+                    self._download_from_queue_to_buffer(rabbitmq_url, queue_name, loop), loop=loop
+                )
+            )
+            return _local_res, _local_eof
+        return 0, CANCELLED

+
+
+

+[docs]
+    async def on_message(
+        self,
+        message: AbstractIncomingMessage,
+        json_data: bytes,
+        rabbitmq_url: str,
+        loop,
+        output_dir="downloaded_files",
+    ) -> defaultdict:
+        """
+        Asynchronous callback function for handling messages from the 'amq-cleverswarm' queue.
+
+        Args:
+            message: The incoming RabbitMQ message.
+            json_data: The JSON data from the message.
+            rabbitmq_url: The RabbitMQ connection URL.
+            loop: The asyncio event loop of the RabbitMQ API
+            output_dir
+        """
+        try:
+            _message_data = json.loads(message.body.decode())
+            _amq_message_data = json.loads(json_data.decode())
+
+            files_to_download = []
+            for _key, _file_type in _amq_message_data["files"].items():
+                if len(_file_type) > 0:
+                    files_info = _file_type[0]
+                    stream_name = files_info["streamName"]
+                    files_info["queue_name"] = (
+                        _message_data.get(stream_name, "") if stream_name else ""
+                    )
+                    files_info["key"] = _key
+                    files_to_download.append(files_info)
+
+            if not files_to_download:
+                logging_info(" [%s] No files to download in this message.", message.delivery_tag)
+                # await message.ack()
+                return defaultdict()
+
+            # Create a task for each file download
+            _tasks = []
+            for file_info in files_to_download:
+                logging_info(f" [{message.delivery_tag}] about to create task for {file_info}")
+                _task = asyncio.create_task(
+                    self.download_file(loop, rabbitmq_url, file_info, _message_data, output_dir)
+                )
+                _tasks.append(_task)
+            logging_info(
+                f" [{message.delivery_tag}] Waiting for all files to download...gather(*tasks)"
+            )
+            await asyncio.gather(*_tasks)  # Wait for all downloads to complete
+
+            logging_info(f"All files downloaded. d-tag: {message.delivery_tag}")
+        except Exception as e:
+            logging_error(f"Building DataMessage: {e}")
+            asyncio.run_coroutine_threadsafe(
+                message.ack(), loop=loop
+            )  # ACK -> ignore the message (do not redeliver)
+
+        return download_locations

+
+
+

+[docs]
+    async def publish_file(
+        self,
+        exchange: AbstractExchange,
+        file_path: Path,
+        routing_key: str,
+        loop: AbstractEventLoop,
+        max_chunk_size: int = 2**20,  # 1MB default chunk size
+        content_type: str = "application/octet-stream",  # Default content type
+        delivery_mode: DeliveryMode = DeliveryMode.PERSISTENT,
+    ) -> tuple[str, int]:
+        """
+        Reads a file from the file system and publishes its content to a RabbitMQ exchange
+        in chunks.  It declares a queue with a random name, binds it to the specified
+        exchange, and uses the queue name as the routing key.
+
+        Args:
+            exchange: The aio_pika RobustChannel to use for communication with RabbitMQ.
+            file_path: The path to the file to publish.
+            max_chunk_size: The maximum size of each chunk (in bytes).
+            routing_key: The name of the RabbitMQ exchange routing key to publish to correct queue.
+            loop: correct event loop
+            max_chunk_size: chunk size to send
+            content_type: The content type of the file data.
+            delivery_mode: The delivery mode (e.g., PERSISTENT or TRANSIENT).
+
+        Returns:
+            The name of the randomly generated queue where the file content was published.
+        """
+        if not file_path.is_file():
+            raise FileNotFoundError(f"File not found: {file_path}")
+        _file_size = os.path.getsize(file_path)
+
+        with open(file_path, "rb") as f:
+            _offset = 0
+            while True:
+                _chunk = f.read(max_chunk_size)
+                if not _chunk:
+                    break  # End of file
+
+                message = Message(
+                    body=_chunk,
+                    content_type=content_type,
+                    delivery_mode=delivery_mode,
+                    headers={
+                        "file_name": file_path.name,
+                        "pos": _offset,
+                        "total_size": _file_size,
+                        "chunk_size": len(_chunk),
+                        "eof": (
+                            END_OF_FILE if max_chunk_size + _offset >= _file_size else IN_PROGRESS
+                        ),
+                    },
+                )
+                logging.debug(
+                    f"Going to Publish chunk {_offset}/{_file_size} to {exchange.name}:{routing_key}"
+                )
+                _future = asyncio.run_coroutine_threadsafe(
+                    exchange.publish(message, routing_key=routing_key), loop
+                )
+                while not _future.done():
+                    # sleep allows coroutine to execute. must wait for completion to ensure all chunks written in right order
+                    await asyncio.sleep(0.02)
+                    logging_debug(f"Waiting for chunk {_offset}/{_file_size} future= {_future}")
+
+                _offset += len(_chunk)
+                logging_debug(
+                    f"Published chunk {_offset}/{_file_size} to {exchange.name}:{routing_key}"
+                )
+
+        logging_debug(
+            f"File {file_path} published to RabbitMQ exchange {exchange.name}, queue {routing_key}"
+        )
+        return routing_key, _file_size

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/logging_utils.html b/api-doc/_build/html/_modules/amqp/adapter/logging_utils.html new file mode 100644 index 0000000..0f1b5d3 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/logging_utils.html @@ -0,0 +1,250 @@ + + + + + + + + amqp.adapter.logging_utils — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.adapter.logging_utils

+import inspect
+import logging
+import os
+import sys
+import threading
+import traceback
+from importlib.metadata import version
+
+# Get version from installed package metadata
+__version__ = version("amq_adapter")  # Name must match pyproject.toml [project] name
+__verbose__ = os.environ.get("AMQ_VERBOSE_LOGGING", "0") == "1"
+
+
+

+[docs]
+def get_context_info():
+    """
+    Retrieves the current_availability module, line number, and function name.
+
+    Returns:
+        A tuple containing (module name, line number, function name).
+        Returns (None, None, None) if it fails to retrieve the information.
+    """
+    try:
+        # Get the frame object for the current_availability function call
+        frame = inspect.currentframe()
+        if frame is not None:
+            # Get the frame object for the caller of the current_availability function
+            frame = frame.f_back.f_back
+        if frame:
+            code_context = frame.f_code
+            module_name = code_context.co_filename
+            module_name = (
+                "amqp" + module_name.split("/amqp", 1)[-1]
+                if "/amqp" in module_name
+                else module_name
+            )
+            line_number = frame.f_lineno
+            function_name = code_context.co_name
+            return module_name, line_number, function_name
+        else:
+            return None, None, None
+    except Exception:
+        return None, None, None

+
+
+
+

+[docs]
+def logging_error(msg: str, *args) -> None:
+    """
+    Log an error message according to current_availability logging for 'ERROR' level.
+    Add module name, line and function name where the error occurred, on single line.
+    Args:
+        msg (str): The error message to log.
+    """
+    _exec_info = sys.exc_info()[2]
+    _thread_id = threading.get_ident()
+    if _exec_info:
+        _tb = traceback.extract_tb(sys.exc_info()[2])[-1]
+        logging.error(
+            f"{_thread_id}:{__version__} [E] '{msg}' ---> '{_tb.filename}':{_tb.lineno}, '{_tb.name}()'",
+            *args,
+        )
+    else:
+        module, line_number, function_name = get_context_info()
+        if module and line_number and function_name:
+            logging.error(
+                f"{_thread_id}:{__version__} [E] '{msg}' ---> '{module}':{line_number}, '{function_name}()'",
+                *args,
+            )
+        else:
+            logging.error(f"{_thread_id}:{__version__} [E] {msg}", *args)

+
+
+
+

+[docs]
+def logging_warning(msg: str, *args) -> None:
+    """
+    Log a warning message according to current_availability logging for 'WARN' level.
+    Add module name, line and function name where the print occurred, on single line.
+    Args:
+        msg (str): The warning message to log.
+    """
+    _thread_id = threading.get_ident()
+    if not __verbose__:
+        logging.warning(f"{_thread_id}:{__version__} [W] {msg}", *args)
+        return
+    module, line_number, function_name = get_context_info()
+    if module and line_number and function_name:
+        logging.warning(
+            f"{_thread_id}:{__version__} [W] '{msg}' ---> '{module}':{line_number}, '{function_name}()'",
+            *args,
+        )
+    else:
+        logging.warning(f"{_thread_id}:{__version__} [W] {msg}", *args)

+
+
+
+

+[docs]
+def logging_info(msg: str, *args) -> None:
+    """
+    Log an info message according to current_availability logging for 'INFO' level.
+    Add module name, line and function name where the print occurred, on single line.
+    Args:
+        msg (str): The info message to log.
+    """
+    _thread_id = threading.get_ident()
+    if not __verbose__:
+        logging.info(f"{_thread_id}:{__version__} [*] {msg}", *args)
+        return
+    module, line_number, function_name = get_context_info()
+    if module and line_number and function_name:
+        logging.info(
+            f"{_thread_id}:{__version__} [*] '{msg}' ---> '{module}':{line_number}, '{function_name}()'",
+            *args,
+        )
+    else:
+        logging.info(f"{_thread_id}:{__version__} [*] {msg}", *args)

+
+
+
+

+[docs]
+def logging_debug(msg: str, *args) -> None:
+    """
+    Log a debug message according to current_availability logging for 'DEBUG' level.
+    Add module name, line and function name where the print occurred, on single line.
+    Args:
+        msg (str): The debug message to log.
+    """
+    _thread_id = threading.get_ident()
+    module, line_number, function_name = get_context_info()
+    if module and line_number and function_name:
+        logging.debug(
+            f"{_thread_id}:{__version__} [DBG] '{msg}' ---> '{module}':{line_number}, '{function_name}()'",
+            *args,
+        )
+    else:
+        logging.debug(f"{_thread_id}:{__version__} [DBG] {msg}", *args)

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/pydantic_serializer.html b/api-doc/_build/html/_modules/amqp/adapter/pydantic_serializer.html new file mode 100644 index 0000000..bcca3b5 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/pydantic_serializer.html @@ -0,0 +1,304 @@ + + + + + + + + amqp.adapter.pydantic_serializer — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.adapter.pydantic_serializer
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.adapter.pydantic_serializer

+"""
+This module provides serialization and deserialization functions for Pydantic models that extend BaseModel
+"""
+
+import importlib
+import json
+import uuid
+from datetime import date, datetime
+from types import UnionType
+from typing import Any, Dict, Union, get_args, get_origin
+from urllib.parse import parse_qs, urlparse
+
+from pydantic import BaseModel
+
+from amqp.adapter.logging_utils import logging_debug
+
+
+

+[docs]
+def serialize_object(obj: BaseModel) -> str:
+    """
+    Serializes an R2RSerializable object to a string in the format
+    "<ClassName>:{key1:value1, key2:value2,...}".  Handles UUIDs and datetimes,
+    and nested Pydantic models.
+
+    Args:
+        obj: The BaseModel object to serialize.
+
+    Returns:
+        A string representation of the object.
+    """
+    class_name = obj.__class__.__name__
+    module_name = obj.__class__.__module__
+    obj_dict = {}
+    for key, _ in obj.model_dump().items():
+        # here we use the original value
+        # the one returned by model_dump will convert everything into dict recursively
+        value = getattr(obj, key)
+        if isinstance(value, uuid.UUID):
+            obj_dict[key] = str(value)
+        elif isinstance(value, datetime):
+            obj_dict[key] = value.isoformat()
+        elif isinstance(value, dict):  # Ensure dictionaries are handled
+            obj_dict[key] = value
+        elif isinstance(value, BaseModel):
+            obj_dict[key] = serialize_object(value)  # Recursively serialize
+        elif isinstance(value, list):
+            serialized_list = []
+            for item in value:
+                if isinstance(item, BaseModel):
+                    serialized_list.append(serialize_object(item))
+                else:
+                    serialized_list.append(item)
+            obj_dict[key] = serialized_list
+        else:
+            obj_dict[key] = value
+
+    dict_string = json.dumps(obj_dict)
+    return f"{module_name}.{class_name}:{dict_string}"

+
+
+
+

+[docs]
+def python_type_to_json(data):
+    """
+    Convert Python objects (dict, list, tuple, set, datetime, etc.) to a JSON string.
+    Handles common non-JSON-serializable types like datetime, date, and sets.
+
+    Args:
+        data: Python object to be converted (dict, list, tuple, set, etc.)
+
+    Returns:
+        str: JSON string representation of the input data
+
+    Raises:
+        TypeError: If the object contains non-serializable types (e.g., custom classes)
+    """
+
+    def default_serializer(obj):
+        """Custom serializer for non-JSON-serializable objects."""
+        if isinstance(obj, (datetime, date)):
+            return obj.isoformat()  # Convert datetime/date to ISO string
+        elif isinstance(obj, set):
+            return list(obj)  # Convert sets to lists
+        elif hasattr(obj, "__dict__"):
+            return obj.__dict__  # Attempt to serialize custom objects
+        else:
+            raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
+
+    return json.dumps(data, default=default_serializer, indent=0, ensure_ascii=False)

+
+
+
+

+[docs]
+def try_deserialize_object(data: str) -> BaseModel | str:
+    """
+    Try deserialize object, if failed, return the input string as-is.
+    """
+    if not isinstance(data, str):
+        return data
+    try:
+        return deserialize_object(data)
+    except Exception as e:
+        logging_debug(f"Failed to deserialize object: {e}")
+        return data

+
+
+
+

+[docs]
+def deserialize_object(data: str) -> BaseModel:
+    """
+    Deserializes a string in the format "<ClassName>:{key1:value1, key2:value2,...}"
+    back into an BaseModel object.  Handles UUIDs, datetimes, and
+    nested Pydantic models.
+
+    Args:
+        data: The string to deserialize.
+
+    Returns:
+        An R2RSerializable object.
+    """
+    class_path, dict_str = data.split(":", 1)
+    module_path, class_name = class_path.rsplit(".", 1)
+
+    obj_dict: Dict[str, Any] = json.loads(dict_str)
+
+    logging_debug(f"Deserialized object: {class_path}")
+    if "[" in class_name:
+        class_name = class_name.split("[")[0]
+    logging_debug(f"trying object: {class_name}")
+    module = importlib.import_module(module_path)
+    cls = getattr(module, class_name)
+    if cls is None:
+        raise ValueError(f"Unknown class: {class_name}")
+
+    # process nested model, dict and list
+    for key, value in obj_dict.items():
+        key_type: type[Any] = cls.model_fields[key].annotation
+        # handle union with none, this will give the true type
+        # for example, return `A` if the type is `A | None`
+        if get_origin(key_type) is UnionType or get_origin(key_type) is Union:
+            union_types = get_args(key_type)
+            if len(union_types) > 2:
+                # if there are multiple unions, like `A | B | None`
+                # then we have no way to figure out which one to use
+                raise ValueError(f"Unsupported Union type: {key_type}")
+            # return the none-None one as the type for processing
+            if union_types[0] is type(None):
+                key_type = union_types[1]
+            else:
+                key_type = union_types[0]
+        # skip if the value is None
+        if value is None:
+            continue
+
+        if key_type == uuid.UUID:
+            obj_dict[key] = uuid.UUID(value)
+        elif key_type == datetime:
+            obj_dict[key] = datetime.fromisoformat(value)
+        elif key_type == dict:
+            obj_dict[key] = value
+        elif issubclass(key_type, BaseModel):
+            obj_dict[key] = deserialize_object(value)
+        elif key_type == list:
+            obj_dict[key] = list(map(try_deserialize_object, value))
+
+    return cls(**obj_dict)

+
+
+
+

+[docs]
+def parse_url_query(url):
+    """
+    Parses a HTTP GET URL and returns (context_path, query_params_dict)
+
+    Args:
+        url: The URL string to parse (e.g., "http://example.com/path?foo=1&bar=2&foo=3")
+
+    Returns:
+        tuple: (context_path, query_params_dict)
+        - context_path: The path part of the URL (e.g., "/path")
+        - query_params_dict: Dictionary of query parameters where values are always lists
+                           (e.g., {"foo": ["1", "3"], "bar": ["2"]})
+    """
+    parsed = urlparse(url)
+    query_params = parse_qs(parsed.query)
+
+    # Convert values from lists to single values when there's only one value
+    # If you prefer to always keep values as lists, remove this comprehension
+    simplified_params = {k: v[0] if len(v) == 1 else v for k, v in query_params.items()}
+
+    return (parsed.path, simplified_params)

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/serializer.html b/api-doc/_build/html/_modules/amqp/adapter/serializer.html new file mode 100644 index 0000000..0525751 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/serializer.html @@ -0,0 +1,216 @@ + + + + + + + + amqp.adapter.serializer — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.adapter.serializer

+"""
+Helper functions used to aid with (de)serialization of messages sent over AMQP.
+"""
+
+import struct
+from io import BytesIO
+from typing import Dict, List, Union
+
+
+

+[docs]
+def long_to_bytes(x: int) -> bytes:
+    return struct.pack("q", x)

+
+
+
+

+[docs]
+def bytes_to_long(b: bytes) -> int:
+    return struct.unpack("q", b)[0]

+
+
+
+

+[docs]
+def read_long(bis: BytesIO) -> int:
+    try:
+        return struct.unpack("q", bis.read(8))[0]
+    except struct.error:
+        return 0

+
+
+
+

+[docs]
+def object_or_list_as_string(value: Union[str, List[str]]) -> str:
+    if isinstance(value, list):
+        return f"[{','.join(value)}]"
+    return str(value)

+
+
+
+

+[docs]
+def map_as_string(map_: Dict[str, str]) -> str:
+    return ",".join(f"{k}={object_or_list_as_string(v)}" for k, v in map_.items())

+
+
+
+

+[docs]
+def map_with_list_as_string(map_: Dict[str, List[str]]) -> str:
+    return ",".join(f"{k}={object_or_list_as_string(v)}" for k, v in map_.items())

+
+
+
+

+[docs]
+def parse_map_string(input_str: str) -> Dict[str, str]:
+    map_ = {}
+    if input_str.startswith("{") and input_str.endswith("}"):
+        for entry in str(input_str[1:-1]).replace("\n", "").split(","):
+            if len(entry) > 1:
+                if entry.startswith('"'):
+                    key, value = entry.split(":")
+                    map_[key.strip('"')] = value.strip('"')
+                else:
+                    key, value = entry.split("=")
+                    map_[key] = value
+    return map_

+
+
+
+

+[docs]
+def csv_as_list(input_str: str) -> List[str]:
+    return [item.strip() for item in input_str.strip("[]").split(",")]

+
+
+
+

+[docs]
+def add_to_map(map_: Dict[str, List[str]], token: str) -> None:
+    try:
+        eq_idx = token.index("=")
+    except ValueError:
+        eq_idx = -1  # set to -1 when not found
+    if eq_idx > 0:
+        key = token[:eq_idx]
+        map_[key] = csv_as_list(token[eq_idx + 1 :])

+
+
+
+

+[docs]
+def parse_map_list_string(input_str: str) -> Dict[str, List[str]]:
+    map_ = {}
+    if input_str.startswith("{") and input_str.endswith("}"):
+        for token in input_str[1:-1].split("],"):
+            add_to_map(map_, token)
+    return map_

+
+
+
+

+[docs]
+def str_to_bool(value: str) -> bool:
+    return value.lower() in ("true", "yes", "1", "t", "y", "on")

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/service_message_factory.html b/api-doc/_build/html/_modules/amqp/adapter/service_message_factory.html new file mode 100644 index 0000000..760c151 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/service_message_factory.html @@ -0,0 +1,278 @@ + + + + + + + + amqp.adapter.service_message_factory — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.adapter.service_message_factory
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.adapter.service_message_factory

+import base64
+
+from amqp.adapter.data_message_factory import DataMessageFactory
+from amqp.adapter.logging_utils import logging_error, logging_info
+from amqp.adapter.serializer import map_as_string, parse_map_string
+from amqp.adapter.trace_info_adapter import TraceInfoAdapter
+from amqp.model.model import ServiceMessage
+from amqp.model.service_message_type import ServiceMessageType
+from amqp.model.snowflake_id import SnowflakeId
+
+RS = "|"
+SPLIT_RS = r"\|"
+
+
+INVALID_MESSAGE = ServiceMessage()  # default values mean invalid message
+
+
+

+[docs]
+class ServiceMessageFactory:
+    """
+    build/serialize/deserialize CleverMicro Service Message class
+    """
+
+

+[docs]
+    def __init__(self, name: str):
+        self.process_name = name

+
+
+

+[docs]
+    def to_string(self, message: ServiceMessage) -> str:
+        """
+        Convert ServiceMessage to human-readable format
+        :param message: ServiceMessage object
+        :return: as string
+        """
+        if message is not None:
+            return (
+                f"ServiceMessage{{id={message.id.as_string()}|type={self.format_message_type(message)}|"
+                f"recipient={message.recipient_name}|replyTo={message.reply_to}|"
+                f"traceInfo={message.trace_info}|body={base64.b64encode(message.message.encode()).decode() if message.payload_type & 0x80 else message.message}}}"
+            )
+        return "null"

+
+
+

+[docs]
+    def of(
+        self, message_type: ServiceMessageType, payload: str, recipient_name: str
+    ) -> ServiceMessage:
+        """
+        Builds ServiceMessage object from relevant values.
+        :param message_type: enum Message type
+        :param payload: Message content, stored as-is
+        :param recipient_name: Recipient name (from the routing expression)
+        :return: ServiceMessage  object
+        """
+        _id = DataMessageFactory.get_instance(1).generate_snowflake_id()
+        return ServiceMessage(
+            id=_id,
+            payload_type=0,
+            message_type=message_type,
+            recipient_name=recipient_name,
+            reply_to=self.process_name,
+            trace_info=TraceInfoAdapter.create_produce_span(_id),
+            message=payload,
+        )

+
+
+

+[docs]
+    def as_base64(
+        self, message_type: ServiceMessageType, payload: str, recipient_name: str
+    ) -> ServiceMessage:
+        """
+        Builds ServiceMessage object from relevant values, stores content Base64 encoded.
+        :param message_type: enum Message type
+        :param payload: Message content, stored as Base64 string
+        :param recipient_name: Recipient name (from the routing expression)
+        :return: ServiceMessage  object
+        """
+        _id = DataMessageFactory.get_instance(1).generate_snowflake_id()
+        return ServiceMessage(
+            id=_id,
+            payload_type=0x80,
+            message_type=message_type,
+            recipient_name=recipient_name,
+            reply_to=self.process_name,
+            trace_info=TraceInfoAdapter.create_produce_span(_id.as_string()),
+            message=payload,
+        )

+
+
+

+[docs]
+    def from_bytes(self, input_bytes: bytes) -> ServiceMessage:
+        """
+        Deserialize ServiceMessage from byte array serialized form.
+        :param input_bytes: serialized ServiceMessage
+        :return: ServiceMessage object represented by the input.
+        """
+        logging_info(f"ServiceMessage >>> [{input_bytes.decode()}]")
+        input_str_array = input_bytes.decode().split(RS)
+        try:
+            i = 0
+            _id = input_str_array[i]
+            i += 1
+            payload_type = int(input_str_array[i], 16)
+            i += 1
+            message_type = ServiceMessageType(payload_type + 1 & 0x7F)
+            recipient_name = input_str_array[i] if i < len(input_str_array) else ""
+            i += 1
+            reply_to = input_str_array[i] if i < len(input_str_array) else ""
+            i += 1
+            trace_info = parse_map_string(input_str_array[i]) if i < len(input_str_array) else {}
+            i += 1
+            message = input_str_array[i] if i < len(input_str_array) else ""
+            return ServiceMessage(
+                id=SnowflakeId.from_hex(_id),
+                payload_type=payload_type,
+                message_type=message_type,
+                recipient_name=recipient_name,
+                reply_to=reply_to,
+                trace_info=trace_info,
+                message=(base64.b64decode(message).decode() if payload_type & 0x80 else message),
+            )
+        except Exception as e:
+            logging_error(
+                "Unexpected ServiceMessage format. Expected 6 tokens separated by '|' in format: "
+                "[ID(64bit number)|MessageType(8bit number)|RecipientName(String)|"
+                "ReplyTo(String)|TraceInfo|Payload(String or Base64)], got: "
+                "[%s], reported problem: %s",
+                input_bytes.decode(),
+                str(e),
+            )
+            return INVALID_MESSAGE

+
+
+

+[docs]
+    def serialize(self, message: ServiceMessage) -> bytes:
+        """
+        Serialize ServiceMessage to byte array.
+        :param message: ServiceMessage to serialize.
+        :return: serialized object.
+        """
+        return (
+            f"{message.id.as_string()}{RS}{self.format_message_type(message)}{RS}{message.recipient_name}{RS}"
+            f"{message.reply_to}{RS}{map_as_string(message.trace_info)}{RS}"
+            f"{base64.b64encode(message.message.encode()).decode() if message.payload_type != 0 else message.message}"
+        ).encode("utf-8")

+
+
+

+[docs]
+    def format_message_type(self, message: ServiceMessage) -> str:
+        """
+        Formats the Enum message type and decorates it with base64 flag at highest bit.
+        For compatibility with 0-based enum ordinals in Java subtract 1 from ordinal value.
+        :param message: Service message to send
+        :return: formatted message type
+        """
+        num_type = (
+            message.message_type.value if message.message_type else ServiceMessageType.UNKNOWN.value
+        ) - 1
+        fmt = (num_type & 0x7F) | (message.payload_type & 0x80)
+        return f"{fmt:02X}"

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/trace_info_adapter.html b/api-doc/_build/html/_modules/amqp/adapter/trace_info_adapter.html new file mode 100644 index 0000000..bc312c4 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/trace_info_adapter.html @@ -0,0 +1,126 @@ + + + + + + + + amqp.adapter.trace_info_adapter — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.adapter.trace_info_adapter
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.adapter.trace_info_adapter

+from dataclasses import dataclass
+from typing import Dict
+
+
+

+[docs]
+@dataclass
+class TraceInfoAdapter:
+    """
+    TODO This class should set up the Open Telemetry tracing stack. To be done later.
+    """
+
+

+[docs]
+    @staticmethod
+    def create_produce_span(message_id: str) -> Dict[str, str]:
+        return {"trace-id": message_id}

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/adapter/type_descriptor.html b/api-doc/_build/html/_modules/amqp/adapter/type_descriptor.html new file mode 100644 index 0000000..63294ec --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/adapter/type_descriptor.html @@ -0,0 +1,324 @@ + + + + + + + + amqp.adapter.type_descriptor — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.adapter.type_descriptor

+""" """
+
+import importlib
+import json
+from typing import Any
+
+
+

+[docs]
+class TypeDescriptor:
+

+[docs]
+    def __init__(self, type_string: str, extra_init_data: dict):
+        self.type_string = type_string
+        self.extra_init_data = extra_init_data or {}
+        self.is_json: bool = False
+        self.type: str = self._extract_type()

+
+
+    def _extract_type(self) -> str:
+        if self.type_string.startswith("<class '"):
+            return self.type_string[8:-2]
+        # Handle Annotated case of FastAPI annotation
+        if "typing.Optional" in self.type_string:
+            annotated = _extract_type_of(self.type_string)
+            if "typing.Annotated" in annotated:
+                # Extract content between the first square brackets after Annotated
+                match = _extract_type_of(annotated)
+                if match:
+                    # Split by comma and get first part, then strip whitespace
+                    parts = [p.strip() for p in match.split(",")]
+                    if len(parts) > 1:
+                        self.is_json = parts[1].lower() == "json"
+                    return parts[0] if parts else ""
+            else:
+                # Handle simple Optional case
+                return annotated
+        return _extract_type_of(self.type_string)
+
+

+[docs]
+    def instantiate(self, payload: Any, is_json: bool = False) -> Any:
+        return _instantiate(
+            (
+                self.type
+                if "typing.Optional" in self.type_string or self.type_string.startswith("<class ")
+                else self.type_string
+            ),
+            payload,
+            self.is_json or is_json,
+            extra_init_data=self.extra_init_data,
+        )

+
+
+    def __repr__(self) -> str:
+        return f"TypeDescriptor(type='{self.type}', is_json={self.is_json})"

+
+
+
+def _extract_type_of(input_string: str) -> str:
+    stack = []
+    start_index = -1
+    end_index = -1
+
+    for i, char in enumerate(input_string):
+        if i > 0:  # this assumes paramerized type, that must be at lest 1 char long
+            if char == "[":
+                if start_index == -1:
+                    start_index = i
+                stack.append(char)
+            elif char == "]":
+                if len(stack) == 1:
+                    end_index = i
+                    break
+                if len(stack) > 0:
+                    stack.pop()
+
+    if start_index != -1 and end_index != -1:
+        return input_string[start_index + 1 : end_index].strip()
+    else:
+        return input_string.strip() if start_index == 1 and end_index == -1 else ""
+
+
+

+[docs]
+def merge_extra_init_data(cls, json_payload, extra_init_data: dict):
+    """
+    Merges extra_init_data into json_payload only when:
+    1. cls has an attribute named like the key
+    2. json_payload doesn't already have the key
+    """
+    return {
+        **json_payload,
+        **{
+            k: v
+            for k, v in extra_init_data.items()
+            if (hasattr(cls, k) or (hasattr(cls, "model_fields") and k in cls.model_fields))
+            and k not in json_payload
+        },
+    }

+
+
+
+def _instantiate(
+    type_string: str, payload: Any, is_json: bool = False, extra_init_data: dict = None
+) -> Any:
+    """
+    Dynamically imports and instantiates a class from a TypeDescriptor's type_string attribute.
+
+    Args:
+        type_string: TypeDescriptor instance with the class path
+        payload: Argument to pass to the constructor
+
+    Returns:
+        Instance of the target class initialized with payload
+
+    Raises:
+        ImportError: If the module/class cannot be imported
+        TypeError: If instantiation fails
+    """
+    # Handle JSON payload first
+    json_payload = json.loads(payload) if is_json and isinstance(payload, str) else None
+
+    # Handle basic types
+    if type_string == "str":
+        return str(payload)
+    if type_string == "int":
+        return int(payload)
+    if type_string == "float":
+        return float(payload)
+    if type_string == "bool":
+        return bool(payload)
+
+    # Handle typing module types
+    if type_string.startswith("typing.") or type_string.startswith("list"):
+        if (
+            type_string.startswith("typing.List")
+            or type_string.startswith("typing.Sequence")
+            or type_string.startswith("list")
+        ):
+            if json_payload is not None:
+                return json_payload
+            inner_type = _extract_type_of(type_string)
+            if inner_type:
+                return [
+                    _instantiate(inner_type, p, extra_init_data=extra_init_data)
+                    for p in (payload if isinstance(payload, list) else payload.split(","))
+                ]
+            return payload if isinstance(payload, list) else payload.split(",")
+
+        if type_string.startswith("typing.Dict") or type_string.startswith("typing.Mapping"):
+            if json_payload is not None:
+                return json_payload
+            return dict(payload)
+
+        if type_string.startswith("typing.Set"):
+            if json_payload is not None:
+                return set(json_payload)
+            _set_type = _extract_type_of(type_string)
+            return set(
+                payload
+                if isinstance(payload, list)
+                else [_instantiate(_set_type, p) for p in payload.split(",")]
+            )
+
+        if type_string.startswith("typing.Tuple"):
+            if json_payload is not None:
+                return tuple(json_payload)
+            _tuple_type = _extract_type_of(type_string)
+            return tuple(
+                payload
+                if isinstance(payload, list)
+                else [_instantiate(_tuple_type, p) for p in payload.split(",")]
+            )
+
+        if type_string.startswith("typing.Optional"):
+            inner_type = _extract_type_of(type_string)
+            if inner_type:
+                return _instantiate(inner_type, payload, is_json, extra_init_data)
+            return payload
+
+    # Handle regular class instantiation
+    parts = type_string.split(".")
+    module_path = ".".join(parts[:-1])
+    class_name = parts[-1]
+
+    try:
+        # Import the module
+        module = importlib.import_module(module_path)
+        # Get the class
+        cls = getattr(module, class_name)
+        if isinstance(payload, cls):
+            return payload
+        # Instantiate with payload
+        if json_payload is not None:
+            _args = merge_extra_init_data(cls, json_payload, extra_init_data or {})
+            if hasattr(cls, "from_dict"):
+                return cls.from_dict(_args)
+            elif hasattr(cls, "create"):
+                return cls.create(**_args)
+            return cls(**_args)
+
+        if isinstance(payload, dict):
+            _args = merge_extra_init_data(cls, payload, extra_init_data or {})
+            if hasattr(cls, "from_dict"):
+                return cls.from_dict(_args)
+            elif hasattr(cls, "create"):
+                return cls.create(**_args)
+            return cls(**_args)
+
+        return cls(payload)
+    except ImportError as e:
+        raise ImportError(f"Could not import module '{module_path}'") from e
+    except AttributeError as e:
+        raise ImportError(f"Module '{module_path}' has no class '{class_name}'") from e
+    except TypeError as e:
+        raise TypeError(f"Failed to instantiate {type_string} with payload {payload}") from e
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/config/amq_configuration.html b/api-doc/_build/html/_modules/amqp/config/amq_configuration.html new file mode 100644 index 0000000..f72d00d --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/config/amq_configuration.html @@ -0,0 +1,383 @@ + + + + + + + + amqp.config.amq_configuration — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.config.amq_configuration
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.config.amq_configuration

+import configparser
+import inspect
+import os
+
+from amqp.adapter.logging_utils import logging_error, logging_warning
+
+"""
+Convert configuration from properties file to an object.
+"""
+
+
+

+[docs]
+class AMQAdapter:
+    """
+    configuration with prefix 'cm.amq-adapter'
+    """
+
+    PREFIX: str = "cm.amq-adapter."
+
+

+[docs]
+    def __init__(self, config: configparser.ConfigParser):
+        """
+        cm.amq-adapter.service-name=amq-adapter
+        cm.amq-adapter.generator-id=164
+        cm.amq-adapter.route-mapping=
+
+        :param config: config parser to read configuration values
+        """
+        self.generator_id = 0
+        self.service_name = config.get(
+            "CleverMicro-AMQ",
+            self.PREFIX + "service-name",
+            fallback="amq-python-adapter-" + str(self.generator_id),
+        )
+        self.route_mapping = config.get(
+            "CleverMicro-AMQ", self.PREFIX + "route-mapping", fallback=None
+        )
+        self.require_authenticated_user = config.getboolean(
+            "CleverMicro-AMQ",
+            self.PREFIX + "require-authenticated-user",
+            fallback=False,
+        )
+        self.backpressure_enabled = config.getboolean(
+            "CleverMicro-AMQ",
+            self.PREFIX + "default-backpressure-enabled",
+            fallback=False,
+        )
+        self.callbacks_enabled = config.getboolean(
+            "CleverMicro-AMQ",
+            self.PREFIX + "callbacks-enabled",
+            fallback=False,
+        )
+        # these 2 shall be provided by Docker swarm, format is a random alphanumeric string
+        self.swarm_service_id = os.getenv("SWARM_SERVICE_ID", default="clever-amqp-service")
+        self.swarm_task_id = os.getenv("SWARM_TASK_ID", default="python-adapter")
+        #
+        # Consul related configuration
+        self.consul_port = (
+            int(
+                os.getenv(
+                    "CONSUL_PORT",
+                    config.get("CleverMicro-AMQ", self.PREFIX + "consul-port", fallback="8500"),
+                )
+            )
+            if os.getenv("CONSUL_PORT") is not None
+            else config.getint("CleverMicro-AMQ", self.PREFIX + "consul-port", fallback=8500)
+        )
+        self.consul_host = os.getenv(
+            "CONSUL_HOST",
+            config.get("CleverMicro-AMQ", self.PREFIX + "consul-host", fallback="consul"),
+        )
+        self.consul_max_retries = (
+            int(
+                os.getenv(
+                    "CONSUL_MAX_RETRIES",
+                    config.get("CleverMicro-AMQ", self.PREFIX + "consul-max-retries", fallback="5"),
+                )
+            )
+            if os.getenv("CONSUL_MAX_RETRIES") is not None
+            else config.getint("CleverMicro-AMQ", self.PREFIX + "consul-max-retries", fallback=5)
+        )
+        self.consul_initial_retry_delay = (
+            float(
+                os.getenv(
+                    "CONSUL_INITIAL_RETRY_DELAY",
+                    config.get(
+                        "CleverMicro-AMQ",
+                        self.PREFIX + "consul-initial-retry-delay",
+                        fallback="0.2",
+                    ),
+                )
+            )
+            if os.getenv("CONSUL_INITIAL_RETRY_DELAY") is not None
+            else config.getfloat(
+                "CleverMicro-AMQ", self.PREFIX + "consul-initial-retry-delay", fallback=0.2
+            )
+        )
+        self.consul_counter_key = (
+            os.getenv(
+                "CONSUL_COUNTER_KEY",
+                config.get(
+                    "CleverMicro-AMQ",
+                    self.PREFIX + "consul-counter-key",
+                    fallback="service/ids/counter",
+                ),
+            )
+            if os.getenv("CONSUL_COUNTER_KEY") is not None
+            else config.get(
+                "CleverMicro-AMQ",
+                self.PREFIX + "consul-counter-key",
+                fallback="service/ids/counter",
+            )
+        )

+
+
+

+[docs]
+    def adapter_prefix(self) -> str:
+        return f"{self.service_name}-{self.generator_id}-"

+

+
+
+
+

+[docs]
+class Dispatch:
+    """
+    configuration with prefix 'cm.dispatch'
+    """
+
+    PREFIX: str = "cm.dispatch."
+
+

+[docs]
+    def __init__(self, config: configparser.ConfigParser):
+        """
+        cm.dispatch.use-dlq=true
+        cm.dispatch.amq-host=rabbitmq
+        cm.dispatch.amq-port=5672
+        cm.dispatch.amq-port-tls=5671
+        cm.dispatch.service-host=
+        cm.dispatch.service-port=8080
+
+        :param config: config parser to read configuration values
+        """
+        self.use_dlq = config.getboolean("CleverMicro-AMQ", self.PREFIX + "use-dlq", fallback=False)
+        self.amq_host = config.get("CleverMicro-AMQ", self.PREFIX + "amq-host", fallback="rabbitmq")
+        self.amq_port = config.getint("CleverMicro-AMQ", self.PREFIX + "amq-port", fallback=5672)
+        self.amq_port_tls = config.getint(
+            "CleverMicro-AMQ", self.PREFIX + "amq-port-tls", fallback=5671
+        )
+        self.service_host = config.get(
+            "CleverMicro-AMQ", self.PREFIX + "service-host", fallback="localhost"
+        )
+        self.service_port = config.getint(
+            "CleverMicro-AMQ", self.PREFIX + "service-port", fallback=8080
+        )
+        self.rabbit_mq_user = os.getenv("RABBIT_MQ_USER", "springuser")
+        self.rabbit_mq_password = os.getenv("RABBIT_MQ_PASSWORD", "TheCleverWho")
+        self.rabbit_mq_url = (
+            f"amqp://{self.rabbit_mq_user}:{self.rabbit_mq_password}@{self.amq_host}/"
+        )
+        self.download_dir = config.get(
+            "CleverMicro-AMQ", self.PREFIX + "download-dir", fallback="downloaded_files"
+        )

+

+
+
+
+

+[docs]
+class Backpressure:
+    """
+    configuration with prefix 'cm.backpressure'
+    """
+
+    PREFIX: str = "cm.backpressure."
+
+

+[docs]
+    def __init__(self, config: configparser.ConfigParser):
+        """
+        cm.backpressure.threshold=20
+        cm.backpressure.time-window=3000
+
+        :param config: config parser to read configuration values
+        """
+        self.threshold_load = config.getint(
+            "CleverMicro-AMQ",
+            self.PREFIX + "threshold",
+            fallback=int(os.getenv("PARALLEL_WORKERS", 1)),
+        )
+        # time-window in seconds, duration between backpressure reports
+        self.time_window = config.getint(
+            "CleverMicro-AMQ", self.PREFIX + "time-window", fallback=10
+        )
+
+        # Define maximum CPU usage before triggering backpressure OVERLOAD alert
+        self.threshold_cpu = config.getint(
+            "CleverMicro-AMQ", self.PREFIX + "threshold-cpu", fallback=90
+        )
+        # Define the time window length, in seconds, during which, if CPU usage is consistently above the threshold, the system will trigger OVERLOAD alert
+        self.cpu_overload_duration = config.getint(
+            "CleverMicro-AMQ", self.PREFIX + "cpu-overload-duration", fallback=30
+        )
+        # Define the time window length, in seconds, during which, if no request is made to the Service, the system will trigger IDLE alert
+        self.idle_duration = config.getint(
+            "CleverMicro-AMQ", self.PREFIX + "idle-duration", fallback=30
+        )
+        # Flag to enable/disable CPU monitoring
+        self.cpu_monitoring_enabled = config.getboolean(
+            "CleverMicro-AMQ", self.PREFIX + "cpu-monitoring-enabled", fallback=False
+        )

+

+
+
+
+

+[docs]
+class AMQConfiguration:
+    """
+    Top level configuration context holder / object
+    """
+
+

+[docs]
+    def __init__(self, config_file_name: str = None):
+        config = configparser.ConfigParser()
+        # Read the application.properties file
+        if os.path.exists(config_file_name):
+            config.read(config_file_name)
+        else:
+            # Get the directory of the caller (the module where this function is called)
+            caller_frame = inspect.stack()[1]  # 0 is current_availability frame, 1 is caller
+            caller_module = inspect.getmodule(caller_frame[0])
+            if caller_module:
+                caller_dir = os.path.dirname(os.path.abspath(caller_module.__file__))
+                config_file_path = os.path.join(caller_dir, config_file_name)
+                config.read(config_file_path)
+            else:
+                logging_error(f"Configuration file not found: {config_file_name}")
+                logging_warning(
+                    "Defaulting to preset values, which will likely be wrong, causing errors."
+                )
+
+        # Override values with environment variables
+        for section in config.sections():
+            for option in config.options(section):
+                # env_var = f"{section.upper()}_{option.upper()}"
+                if option in os.environ:
+                    config.set(section, option, os.environ[option])
+
+        #
+        # Add individual config areas
+        #
+        self.amq_adapter: AMQAdapter = AMQAdapter(config)
+        self.dispatch: Dispatch = Dispatch(config)
+        self.backpressure: Backpressure = Backpressure(config)

+
+
+

+[docs]
+    def get_unique_instance_id(self) -> int:
+        """
+        Get a unique instance ID for this AMQ service.
+
+        Returns:
+            int: A unique instance ID
+        """
+        if self.instance_id == -1:
+            logging_warning(f"Generated unique instance ID: {self.instance_id}")
+        return self.instance_id

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/model/model.html b/api-doc/_build/html/_modules/amqp/model/model.html new file mode 100644 index 0000000..e6481fa --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/model/model.html @@ -0,0 +1,589 @@ + + + + + + + + amqp.model.model — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.model.model

+import base64
+import json
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Dict, List
+
+from aio_pika.abc import AbstractRobustConnection
+
+from amqp.model.service_message_type import ServiceMessageType
+from amqp.model.snowflake_id import SnowflakeId
+from amqp.router.utils import sanitize_as_rabbitmq_name
+
+RS = ":"
+
+
+"""
+Define the structure of messages used in Clever Micro
+"""
+
+
+

+[docs]
+class DataMessageMagicByte(Enum):
+    HTTP_REQUEST = "A"
+    RPC_REQUEST = "R"

+
+
+
+

+[docs]
+@dataclass
+class CleverMicroMessage:
+    DEFAULT_CONTENT_TYPE = ["application/octet-stream"]
+
+    """
+    The common structure of a message that transfers the user request to the Service and back. All data related messages
+    conform to this base structure:
+
+    magic - identifies the message type (REST, RPC, DataResponse)
+    id - unique message ID
+    m_field - method name (for REST style calls) or service name (for RPC style calls) or response code for DataResponse
+    d_field - domain name (for REST style calls) or module name (for RPC style calls) or  error code for DataResponse
+    p_field - path (for REST style calls) or method name (for RPC style calls) or error cause for DataResponse
+    headers - headers of the message (e.g. Content-Type, Accept, etc.)
+    trace_info - trace information (e.g. trace ID, span ID, etc. for Jaeger trace monitor)
+    base64body - the body of the message encoded in base64
+    """
+
+

+[docs]
+    def __init__(
+        self,
+        magic: str,
+        id: SnowflakeId,
+        m_field: str,
+        d_field: str,
+        p_field: str,
+        headers: Dict[str, List[str]],
+        trace_info: Dict[str, str],
+        base64body: bytes,
+    ):
+        self._magic = magic
+        self._id: SnowflakeId = id
+        self._m_field = m_field
+        self._d_field = d_field
+        self._p_field = p_field
+        self._headers: Dict[str, List[str]] = headers
+        self._trace_info: Dict[str, str] = trace_info
+        self._base64body: bytes = base64body

+
+
+

+[docs]
+    def magic(self):
+        return self._magic

+
+
+

+[docs]
+    def id(self):
+        return self._id

+
+
+

+[docs]
+    def m_field(self) -> str:
+        return self._m_field

+
+
+

+[docs]
+    def d_field(self) -> str:
+        return self._d_field

+
+
+

+[docs]
+    def p_field(self) -> str:
+        return self._p_field

+
+
+

+[docs]
+    def headers(self) -> Dict[str, List[str]]:
+        return self._headers

+
+
+

+[docs]
+    def trace_info(self) -> Dict[str, str]:
+        return self._trace_info

+
+
+

+[docs]
+    def base64body(self) -> bytes:
+        return self._base64body

+
+
+

+[docs]
+    def body(self) -> bytes:
+        return base64.b64decode(self.base64body())

+
+
+

+[docs]
+    def content_type(self) -> str:
+        return self.headers().get("Content-Type", self.DEFAULT_CONTENT_TYPE)[0]

+
+
+

+[docs]
+    def return_address(self) -> str:
+        return self.headers().get("Return-Address", "")[0]

+

+
+
+
+

+[docs]
+class DataMessage(CleverMicroMessage):
+    """
+    The class represents a structure of a message that transfers the user request to the Service.
+    It may also be used to make a call/request between services.
+    The response to this call is in format of DataResponse class.
+
+    See DataMessageFactory for code to instantiate, serialize and deserialize the class
+    """
+
+

+[docs]
+    def __init__(
+        self,
+        magic: str,
+        id: SnowflakeId,
+        method: str,
+        domain: str,
+        path: str,
+        headers: Dict[str, List[str]],
+        trace_info: Dict[str, str],
+        base64body: bytes,
+    ):
+        super().__init__(magic, id, method, domain, path, headers, trace_info, base64body)

+
+
+

+[docs]
+    def method(self) -> str:
+        return self.m_field()

+
+
+

+[docs]
+    def domain(self) -> str:
+        return self.d_field()

+
+
+

+[docs]
+    def path(self) -> str:
+        return self.p_field()

+
+
+

+[docs]
+    def routing_key(self) -> str:
+        return sanitize_as_rabbitmq_name(f"{self.d_field()}.{self.p_field()}")

+

+
+
+
+

+[docs]
+class MultipartDataMessage(DataMessage):
+

+[docs]
+    def __init__(self, message: DataMessage, extra_data: dict):
+        super().__init__(
+            message.magic(),
+            message.id(),
+            message.method(),
+            message.domain(),
+            message.path(),
+            message.headers(),
+            message.trace_info(),
+            message.base64body(),
+        )
+        self.extra_data = extra_data

+

+
+
+
+

+[docs]
+@dataclass
+class AMQMessage(DataMessage):
+    """
+    Expand the core DataMessage type to include the channel, which is required to create a dedicated queue
+    in case the response should initiate file download.
+    """
+
+    _connection: AbstractRobustConnection = field(repr=False)  # Don't show in repr
+
+

+[docs]
+    def __init__(self, data_message: DataMessage, connection: AbstractRobustConnection):
+        # Initialize the parent DataMessage with all properties from the input data_message
+        super().__init__(
+            magic=data_message.magic(),
+            id=data_message.id(),
+            method=data_message.method(),
+            domain=data_message.domain(),
+            path=data_message.path(),
+            headers=data_message.headers(),
+            trace_info=data_message.trace_info(),
+            base64body=data_message.base64body(),
+        )
+        self._connection = connection
+        self.extra_data = data_message.extra_data if hasattr(data_message, "extra_data") else {}

+
+
+    @property
+    def connection(self) -> AbstractRobustConnection:
+        """Get the AMQP connection associated with this message"""
+        return self._connection

+
+
+
+

+[docs]
+class DataResponse(CleverMicroMessage):
+    """
+    The response message to REST & RPC style calls (note: the request is made with DataMessage)
+
+    See DataResponseFactory for code to instantiate, serialize and deserialize the class
+    """
+
+

+[docs]
+    def __init__(
+        self,
+        magic: str,
+        id: SnowflakeId,
+        response_code: str,
+        content_type: str,
+        error: str,
+        error_cause: str,
+        headers: Dict[str, List[str]],
+        trace_info: Dict[str, str],
+        base64body: bytes,
+    ):
+        if headers is None:
+            headers = {}
+        headers["Content-Type"] = [content_type]
+        super().__init__(
+            magic,
+            id,
+            response_code,
+            error,
+            error_cause,
+            headers,
+            trace_info,
+            base64body,
+        )

+
+
+

+[docs]
+    def response_code(self) -> str:
+        return self.m_field()

+
+
+

+[docs]
+    def error(self) -> str:
+        return self.d_field()

+
+
+

+[docs]
+    def error_cause(self) -> str:
+        return self.p_field()

+

+
+
+
+

+[docs]
+@dataclass(frozen=True)
+class AMQRoute:
+    """
+    Configuration item representing one AMQRoute. Adapter uses this to declare the Exchange
+    and/or queue and bind the key as routing expression.
+
+    :param component_name: a service/component name that this route points to (owner of the route)
+    :param exchange: RabbitMQ exchange name
+    :param queue: RabbitMQ queue name
+    :param key: RabbitMQ TOPIC Exchange routing key
+    :param timeout: Timeout in milliseconds, how long to wait for reply, or not waiting if less then 1
+    :param valid_until: optional timestamp (millis from epoch) after which the route is ignored
+    """
+
+    component_name: str
+    exchange: str
+    queue: str
+    key: str
+    timeout: int
+    valid_until: int
+
+    FORMAT = "Component-Name:Exchange-Name:Queue-Name:Routing-Key:Timeout:Valid-Until"
+
+    def __str__(self):
+        return (
+            f"{self.component_name}{RS}{self.exchange}{RS}{self.queue}{RS}{self.key}"
+            f"{RS}{self.timeout}{RS}{self.valid_until}"
+        )
+
+    def __eq__(self, other):
+        if isinstance(other, AMQRoute):
+            return (
+                self.component_name == other.component_name
+                and self.queue == other.queue
+                and self.key == other.key
+            )
+        return False
+
+    @property
+    def primary_key(self):
+        """
+        Build the unique identifier of the route
+        :return primary key
+        """
+        return f"{self.component_name}{RS}{self.queue}{RS}{self.key}"
+
+

+[docs]
+    def as_string(self) -> str:
+        return self.__str__()

+

+
+
+
+# Ensure backward compatibility
+AMQResponse = DataResponse
+
+
+

+[docs]
+@dataclass(frozen=True)
+class ServiceMessage:
+    """
+    The CleverMicro service message that is used to communicate the internal state of the AMQ channel.
+    In v0.2 it supports service discovery / route registration and Backpressure status notification.
+    """
+
+    id: SnowflakeId = None
+    payload_type: int = 0
+    message_type: ServiceMessageType = ServiceMessageType.UNKNOWN
+    recipient_name: str = None
+    reply_to: str = None
+    trace_info: Dict[str, str] = field(default_factory=dict)
+    message: str = None
+
+

+[docs]
+    def is_valid(self) -> bool:
+        return self.message_type is not None

+

+
+
+
+

+[docs]
+class ScalingRequestAlert(Enum):
+    OVERLOAD = "OVERLOAD"
+    IDLE = "IDLE"
+    UPDATE = "UPDATE"
+    SCALE_UP = "SCALE_UP"
+    SCALE_DOWN = "SCALE_DOWN"

+
+
+
+

+[docs]
+@dataclass(frozen=True)
+class ScalingRequest:
+    service_id: str
+    task_id: str
+    max_availability: int
+    current_availability: int
+    request_type: ScalingRequestAlert
+    version: int = 1
+
+

+[docs]
+    def to_json(self) -> str:
+        """Converts the object to a JSON string matching the Java structure"""
+        return json.dumps(
+            {
+                "version": self.version,
+                "serviceId": self.service_id,
+                "taskId": self.task_id,
+                "maxAvailability": self.max_availability,
+                "currentAvailability": self.current_availability,
+                "requestType": self.request_type.value,  # Using .value for Enum serialization
+            },
+            indent=2,
+        )

+
+
+

+[docs]
+    @classmethod
+    def from_json(cls, json_str: str) -> "ScalingRequest":
+        """Creates a ScalingRequest from a JSON string"""
+        data = json.loads(json_str)
+        return cls(
+            service_id=data["serviceId"],
+            task_id=data["taskId"],
+            max_availability=data["maxAvailability"],
+            current_availability=data["currentAvailability"],
+            request_type=ScalingRequestAlert(data["requestType"]),  # Convert string to Enum
+        )

+

+
+
+
+

+[docs]
+class AMQErrorMessage:
+    """
+    The error response message to RPC style call (note: the request is made with DataMessage)
+    """
+
+

+[docs]
+    def __init__(
+        self,
+        response_code: int,
+        error: str,
+        detail: str,
+        content_type: str = "application/json",
+    ):
+        self.response_code = response_code
+        self.error = error
+        self.detail = detail
+        self.content_type = content_type

+
+
+

+[docs]
+    def serialize(self) -> bytes:
+        return json.dumps(
+            {
+                "response_code": self.response_code,
+                "error": self.error,
+                "detail": self.detail,
+            }
+        ).encode("utf-8")

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/model/service_message_type.html b/api-doc/_build/html/_modules/amqp/model/service_message_type.html new file mode 100644 index 0000000..6848143 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/model/service_message_type.html @@ -0,0 +1,120 @@ + + + + + + + + amqp.model.service_message_type — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.model.service_message_type
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.model.service_message_type

+from enum import Enum, auto
+
+
+

+[docs]
+class ServiceMessageType(Enum):
+    ROUTING_DATA_REQUEST = auto()
+    ROUTING_DATA = auto()
+    ROUTING_DATA_REMOVE = auto()
+    ROUTING_DATA_REPLACE = auto()
+    BACKPRESSURE = auto()
+    UNKNOWN = auto()

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/model/snowflake_id.html b/api-doc/_build/html/_modules/amqp/model/snowflake_id.html new file mode 100644 index 0000000..ec1ad2c --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/model/snowflake_id.html @@ -0,0 +1,204 @@ + + + + + + + + amqp.model.snowflake_id — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.model.snowflake_id

+import struct
+
+
+

+[docs]
+class SnowflakeId:
+    """
+    see https://en.wikipedia.org/wiki/Snowflake_ID
+    """
+
+    SNOWFLAKE_ID_WIDTH = (
+        10  # with in bytes (8 bits each), can be more than long int width (8 bytes)
+    )
+
+

+[docs]
+    def __init__(self, hi_bits_or_bytes=None, lo_bits=None):
+        self.bits = [0, 0]
+        if lo_bits is None:
+            if hi_bits_or_bytes is not None:
+                i = 0
+                shift = 8  # starting from Hi value, which is only 2 bytes wide
+                n = 1
+                while i < len(hi_bits_or_bytes) and i <= self.SNOWFLAKE_ID_WIDTH:
+                    self.bits[n] |= hi_bits_or_bytes[i] << shift
+                    if shift == 0:
+                        n -= 1
+                        shift = 56
+                    else:
+                        shift -= 8
+                    i += 1
+        else:
+            self.bits = [lo_bits, hi_bits_or_bytes]

+
+
+

+[docs]
+    @staticmethod
+    def from_hex(_input):
+        expected_length = 2 * SnowflakeId.SNOWFLAKE_ID_WIDTH
+        if _input is None or len(_input) < expected_length:
+            raise RuntimeError(
+                f"MessageId is {SnowflakeId.SNOWFLAKE_ID_WIDTH * 8} bits wide, it is represented by HEX string "
+                f"of length: {expected_length}, real input: [{_input}] of length: {len(_input) if _input else 0}"
+            )
+
+        bits = [0, 0]
+        n = 1
+        for i in range(0, expected_length, 2):
+            if i == expected_length - (2 * 8):
+                n = 0
+            bits[n] = (bits[n] << 8) | int(_input[i : i + 2], 16)
+
+        return SnowflakeId(bits[1], bits[0])

+
+
+    def __str__(self):
+        _hex = f"{self.bits[1]:016X}{self.bits[0]:016X}"
+        _val = (
+            _hex
+            if len(_hex) <= 2 * SnowflakeId.SNOWFLAKE_ID_WIDTH
+            else _hex[(-2 * SnowflakeId.SNOWFLAKE_ID_WIDTH) :]
+        )
+        return _val.lower()
+
+    def __eq__(self, other):
+        if isinstance(other, SnowflakeId):
+            return self.bits[1] == other.bits[1] and self.bits[0] == other.bits[0]
+        return False
+
+    def __lt__(self, other):
+        if self.bits[1] < other.bits[1]:
+            return True
+        elif self.bits[1] > other.bits[1]:
+            return False
+        return self.bits[0] < other.bits[0]
+
+

+[docs]
+    def get_bytes(self):
+        high = struct.pack("!Q", self.bits[1])
+        low = struct.pack("!Q", self.bits[0])
+        return high[-2:] + low

+
+
+

+[docs]
+    def get_bits(self):
+        return self.bits

+
+
+

+[docs]
+    def as_string(self) -> str:
+        return self.__str__()

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/rabbitmq/rabbit_mq_client.html b/api-doc/_build/html/_modules/amqp/rabbitmq/rabbit_mq_client.html new file mode 100644 index 0000000..4d77373 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/rabbitmq/rabbit_mq_client.html @@ -0,0 +1,374 @@ + + + + + + + + amqp.rabbitmq.rabbit_mq_client — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.rabbitmq.rabbit_mq_client
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.rabbitmq.rabbit_mq_client

+import logging
+from typing import Optional
+
+import aio_pika
+from aio_pika.abc import AbstractRobustExchange, AbstractRobustQueue
+from pika.exchange_type import ExchangeType
+
+from amqp.adapter.data_message_factory import DataMessageFactory
+from amqp.adapter.logging_utils import (
+    logging_debug,
+    logging_error,
+    logging_info,
+    logging_warning,
+)
+from amqp.model.model import AMQRoute, DataMessage
+from amqp.router.router_base import (
+    AMQ_REPLY_TO_EXCHANGE,
+    AMQ_RPC_EXCHANGE,
+    DLQ_EXCHANGE,
+)
+from amqp.router.utils import sanitize_as_rabbitmq_name
+
+
+

+[docs]
+class RabbitMQClient:
+    PREFETCH_COUNT = 1
+    DLQ_ARGS = {"x-dead-letter-exchange": DLQ_EXCHANGE}
+
+

+[docs]
+    def __init__(self, configuration, router):
+        self.channel: aio_pika.RobustChannel | None = None
+        self.connection: aio_pika.RobustConnection | None = None
+        self.rpc_exchange: aio_pika.RobustExchange | None = None
+        self.reply_exchange: aio_pika.RobustExchange | None = None
+        self.amq_configuration = configuration
+        logging.info("*******************************************")
+        logging.info(
+            "******** RabbitMQClient.init(): %s",
+            self.amq_configuration.dispatch.amq_host,
+        )
+        logging.info("*******************************************")
+        self.router = router
+        # this.meterRegistry = new PrometheusMeterRegistry(PrometheusConfig.DEFAULT);
+
+        self.reply_to_exchange: AbstractRobustExchange | None = (
+            None  # when sending response to RPC request
+        )
+        self.reply_to_queue: AbstractRobustQueue | None = (
+            None  # when receiving response to RPC request
+        )

+
+
+

+[docs]
+    async def init(self, loop) -> AbstractRobustExchange:
+        await self.setup_amq_channel(loop)
+        await self.router.init_routing_paths_consumer(self.router.channel)
+        cm_reply_to_queue = self.router.get_reply_to_queue_name()
+        self.reply_to_queue = await self.channel.declare_queue(
+            name=cm_reply_to_queue, durable=True, exclusive=False, auto_delete=False
+        )
+        self.reply_to_exchange = await self.channel.declare_exchange(
+            AMQ_REPLY_TO_EXCHANGE, type=ExchangeType.direct
+        )
+        await self.reply_to_queue.bind(
+            exchange=self.reply_to_exchange, routing_key=cm_reply_to_queue
+        )
+        return self.reply_to_exchange

+
+
+

+[docs]
+    def cleanup(self):
+        logging_info("RabbitMQClient.cleanup()")
+        self.router.cleanup()  # de-register route(s)
+        if self.router.is_open(self.channel):
+            try:
+                self.channel.close()
+                if not self.connection.is_closed:
+                    self.connection.close()
+            except Exception as e:
+                logging_error(
+                    "RabbitMQClient.PreDestroy cleanup - connection close error: %s",
+                    e,
+                )

+
+
+

+[docs]
+    async def register_inbound_routes(self, route_mapping: str, callback):
+        """
+        Register inbound routes for the AMQ adapter. The route mapping is a comma-separated string that contains
+        list of routes. A route is the mapping of domain and path to the exchange and queue name.
+        This method declare (and thus create) the queue and exchange, bind them together using the
+        regex-like routing expression given in the route.
+        After this the Service is listening on (consuming from) the queue for incoming messages.
+        """
+        if self.router.is_open(self.channel):
+            queue_args = self.DLQ_ARGS if self.amq_configuration.dispatch.use_dlq else None
+            logging_info("RabbitMQClient register routes, cfg mapping: [%s]", route_mapping)
+            # convert the comma-separated string into list of AMQRoute objects
+            requested_routes = self.router.unwrap_route_list(route_mapping)
+            for route in requested_routes:
+                try:
+                    # Note: AMQRoute allows one of the exchange or queue to be None, in which case the default is used
+                    queue_name = (
+                        route.queue if route.queue else self.router.get_consume_queue_name()
+                    )
+                    logging_info("RabbitMQClient register route: [%s]", route)
+                    if self.amq_configuration.amq_adapter.callbacks_enabled:
+                        queue: Optional[AbstractRobustQueue] = await self.channel.declare_queue(
+                            name=queue_name,
+                            durable=True,
+                            exclusive=False,
+                            auto_delete=False,
+                            arguments=queue_args,
+                        )
+                    else:
+                        queue = None
+                    _exchange_name: str = route.exchange if route.exchange else AMQ_RPC_EXCHANGE
+                    exchange: AbstractRobustExchange = await self.channel.declare_exchange(
+                        name=_exchange_name, type=ExchangeType.topic
+                    )
+                    if self.amq_configuration.amq_adapter.callbacks_enabled:
+                        await queue.bind(exchange, route.key)
+                        _c_tag = await queue.consume(callback, no_ack=False)
+                    else:
+                        _c_tag = None
+                    # Register the route with the router and publish its detail to other adapters
+                    await self.router.register_route(
+                        AMQRoute(
+                            route.component_name,
+                            _exchange_name,
+                            queue_name,
+                            sanitize_as_rabbitmq_name(route.key),
+                            route.timeout,
+                            route.valid_until,
+                        )
+                    )
+                    logging_info(
+                        " [%s] AMQ connection initialized for route: %s, listens on: %s/%s",
+                        _c_tag,
+                        route,
+                        exchange,
+                        queue_name,
+                    )
+                except Exception as err:
+                    logging_error("Callback registration INCOMPLETE, %s", err)
+        else:
+            logging_warning("Channel is null, cannot register routes.")

+
+
+

+[docs]
+    async def register_data_reply_callback(self, rpc_callback):
+        _c_tag = await self.reply_to_queue.consume(callback=rpc_callback, no_ack=False)
+        logging_info(
+            " [%s] RabbitMQClient register data reply callback on queue: %s",
+            _c_tag,
+            self.reply_to_queue.name,
+        )

+
+
+

+[docs]
+    async def setup_amq_channel(self, loop):
+        """
+        Set up the RabbitMQ connection
+        :return: nothing, it applies changes to instance variables
+        """
+        logging.info(
+            f"RabbitMQClient.setupAMQ, connecting to RabbitMQ at {self.amq_configuration.dispatch.amq_host}:{self.amq_configuration.dispatch.amq_port}, loop={loop}"
+        )
+        self.connection = await aio_pika.connect_robust(
+            host=self.amq_configuration.dispatch.amq_host,
+            port=self.amq_configuration.dispatch.amq_port,
+            login=self.amq_configuration.dispatch.rabbit_mq_user,
+            password=self.amq_configuration.dispatch.rabbit_mq_password,
+            loop=loop,
+        )
+        logging_debug(
+            "RabbitMQClient.setupAMQ, got connection, open=%s",
+            self.connection.is_closed,
+        )
+        self.channel = await self.connection.channel()
+        await self.channel.set_qos(prefetch_count=self.PREFETCH_COUNT)
+        await self.router.init_internal_routing_paths(self.channel)
+        self.router.set_route_added_notifier(
+            lambda route: logging_debug(
+                " RouteAdded, setting up metrics: amqp.adapter.exchange.%s",
+                route.exchange,
+            )
+        )

+
+
+

+[docs]
+    async def send_message(self, message: DataMessage):
+        """
+        The API routine that sends a datagram message (DataMessage) to the destination. The Destination
+        is determined from the DataMessage metadata section, using `domain` and `path` as key.
+        :param message: message to send
+        :return: nothing (void) as submitting message to RabbitMQ exchange does not return anything
+         meaningful. There will be asynch ACK later that will confirm the message was sent to RMQ.
+        """
+        try:
+            route = self.router.find_route_by_message(message)
+            if route and self.rpc_exchange:
+                if route.timeout <= 0:
+                    # No response expected
+                    pika_message: aio_pika.message.Message = aio_pika.message.Message(
+                        body=DataMessageFactory.serialize(message),
+                        content_encoding="utf-8",
+                        delivery_mode=2,
+                    )
+                    await self.rpc_exchange.publish(
+                        message=pika_message,
+                        routing_key=self.router.get_routing_key(
+                            message
+                        ),  # context path is a routing key
+                    )
+                    logging_info(f"Msg Publish (no-reply), messageId: {message.id()}, to: {route}")
+                else:
+                    # This is RPC call, there should be response
+                    pika_message: aio_pika.message.Message = aio_pika.message.Message(
+                        body=DataMessageFactory.serialize(message),
+                        content_encoding="utf-8",
+                        delivery_mode=2,
+                        correlation_id=str(message.id()),
+                        reply_to=self.router.get_reply_to_queue_name(),
+                    )
+                    await self.rpc_exchange.publish(
+                        message=pika_message,
+                        routing_key=self.router.get_routing_key(
+                            message
+                        ),  # context path is a routing key
+                    )
+                    logging_info(
+                        "Msg Publish (RPC call), messageId: %s, to: %s",
+                        message.id().as_string(),
+                        route.as_string(),
+                    )
+            else:
+                logging_warning(
+                    "Message not sent, no route for %s/%s",
+                    message.domain(),
+                    message.path(),
+                )
+
+        except Exception as err:
+            logging_error("Send message failed: %s", err)

+
+
+

+[docs]
+    async def request_routes(self):
+        await self.router.request_routes_from_adapters()

+
+
+

+[docs]
+    def find_route(self, domain: str, path: str) -> AMQRoute:
+        return self.router.find_route(domain, path)

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/rabbitmq/user_management_service_client.html b/api-doc/_build/html/_modules/amqp/rabbitmq/user_management_service_client.html new file mode 100644 index 0000000..ef59ea1 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/rabbitmq/user_management_service_client.html @@ -0,0 +1,397 @@ + + + + + + + + amqp.rabbitmq.user_management_service_client — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.rabbitmq.user_management_service_client
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.rabbitmq.user_management_service_client

+import asyncio
+import json
+import logging
+import uuid
+from typing import Any, Dict, List, Optional
+
+import aio_pika
+from aio_pika import Message
+from aio_pika.abc import AbstractIncomingMessage, AbstractRobustChannel, AbstractRobustConnection
+
+from amqp.adapter.logging_utils import logging_debug, logging_error, logging_info
+from amqp.config.amq_configuration import AMQConfiguration
+
+
+

+[docs]
+class UserManagementServiceException(Exception):
+    """Exception raised for errors in the User Management Service."""
+
+

+[docs]
+    def __init__(self, exception_type: str, message: str, additional_info: Dict[str, Any] = None):
+        self.exception_type = exception_type
+        self.message = message
+        self.additional_info = additional_info or {}
+        super().__init__(f"{exception_type}: {message}")

+

+
+
+
+

+[docs]
+class UserManagementServiceClient:
+    """
+    Client for the User Management Service that communicates over RabbitMQ.
+    Supports operations for token, user, group, tenant, and permission services.
+    """
+
+    # Exchange name for User Management Service
+    EXCHANGE_NAME = "cleverthis.clevermicro.auth.endpoints"
+
+    # Service routing keys
+    TOKEN_SERVICE = "token-service-v1"
+    USER_SERVICE = "user-service-v1"
+    GROUP_SERVICE = "group-service-v1"
+    TENANT_SERVICE = "tenant-service-v1"
+    PERMISSION_SERVICE = "permission-service-v1"
+
+    # Response queue name
+    RESPONSE_QUEUE_NAME = "user-management-service-cleverswarm"
+
+

+[docs]
+    def __init__(self, configuration: AMQConfiguration, loop: asyncio.AbstractEventLoop = None):
+        """
+        Initialize the User Management Service client.
+        
+        Args:
+            configuration: AMQ configuration
+            loop: Event loop to use (optional)
+        """
+        self.amq_configuration = configuration
+        self.loop = loop or asyncio.get_event_loop()
+        self.connection: Optional[AbstractRobustConnection] = None
+        self.channel: Optional[AbstractRobustChannel] = None
+        self.exchange: Optional[aio_pika.RobustExchange] = None
+        self.response_queue: Optional[aio_pika.RobustQueue] = None
+        self.response_consumer_tag: Optional[str] = None
+        self.futures: Dict[str, asyncio.Future] = {}
+        self.initialized = False

+
+
+

+[docs]
+    async def initialize(self) -> None:
+        """Initialize the RabbitMQ connection and set up the exchange and response queue."""
+        if self.initialized:
+            return
+
+        try:
+            # Connect to RabbitMQ
+            self.connection = await aio_pika.connect_robust(
+                host=self.amq_configuration.dispatch.amq_host,
+                port=self.amq_configuration.dispatch.amq_port,
+                login=self.amq_configuration.dispatch.rabbit_mq_user,
+                password=self.amq_configuration.dispatch.rabbit_mq_password,
+                loop=self.loop,
+            )
+
+            # Create channel
+            self.channel = await self.connection.channel()
+            await self.channel.set_qos(prefetch_count=1)
+
+            # Declare exchange
+            self.exchange = await self.channel.declare_exchange(
+                name=self.EXCHANGE_NAME,
+                type=aio_pika.ExchangeType.TOPIC,
+                durable=True,
+            )
+
+            # Declare response queue
+            self.response_queue = await self.channel.declare_queue(
+                name=self.RESPONSE_QUEUE_NAME,
+                durable=True,
+                exclusive=False,
+                auto_delete=False,
+            )
+
+            # Start consuming responses
+            self.response_consumer_tag = await self.response_queue.consume(
+                self._on_response_callback,
+                no_ack=False,
+            )
+
+            self.initialized = True
+            logging_info("User Management Service client initialized")
+
+        except Exception as e:
+            logging_error(f"Failed to initialize User Management Service client: {e}")
+            if self.connection and not self.connection.is_closed:
+                await self.connection.close()
+            raise

+
+
+    async def _on_response_callback(self, message: AbstractIncomingMessage) -> None:
+        """
+        Handle responses from the User Management Service.
+        
+        Args:
+            message: The incoming message
+        """
+        try:
+            correlation_id = message.correlation_id
+            if not correlation_id:
+                logging_error("Received response without correlation ID")
+                await message.ack()
+                return
+
+            future = self.futures.get(correlation_id)
+            if not future:
+                logging_error(f"No pending request found for correlation ID: {correlation_id}")
+                await message.ack()
+                return
+
+            try:
+                response_data = json.loads(message.body.decode('utf-8'))
+                logging_debug(f"Received response: {response_data}")
+                future.set_result(response_data)
+            except Exception as e:
+                future.set_exception(e)
+
+            await message.ack()
+
+        except Exception as e:
+            logging_error(f"Error processing response: {e}")
+            await message.ack()
+
+

+[docs]
+    async def close(self) -> None:
+        """Close the RabbitMQ connection."""
+        if self.connection and not self.connection.is_closed:
+            await self.connection.close()
+            self.initialized = False
+            logging_info("User Management Service client closed")

+
+
+

+[docs]
+    async def call_service(
+        self, service: str, method: str, args: Dict[str, Any] = None
+    ) -> Dict[str, Any]:
+        """
+        Call a method on a User Management Service.
+        
+        Args:
+            service: Service routing key (e.g., 'token-service-v1')
+            method: Method name to call
+            args: Method arguments
+            
+        Returns:
+            Response data
+            
+        Raises:
+            UserManagementServiceException: If the service returns an error
+        """
+        if not self.initialized:
+            await self.initialize()
+
+        correlation_id = str(uuid.uuid4())
+        future = self.loop.create_future()
+        self.futures[correlation_id] = future
+
+        request_data = {
+            "method": method,
+            "args": args or {},
+        }
+
+        message = Message(
+            body=json.dumps(request_data).encode('utf-8'),
+            content_type='application/json',
+            correlation_id=correlation_id,
+            reply_to=self.RESPONSE_QUEUE_NAME,
+        )
+
+        try:
+            await self.exchange.publish(message, routing_key=service)
+            logging_info(f"Sent request to {service}.{method}: {args}")
+
+            # Wait for response
+            response = await future
+
+            # Process response
+            if response.get("type") == "OK":
+                return response.get("result", [])
+            else:
+                raise UserManagementServiceException(
+                    response.get("exception", "unknown_error"),
+                    response.get("message", "Unknown error"),
+                    response.get("additional_info", {})
+                )
+
+        except asyncio.CancelledError:
+            raise
+        except UserManagementServiceException:
+            raise
+        except Exception as e:
+            logging_error(f"Error calling service {service}.{method}: {e}")
+            raise
+        finally:
+            self.futures.pop(correlation_id, None)

+
+
+

+[docs]
+    async def validate_token(self, token: str) -> Dict[str, Any]:
+        """
+        Validate a JWT token.
+        
+        Args:
+            token: JWT token to validate
+            
+        Returns:
+            Token information
+        """
+        return await self.call_service(
+            service=self.TOKEN_SERVICE,
+            method="validateToken",
+            args={"token": token}
+        )

+
+
+

+[docs]
+    async def query_user_by_id(self, user_id: str) -> Dict[str, Any]:
+        """
+        Query user information by user ID.
+        
+        Args:
+            user_id: User ID
+            
+        Returns:
+            User information
+        """
+        return await self.call_service(
+            service=self.USER_SERVICE,
+            method="queryUserById",
+            args={"userId": user_id}
+        )

+
+
+

+[docs]
+    async def list_users_in_group(self, group_id: str) -> List[Dict[str, Any]]:
+        """
+        List users in a group.
+        
+        Args:
+            group_id: Group ID
+            
+        Returns:
+            List of users
+        """
+        return await self.call_service(
+            service=self.GROUP_SERVICE,
+            method="listUsersInGroup",
+            args={"groupId": group_id}
+        )

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/router/route_database.html b/api-doc/_build/html/_modules/amqp/router/route_database.html new file mode 100644 index 0000000..d102fe4 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/router/route_database.html @@ -0,0 +1,209 @@ + + + + + + + + amqp.router.route_database — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.router.route_database

+import re
+from typing import Optional, Set
+
+from amqp.adapter.logging_utils import logging_info
+from amqp.model.model import AMQRoute
+from amqp.router.utils import sanitize_as_rabbitmq_name
+
+
+

+[docs]
+class RouteDatabase:
+

+[docs]
+    def __init__(self):
+        self.routes: Set[AMQRoute] = set()

+
+
+

+[docs]
+    def get_routes(self) -> Set[AMQRoute]:
+        return self.routes

+
+
+

+[docs]
+    def pattern(self, routing_key: str) -> re.Pattern:
+        breaker = False
+        tokens = routing_key.split(".")
+        counter = len(tokens)
+        regex_parts = []
+
+        for token in tokens:
+            counter -= 1
+            if not breaker:
+                if token == "":
+                    res = "[^\\.]*"
+                elif token == "#":
+                    breaker = True
+                    res = ".*$"
+                else:
+                    res = token
+                if counter > 0 and not breaker:
+                    res += "\\."
+                regex_parts.append(res)
+            else:
+                regex_parts.append("")
+
+        regex = "".join(filter(lambda x: x != "", regex_parts))
+        if not routing_key:
+            return re.compile(".*")
+        return re.compile(regex)

+
+
+

+[docs]
+    def matches(self, routing_key_from_route: str, routing_key_from_message: str) -> bool:
+        route_pattern = self.pattern(routing_key_from_route)
+        return bool(route_pattern.match(sanitize_as_rabbitmq_name(routing_key_from_message)))

+
+
+

+[docs]
+    def wrap_routes(self) -> str:
+        return ",".join(str(route) for route in self.routes)

+
+
+

+[docs]
+    def find_route(self, domain: str, path: str) -> AMQRoute | None:
+        routing_key = sanitize_as_rabbitmq_name(f"{domain}.{path}")
+        logging_info(f"findRoute key:{routing_key} in:{self.wrap_routes()}")
+        for route in self.routes:
+            if self.matches(route.key, routing_key):
+                return route
+        return None

+
+
+

+[docs]
+    def find_route_by_service(self, service_name: str) -> Optional[AMQRoute]:
+        logging_info(f"findRoute service_name:{service_name} in:{self.wrap_routes()}")
+        for route in self.routes:
+            if route.component_name == service_name:
+                return route
+        return None

+
+
+

+[docs]
+    def add_route(self, route: AMQRoute) -> bool:
+        if route not in self.routes:
+            self.routes.add(route)
+            return True
+        return False

+
+
+

+[docs]
+    def remove_route(self, route: AMQRoute) -> bool:
+        return route in self.routes and self.routes.remove(route)

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/router/router_base.html b/api-doc/_build/html/_modules/amqp/router/router_base.html new file mode 100644 index 0000000..f870aca --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/router/router_base.html @@ -0,0 +1,258 @@ + + + + + + + + amqp.router.router_base — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.router.router_base

+from typing import Callable, List, Optional, Set
+
+from amqp.adapter.amq_route_factory import NULL_ROUTE, AMQRouteFactory
+from amqp.adapter.logging_utils import logging_debug, logging_error, logging_info
+from amqp.model.model import AMQRoute, DataMessage
+from amqp.router.route_database import RouteDatabase
+from amqp.router.utils import sanitize_as_rabbitmq_name
+
+CM_REQUEST_EXCHANGE = "CM-Request"
+CM_RESPONSE_EXCHANGE = "CM-Response"
+CM_C_REQ_QUEUE = "C-REQ"
+CM_C_RESP_QUEUE = "C-RESP"
+CM_C_AMQ_QUEUE = "C-AMQ"
+CM_P_RESP_QUEUE = "P-RESP"
+CM_P_REPLY_TO = "P-REPLY-TO"
+ANY_RECIPIENT = "*"
+AMQ_RPC_EXCHANGE = "AMQ-RPC"
+AMQ_REPLY_TO_EXCHANGE = "AMQ-REPLY-TO"
+DLQ_EXCHANGE = "DLX"
+
+
+

+[docs]
+class RouterBase:
+

+[docs]
+    def __init__(self):
+        self.route_database = RouteDatabase()
+        self.own_routes: Set[AMQRoute] = set()
+        self.route_added_notifier: Callable[[AMQRoute], None] | None = None
+        self.route_removed_notifier: Callable[[AMQRoute], None] | None = None

+
+
+

+[docs]
+    def get_routing_key(self, message: DataMessage) -> str:
+        return sanitize_as_rabbitmq_name(f"{message.domain()}.{message.path()}")

+
+
+

+[docs]
+    def wrap_routes(self) -> str:
+        return self.route_database.wrap_routes()

+
+
+

+[docs]
+    def wrap_own_routes(self) -> str:
+        return ",".join(str(route) for route in self.own_routes)

+
+
+

+[docs]
+    def unwrap_route_list(self, route_string: str) -> List[AMQRoute]:
+        logging_debug("RouterMaster.unwrapRoutes, route(s): %s", route_string)
+        routes = [AMQRouteFactory.from_string(route_str) for route_str in route_string.split(",")]
+        return [route for route in routes if route != NULL_ROUTE]

+
+
+

+[docs]
+    def get_routes(self) -> Set[AMQRoute]:
+        return self.route_database.get_routes()

+
+
+

+[docs]
+    def find_route(self, domain: str, path: str) -> AMQRoute | None:
+        return self.route_database.find_route(domain, path)

+
+
+

+[docs]
+    def find_route_by_message(self, message: DataMessage) -> AMQRoute | None:
+        return self.route_database.find_route(message.domain(), message.path())

+
+
+

+[docs]
+    def find_route_by_service(self, service_name: str) -> Optional[AMQRoute]:
+        _route: Optional[AMQRoute] = self.route_database.find_route_by_service(service_name)
+        if _route is None:
+            for route in self.own_routes:
+                if route.component_name == service_name:
+                    _route = route
+        return _route

+
+
+

+[docs]
+    def add_routes(self, message: str) -> None:
+        try:
+            amq_route_list = self.unwrap_route_list(message)
+            logging_info(" [DBG] RouterMaster.addRoute [%d]: %s", len(amq_route_list), message)
+            for route in amq_route_list:
+                logging_info("RouterMaster.addRoute, adding route: %s", route)
+                if not route.exchange and not route.queue and not route.key:
+                    logging_error(
+                        "Cannot setup AMQ Exchange for '%s', at least one of "
+                        "Exchange, Queue and/or Key must be present in the routing string. "
+                        "Expected format is '%s'",
+                        route,
+                        AMQRoute.FORMAT,
+                    )
+                else:
+                    if route.exchange != DLQ_EXCHANGE:
+                        is_new_route = self.route_database.add_route(route)
+                        if is_new_route and self.route_added_notifier:
+                            self.route_added_notifier(route)
+        except Exception as err:
+            logging_error("add_routes error: %s", err)

+
+
+

+[docs]
+    def set_route_added_notifier(self, callback: Callable[[AMQRoute], None]):
+        self.route_added_notifier = callback

+
+
+

+[docs]
+    def remove_routes(self, message: str) -> None:
+        try:
+            to_remove = [AMQRouteFactory.from_string(route_str) for route_str in message.split(",")]
+            removed_count = sum(1 for route in to_remove if self.remove_route(route))
+            logging_info(f"RouterMaster.removeRoutes(): {message}, removed={removed_count}")
+        except IOError as err:
+            logging_error(f"Can't remove route(s): {err}")

+
+
+

+[docs]
+    def remove_route(self, route: AMQRoute) -> bool:
+        is_route_removed = self.route_database.remove_route(route)
+        if is_route_removed and self.route_removed_notifier:
+            self.route_removed_notifier(route)
+        return is_route_removed

+
+
+

+[docs]
+    def add_route(self, route: AMQRoute) -> None:
+        self.route_database.add_route(route)

+
+
+

+[docs]
+    def add_own_route(self, route: AMQRoute) -> None:
+        self.own_routes.add(route)

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/router/router_consumer.html b/api-doc/_build/html/_modules/amqp/router/router_consumer.html new file mode 100644 index 0000000..947f9ea --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/router/router_consumer.html @@ -0,0 +1,328 @@ + + + + + + + + amqp.router.router_consumer — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.router.router_consumer

+from typing import Set
+
+from aio_pika.abc import (
+    AbstractIncomingMessage,
+    AbstractRobustChannel,
+    AbstractRobustQueue,
+)
+
+from amqp.adapter.amq_route_factory import AMQRouteFactory
+from amqp.adapter.logging_utils import (
+    logging_debug,
+    logging_error,
+    logging_info,
+    logging_warning,
+)
+from amqp.config.amq_configuration import AMQConfiguration
+from amqp.model.model import AMQRoute, ServiceMessage
+from amqp.model.service_message_type import ServiceMessageType
+from amqp.router.router_base import (
+    ANY_RECIPIENT,
+    CM_C_REQ_QUEUE,
+    CM_REQUEST_EXCHANGE,
+    CM_RESPONSE_EXCHANGE,
+)
+from amqp.router.router_producer import RouterProducer
+
+
+

+[docs]
+class RouterConsumer(RouterProducer):
+    """
+    * Contains Consumer logic. The logic here:
+    * Sets a listener on CM_C_REQ_QUEUE queue to receive routing data requests
+    * Upon receipt of routing data request, responds on CM_RESPONSE_EXCHANGE with local routing data.
+    * It also proactively pushes the local routing data to CM_RESPONSE_EXCHANGE on startup to
+    * notify the other (excluding self) Producers about its presence.
+    *
+    * Consumer is also Producer (Consumer sits alongside the CM Service, and anytime the Service needs
+    * to communicate with other Service, it can do so via the Adapter). Therefore, the Producer
+    * capability is also required.
+    """
+
+

+[docs]
+    def __init__(self, configuration: AMQConfiguration):
+        super().__init__(configuration)
+        self.amqRouteFactory = AMQRouteFactory()
+        logging_info("RouterConsumer.<init>")

+
+
+

+[docs]
+    async def init_routing_paths_consumer(self, _channel: AbstractRobustChannel):
+        """
+        * Initialize router according to Consumer mode.
+        """
+        logging_info(
+            "RouterConsumer.initConsumerRouter, channel open: %s",
+            self.is_open(_channel),
+        )
+        if self.is_open(_channel):
+            try:
+                #  1. declare a Queue to receive the RoutingData requests
+                _cm_request_queue: str = (
+                    self.amq_configuration.amq_adapter.adapter_prefix() + CM_C_REQ_QUEUE
+                )
+                _queue: AbstractRobustQueue = await self.channel.declare_queue(
+                    name=_cm_request_queue,
+                    durable=True,
+                    exclusive=False,
+                    auto_delete=False,
+                )
+                # 1a. bind queue to CM_REQUEST_EXCHANGE w/o any conditions (empty routing key)
+                await _queue.bind(exchange=CM_REQUEST_EXCHANGE, routing_key="")
+                # 1b. Service adapter mode - listens on Request queue and replies to Response queue
+                _c_tag = await _queue.consume(
+                    callback=self.handle_routing_data_request_message, no_ack=False
+                )
+                logging_info(
+                    " [%s] RouterConsumer listens for RouteDataRequests on: %s",
+                    _c_tag,
+                    _cm_request_queue,
+                )
+            except Exception as ioe:
+                logging_error("RouterConsumer FATAL: cannot initialize, %s", ioe)
+        else:
+            logging_error("RouterConsumer FATAL: cannot initialize, RabbitMQ channel is not open.")

+
+
+    """
+     * ServiceMessageType.ROUTING_DATA_REQUEST  handler  listening on queue 'CleverMicroRequest'
+    """
+
+

+[docs]
+    async def handle_routing_data_request_message(self, message: AbstractIncomingMessage):
+        # some debug statements, TODO - remove for prod release
+        delivery_tag = message.delivery_tag
+        debug = "Delivery.Properties = " + message.properties.__str__()
+        logging_debug(
+            " ******[%s] (ROUTING_DATA_REQ) tag: %s, env: %s, props: %s",
+            delivery_tag,
+            message.consumer_tag,
+            message.properties,
+            debug,
+        )
+
+        await message.ack(False)
+
+        cm_message: ServiceMessage = self.service_message_factory.from_bytes(message.body)
+        route_mapping: str = self.wrap_own_routes()
+        logging_debug(
+            "******[%s] (ROUTING_DATA_REQ) msg=%s, routeMap=[%s]",
+            delivery_tag,
+            self.service_message_factory.to_string(cm_message),
+            route_mapping,
+        )
+        # Reply only if self adapter has own routeMapping (e.g. API-gateway-side adapter has none)
+        if (
+            cm_message.is_valid()
+            and cm_message.message_type == ServiceMessageType.ROUTING_DATA_REQUEST
+            and route_mapping
+        ):
+            if cm_message.reply_to != self.amq_configuration.amq_adapter.service_name:
+                try:
+                    service_message: ServiceMessage = self.service_message_factory.of(
+                        ServiceMessageType.ROUTING_DATA,
+                        route_mapping,
+                        cm_message.reply_to,
+                    )
+                    await self.publish_service_message(service_message, self.cm_response_exchange)
+                except Exception as err:
+                    logging_error(
+                        "******[%s] (ROUTING_DATA_REQ) Response to queue: %s failed: %s",
+                        delivery_tag,
+                        CM_RESPONSE_EXCHANGE,
+                        err,
+                    )
+            else:
+                logging_info(
+                    "******[%s] (ROUTING_DATA_REQ) [%s] Ignore request originated by ourselves.",
+                    delivery_tag,
+                    str(message.body),
+                )
+        else:
+            logging_error(
+                "******[%s] (ROUTING_DATA_REQ) [%s] produces invalid or no CM msg type.",
+                delivery_tag,
+                str(message.body),
+            )

+
+
+

+[docs]
+    async def register_route(self, route: AMQRoute):
+        """
+        * Called in Consumer (Service Adapter) context. Registers the routing data for self Service
+        * with the Master router by sending own routing data to Master via CleverMicroResponse queue.
+        * :param route: route to register with Master
+        """
+        try:
+            if self.is_open(self.channel) and route.queue:
+                serviceMessage: ServiceMessage = self.service_message_factory.of(
+                    ServiceMessageType.ROUTING_DATA, route.as_string(), ANY_RECIPIENT
+                )
+                await self.publish_service_message(serviceMessage, self.cm_response_exchange)
+                self.add_own_route(route)
+                logging_info("RouterConsumer registered Route: %s", route)
+            else:
+                logging_warning(
+                    "RouterConsumer couldn't register route data: %s channel isn't open.",
+                    CM_RESPONSE_EXCHANGE,
+                )
+        except Exception as ioe:
+            logging_error("RouterConsumer failed register route data: %s", ioe)

+
+
+

+[docs]
+    async def remove_route_on_cleanup(self, route: AMQRoute) -> bool:
+        """
+        * Unregister / remove route from the list
+        * :param route: route to remove
+        * :return result of remove operation
+        """
+        logging_info("RouterConsumer.removeRoute, route: %s", route.as_string())
+        try:
+            service_message: ServiceMessage = self.service_message_factory.of(
+                ServiceMessageType.ROUTING_DATA_REMOVE, route.as_string(), ANY_RECIPIENT
+            )
+            if not await self.publish_service_message(service_message, self.cm_response_exchange):
+                logging_warning(
+                    "RouterConsumer couldn't remove current_availability route: %s, channel not open.",
+                    route,
+                )
+
+        except Exception as ioe:
+            logging_error("RouterConsumer failed remove current_availability route: %s", ioe)
+
+        result: bool = self.remove_route(route)
+        return result

+
+
+

+[docs]
+    def cleanup(self):
+        """
+        * Cleanup - de-register routes with master.
+        """
+        routes: Set[AMQRoute] = self.get_routes()
+        logging_info("RouterConsumer.cleanup() [%d]: %s", len(routes), self.wrap_routes())
+        not_removed = sum(
+            1 for r in (self.remove_route_on_cleanup(route) for route in routes) if not r
+        )
+        if not_removed > 0:
+            logging_warning(
+                "%d route(s) not removed. self may lead to failed delivery on self route",
+                not_removed,
+            )

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/router/router_producer.html b/api-doc/_build/html/_modules/amqp/router/router_producer.html new file mode 100644 index 0000000..cbd3e79 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/router/router_producer.html @@ -0,0 +1,362 @@ + + + + + + + + amqp.router.router_producer — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.router.router_producer

+"""
+* Maps the request to RabbitMQ exchange. Handles the service discovery logic.
+*
+* Router can be either in 'Master' or 'Service (Consumer)' modes. 'Master' mode is the outward
+* facing side that receives the requests and routes it to queue associated with requested service.
+* 'Service' mode is consumer side for given service, which receives the message from AMQ and
+* forwards it to the application.
+"""
+
+from aio_pika import Message
+from aio_pika.abc import (
+    AbstractIncomingMessage,
+    AbstractRobustChannel,
+    AbstractRobustConnection,
+    AbstractRobustExchange,
+    AbstractRobustQueue,
+)
+from pika.exchange_type import ExchangeType
+
+from amqp.adapter.logging_utils import (
+    logging_debug,
+    logging_error,
+    logging_info,
+    logging_warning,
+)
+from amqp.adapter.service_message_factory import ServiceMessageFactory
+from amqp.config.amq_configuration import AMQConfiguration
+from amqp.model.model import ServiceMessage
+from amqp.model.service_message_type import ServiceMessageType
+from amqp.router.router_base import (
+    ANY_RECIPIENT,
+    CM_C_AMQ_QUEUE,
+    CM_P_REPLY_TO,
+    CM_P_RESP_QUEUE,
+    CM_REQUEST_EXCHANGE,
+    CM_RESPONSE_EXCHANGE,
+    RouterBase,
+)
+
+
+

+[docs]
+class RouterProducer(RouterBase):
+
+

+[docs]
+    def __init__(self, configuration: AMQConfiguration):
+        """
+        * Initialize router - need to supply the config values and RabbitMQ channel.
+        * :param configuration:  adapter's configuration reference.
+        """
+        super().__init__()
+        self.connection: AbstractRobustConnection | None = None
+        self.service_message_factory = ServiceMessageFactory(configuration.amq_adapter.service_name)
+        self.amq_configuration: AMQConfiguration = configuration
+        self.channel: AbstractRobustChannel | None = None
+        self.cm_request_exchange: AbstractRobustExchange | None = None
+        self.cm_response_exchange: AbstractRobustExchange | None = None
+
+        logging_info(
+            "RouterProducer.<init>: %s, route: %s",
+            self.amq_configuration.amq_adapter.service_name,
+            self.amq_configuration.amq_adapter.route_mapping,
+        )

+
+
+

+[docs]
+    async def init_internal_routing_paths(self, channel: AbstractRobustChannel | None):
+        """
+        * Initialize internal routes for ServiceMessages.
+        * The logic here sets a producer and listener on CleverMicroRequest/CleverMicroResponse queues
+        * created to enable the service discovery.
+        * The Producer mode sends out routing data request on CleverMicroRequest and listens
+        * on CleverMicroResponse for any service responding with its routing data.
+        """
+
+        self.channel = channel
+        logging_info(
+            "RouterProducer.initRoutingPaths, channel open: %s",
+            self.is_open(self.channel),
+        )
+        if self.is_open(self.channel):
+            try:
+                # **** set up the service discovery internal exchanges ****
+                # 1. declare RequestExchange to where to publish the RoutingData requests
+                self.cm_request_exchange = await self.channel.declare_exchange(
+                    name=CM_REQUEST_EXCHANGE, type=ExchangeType.fanout
+                )
+                #
+                # 2. declare ResponseExchange where to publish current_availability RoutingData (response to
+                #    a RoutingData request)
+                self.cm_response_exchange = await self.channel.declare_exchange(
+                    name=CM_RESPONSE_EXCHANGE, type=ExchangeType.fanout
+                )
+                # 2a. declare a Response queue for Routing Data replies from Services
+                _cm_response_queue: str = self.get_response_queue_name()
+                _response_queue: AbstractRobustQueue = await self.channel.declare_queue(
+                    name=_cm_response_queue,
+                    durable=True,
+                    exclusive=False,
+                    auto_delete=False,
+                    arguments={},
+                )
+                # 2b. bind queue to CM_RESPONSE_EXCHANGE w/o any conditions (empty routing key)
+                await _response_queue.bind(exchange=CM_RESPONSE_EXCHANGE, routing_key="#")
+                # 2c. listen for incoming RoutingData messages
+                _c_tag = await _response_queue.consume(
+                    callback=self.handle_routing_data_message, no_ack=False
+                )
+                logging_info(
+                    " [%s] Routing master listens for Route updates on %s",
+                    _c_tag,
+                    _cm_response_queue,
+                )
+            except Exception as ioe:
+                logging_error("RouterProducer FATAL: cannot initialize, %s", ioe)
+
+        else:
+            logging_error("RouterProducer FATAL: cannot initialize, RabbitMQ channel is not open.")

+
+
+

+[docs]
+    async def handle_routing_data_message(self, message: AbstractIncomingMessage):
+        """
+        * Handler for CLEVER_MICRO_RESPONSE queue messages. Used in Master mode to handle receipt of
+        * routing data, invokes addRoute or removeRoute depending on the type of the message.
+        """
+        logging_info(
+            "[%s] Received ROUTING DATA: [%s], msgId=%s",
+            message.delivery_tag,
+            message.body,
+            message.message_id,
+        )
+        await message.ack(multiple=False)
+        cm_message: ServiceMessage = self.service_message_factory.from_bytes(message.body)
+        # ignore the message if it comes from ourselves (even if from different instance)
+        logging_debug(
+            "******[%s] ROUTING_DATA, msg=%s, routeMap=[%s] sn=%s, replyTo=%s",
+            message.delivery_tag,
+            self.service_message_factory.to_string(cm_message),
+            self.amq_configuration.amq_adapter.route_mapping,
+            self.amq_configuration.amq_adapter.service_name,
+            cm_message.reply_to,
+        )
+        if (
+            cm_message.is_valid()
+            and not self.amq_configuration.amq_adapter.service_name == cm_message.reply_to
+        ):
+            if cm_message.message_type == ServiceMessageType.ROUTING_DATA:
+                self.add_routes(cm_message.message)
+            if cm_message.message_type == ServiceMessageType.ROUTING_DATA_REMOVE:
+                self.remove_routes(cm_message.message)

+
+
+

+[docs]
+    async def request_routes_from_adapters(self):
+        """
+        * Send a broadcast message prompting all listening adapters to reply with own routing data.
+        """
+        logging_info(
+            "RouterProducer.requestRoutesFromAdapters, queue name: %s",
+            CM_REQUEST_EXCHANGE,
+        )
+        try:
+            serviceMessage: ServiceMessage = self.service_message_factory.of(
+                ServiceMessageType.ROUTING_DATA_REQUEST, "", ANY_RECIPIENT
+            )
+            if not await self.publish_service_message(serviceMessage, self.cm_request_exchange):
+                logging_warning(
+                    "RouterProducer could not request route data: %s channel is not open.",
+                    CM_REQUEST_EXCHANGE,
+                )
+
+        except Exception as ioe:
+            logging_error("RouterProducer failed request routing data: %s", ioe)

+
+
+

+[docs]
+    async def publish_service_message(
+        self, message: ServiceMessage, exchange: AbstractRobustExchange
+    ) -> bool:
+        """
+        * Publishes a service message to the service queue and logs success log entry.
+        *
+        * :param message:   Service Message to be sent
+        * :param exchange: target exchange name where to publish the message
+        * :return True if channel is open, False otherwise
+        * @throws IOException if something else goes wrong
+        """
+        if self.is_open(self.channel):
+            binary_content: bytes = self.service_message_factory.serialize(message)
+            pika_message: Message = Message(
+                body=binary_content,
+                content_encoding="utf-8",
+                delivery_mode=2,
+                content_type="application/octet-stream",
+                headers=None,
+                priority=0,
+                correlation_id=None,
+            )
+            await exchange.publish(message=pika_message, routing_key="")
+            logging_info(
+                "Service Message Published to %s, msg: %s",
+                exchange.name,
+                str(binary_content),
+            )
+            return True
+        return False

+
+
+

+[docs]
+    def get_reply_to_queue_name(self) -> str:
+        """
+        * self should create a unique name for self process and also when there's several instances.
+        * @return unique reply-to queue name.
+        """
+        return self.amq_configuration.amq_adapter.adapter_prefix() + CM_P_REPLY_TO

+
+
+

+[docs]
+    def get_response_queue_name(self) -> str:
+        """
+        * self should create a unique name for self process and also when there's several instances.
+        * @return unique reply-to queue name.
+        """
+        return self.amq_configuration.amq_adapter.adapter_prefix() + CM_P_RESP_QUEUE

+
+
+

+[docs]
+    def get_consume_queue_name(self) -> str:
+        """
+        * self should create a unique name for self process and also when there's several instances.
+        * @return unique reply-to queue name.
+        """
+        return self.amq_configuration.amq_adapter.adapter_prefix() + CM_C_AMQ_QUEUE

+
+
+

+[docs]
+    def is_open(self, _channel: AbstractRobustChannel) -> bool:
+        """
+        * Test if the channel is usable (opened).
+        * :param _channel: the channel
+        * :return True if the channel is opened.
+        """
+        return _channel is not None and not _channel.is_closed

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/router/utils.html b/api-doc/_build/html/_modules/amqp/router/utils.html new file mode 100644 index 0000000..757ee20 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/router/utils.html @@ -0,0 +1,156 @@ + + + + + + + + amqp.router.utils — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.router.utils

+import asyncio
+import re
+
+pattern = re.compile(r"[^a-zA-Z0-9.#/\-]")
+AWAIT_SLEEP = 0.05  # seconds
+
+
+

+[docs]
+def sanitize_as_rabbitmq_name(input_str: str) -> str:
+    matcher = pattern.search(input_str)
+    token = input_str[: matcher.start()] if matcher else input_str
+    return sanitize_as_rabbitmq_domain_name(token)

+
+
+
+

+[docs]
+def sanitize_as_rabbitmq_domain_name(token: str) -> str:
+    # Step 1: Replace non-alphanumeric characters (except periods) with a period
+    step1 = re.sub(r"[^A-Za-z0-9.#]", ".", token)
+    # Step 2: Replace multiple consecutive periods with a single period
+    step2 = re.sub(r"\.+", ".", step1)
+    # Step 3: Remove trailing '.' character, if applicable
+    step_last_char = len(step2) - 1
+    return step2[:-1] if step_last_char > 0 and step2[step_last_char] == "." else step2

+
+
+
+

+[docs]
+async def await_future(future: asyncio.Future, sleep_time=AWAIT_SLEEP):
+    """
+    Wait for a future to complete.
+    """
+    while not future.done():
+        await asyncio.sleep(sleep_time)

+
+
+
+

+[docs]
+async def await_result(future: asyncio.Future, sleep_time=AWAIT_SLEEP):
+    """
+    Wait for a future to complete and return its result.
+    """
+    await await_future(future, sleep_time=sleep_time)
+    return future.result()

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/service/amq_message_handler.html b/api-doc/_build/html/_modules/amqp/service/amq_message_handler.html new file mode 100644 index 0000000..6f29167 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/service/amq_message_handler.html @@ -0,0 +1,692 @@ + + + + + + + + amqp.service.amq_message_handler — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Module code
    • +
  • amqp.service.amq_message_handler
    • +
  • +
    • +
+
+
+
+
+ +

Source code for amqp.service.amq_message_handler

+import asyncio
+import importlib
+import inspect
+import os
+import threading
+import time
+from asyncio import AbstractEventLoop, Future
+from typing import Any, Dict
+
+from aio_pika import Message
+from aio_pika.abc import AbstractIncomingMessage, AbstractRobustExchange
+from opentelemetry import trace
+from opentelemetry.trace import Tracer, TraceState
+from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
+from pika.exchange_type import ExchangeType
+
+from amqp.adapter.backpressure_handler import BackpressureHandler
+from amqp.adapter.cleverthis_service_adapter import AMQMessage, CleverThisServiceAdapter
+from amqp.adapter.data_message_factory import DataMessageFactory
+from amqp.adapter.data_response_factory import DataResponseFactory
+from amqp.adapter.file_handler import FileHandler, StreamingFileHandler
+from amqp.adapter.logging_utils import logging_debug, logging_error, logging_info
+from amqp.adapter.serializer import map_as_string, parse_map_string
+from amqp.adapter.service_message_factory import ServiceMessageFactory
+from amqp.config.amq_configuration import AMQConfiguration
+from amqp.model.model import (
+    DataMessage,
+    DataMessageMagicByte,
+    DataResponse,
+    MultipartDataMessage,
+)
+from amqp.rabbitmq.rabbit_mq_client import RabbitMQClient
+from amqp.router.utils import sanitize_as_rabbitmq_name
+
+
+

+[docs]
+def collect_trace_info():
+    trace_map = {}
+    TraceContextTextMapPropagator().inject(
+        carrier=trace_map, context=trace.context_api.get_current()
+    )
+    return trace_map

+
+
+
+

+[docs]
+def get_default_trace_state():
+    return TraceState(entries={})

+
+
+
+

+[docs]
+def set_text(carrier, key, value):
+    carrier[key] = value

+
+
+
+

+[docs]
+async def invoke_command(
+    package_name: str, class_name: str, function_name: str, msg_id: str = "", kwargs=None
+) -> Any:
+    if kwargs is None:
+        kwargs = {}
+    try:
+        # 1. Dynamically import the package
+        logging_info(f"Attempting to import package: {package_name}")
+        package = importlib.import_module(package_name)
+        logging_info(f"Package '{package_name}' imported successfully.")
+
+        target_callable = None
+
+        if class_name == "__global__":
+            # 2. Handle global function invocation
+            logging_info(f"Attempting to find global function: {function_name} in {package_name}")
+            target_callable = getattr(package, function_name)
+            logging_info(f"Global function '{function_name}' found.")
+        else:
+            # 3. Handle class method invocation
+            logging_info(f"Attempting to find class: {class_name} in {package_name}")
+            target_class = getattr(package, class_name)
+            logging_info(f"Class '{class_name}' found. Instantiating...")
+
+            # Instantiate the class. Assuming a default constructor or one that doesn't
+            # require arguments from kwargs for initialization.
+            # If the class __init__ needs specific arguments, this part might need adjustment
+            # based on how those arguments are provided.
+            instance = target_class()
+            logging_info(f"Instance of '{class_name}' created.")
+
+            logging_info(f"Attempting to find method: {function_name} in class {class_name}")
+            target_callable = getattr(instance, function_name)
+            logging_info(f"Method '{function_name}' found.")
+
+        # 4. Invoke the function/method
+        logging_info(f"Invoking '{function_name}' with arguments: {kwargs}")
+        if inspect.iscoroutinefunction(target_callable):
+            result = await target_callable(**kwargs)
+            logging_info(f"Asynchronous function '{function_name}' invoked. Result: {result}")
+        else:
+            result = target_callable(**kwargs)
+            logging_info(f"Synchronous function '{function_name}' invoked. Result: {result}")
+
+        response: DataResponse = DataResponseFactory.of(
+            id=msg_id,
+            response_code=200,
+            content_type="text/plain",
+            body=result.encode("utf-8"),
+            trace_info=collect_trace_info(),
+            error=None,
+            error_cause=None,
+        )
+        response._magic = DataMessageMagicByte.RPC_REQUEST.value
+        return response
+
+    except ModuleNotFoundError as e:
+        logging_error(f"Error: Package '{package_name}' not found. {e}")
+        raise
+    except AttributeError as e:
+        logging_error(
+            f"Error: Class '{class_name}' or function/method '{function_name}' not found in '{package_name}'. {e}"
+        )
+        raise
+    except Exception as e:
+        logging_error(f"An unexpected error occurred during invocation: {e}")
+        raise

+
+
+
+

+[docs]
+class DataMessageHandler:
+

+[docs]
+    def __init__(
+        self,
+        service_adapter: CleverThisServiceAdapter,
+        tracer: Tracer,
+        message_factory: DataMessageFactory,
+        service_message_factory: ServiceMessageFactory,
+        reply_to_exchange: AbstractRobustExchange,
+        rabbit_mq_client: RabbitMQClient,
+        amq_configuration: AMQConfiguration,
+        loop,
+        backpressure_handler: BackpressureHandler,
+        file_handler: FileHandler = StreamingFileHandler(),
+    ):
+        self.service_adapter: CleverThisServiceAdapter = service_adapter
+        self.tracer = tracer
+        self.message_factory: DataMessageFactory = message_factory
+        self.service_message_factory: ServiceMessageFactory = service_message_factory
+        self.reply_to_exchange: AbstractRobustExchange = reply_to_exchange
+        self.rabbit_mq_client: RabbitMQClient = rabbit_mq_client
+        self.rabbit_mq_url = amq_configuration.dispatch.rabbit_mq_url
+        self.output_dir = amq_configuration.dispatch.download_dir
+        self.loop = loop
+        self.service_adapter.loop = loop
+        # Dictionary to store outstanding Futures
+        self.outstanding: Dict[str, asyncio.Future] = {}
+        self.reply_to: str | None = None
+        self.file_handler: FileHandler = file_handler
+        self.backpressure_handler: BackpressureHandler = backpressure_handler

+
+
+

+[docs]
+    async def inbound_data_message_callback_as_thread(self, message: AbstractIncomingMessage):
+        """
+        The callback method that is called when a DataMessage is received from RabbitMQ, starts new Thread.
+        """
+        threading.Thread(
+            target=lambda: asyncio.run(self.inbound_data_message_callback_no_thread(message))
+        ).start()

+
+
+

+[docs]
+    async def inbound_data_message_callback_no_thread(self, message: AbstractIncomingMessage):
+        """
+        Receives the DataMessage as bytes from RabbitMQ queue and deserializes it to the DataMessage object
+        Ensures Jaeger trace-id propagation.
+        Invokes custom handler/mapper/adapter method that corresponds to this message
+        :param message:
+        :return:
+        """
+        start = time.time()
+        amq_message = await self.reconstitute_data_message(message)
+        if amq_message is not None:
+            self.ensure_trace_info(amq_message)
+            if amq_message.magic() == DataMessageMagicByte.HTTP_REQUEST.value:
+                await self.run_http_request_magic(message, amq_message, self.loop)
+            elif amq_message.magic() == DataMessageMagicByte.RPC_REQUEST.value:
+                await self.run_rpc_request(message, amq_message, self.loop)
+            else:
+                logging_error(
+                    "Unknown MAGIC value: [%s], don't know how to interpret the message",
+                    amq_message.magic(),
+                )
+                asyncio.run_coroutine_threadsafe(message.nack(requeue=False), self.loop)
+                return
+        else:
+            logging_error("######[%s] No valid AMQ Message present.", message.delivery_tag)
+        self.record_duration(start, message.delivery_tag)
+        asyncio.run_coroutine_threadsafe(message.ack(multiple=False), self.loop)

+
+
+

+[docs]
+    async def run_http_request_magic(
+        self,
+        message: AbstractIncomingMessage,
+        amq_message: DataMessage,
+        loop: AbstractEventLoop,
+    ) -> None:
+        """
+        Synchronous version of on_message method. This is a wrapper around the async on_message method.
+        It also counts parallel executions and handles backpressure.
+        :param message: RabbitMQ raw message
+        :param amq_message: DataMessage
+        :param loop: Event loop
+        :return: DataResponse
+        """
+        # Increment the counter for parallel executions and check resource availability
+        self.backpressure_handler.increase_current_load()
+        await self.backpressure_handler.check_overload_condition()
+        logging_info(
+            f"PARALLEL: Current Capacity [{self.backpressure_handler.current_availability}] of [{self.backpressure_handler.max_availability}]"
+        )
+        if message.reply_to:
+            self.reply_to = message.reply_to
+
+        try:
+            _a_message = AMQMessage(amq_message, self.rabbit_mq_client.connection)
+            _response: DataResponse = await self.service_adapter.on_message(_a_message)
+            logging_debug(f"Result in thread: {_response}")
+            try:
+                await self.send_reply(message.reply_to, _response)
+            except Exception as e:
+                logging_error(f"Processing message: {e}")
+                asyncio.run_coroutine_threadsafe(message.nack(requeue=False), loop=loop)
+
+            if isinstance(amq_message, MultipartDataMessage):
+                # remove the downloaded files from the output_dir
+                for file_id, filename in amq_message.extra_data.items():
+                    try:
+                        logging_info(
+                            f"[{message.delivery_tag}] Deleting file: {file_id} in {filename}"
+                        )
+                        os.remove(filename)
+                    except OSError as e:
+                        logging_error(f"Deleting file {filename}: {e}")
+        except Exception as e:
+            logging_error(f"Request handler: {e}")
+
+        self.backpressure_handler.decrease_current_load()

+
+
+

+[docs]
+    async def run_rpc_request(
+        self,
+        message: AbstractIncomingMessage,
+        amq_message: DataMessage,
+        loop: AbstractEventLoop,
+    ) -> None:
+        """
+        Synchronous version of on_message method. This is a wrapper around the async on_message method.
+        It also counts parallel executions and handles backpressure.
+        :param message: RabbitMQ raw message
+        :param amq_message: DataMessage
+        :param loop: Event loop
+        :return: DataResponse
+        """
+        # Increment the counter for parallel executions and check resource availability
+        self.backpressure_handler.increase_current_load()
+        await self.backpressure_handler.check_overload_condition()
+        logging_info(
+            f"PARALLEL: Current Capacity [{self.backpressure_handler.current_availability}] of [{self.backpressure_handler.max_availability}]"
+        )
+        if message.reply_to:
+            self.reply_to = message.reply_to
+
+        try:
+            _a_message = AMQMessage(amq_message, self.rabbit_mq_client.connection)
+            _response: DataResponse = await self.on_rpc(_a_message)
+            logging_debug(f"Result in thread: {_response}")
+            try:
+                await self.send_reply(message.reply_to, _response)
+            except Exception as e:
+                logging_error(f"Processing message: {e}")
+                asyncio.run_coroutine_threadsafe(message.nack(requeue=False), loop=loop)
+
+            if isinstance(amq_message, MultipartDataMessage):
+                # remove the downloaded files from the output_dir
+                for file_id, filename in amq_message.extra_data.items():
+                    try:
+                        logging_info(
+                            f"[{message.delivery_tag}] Deleting file: {file_id} in {filename}"
+                        )
+                        os.remove(filename)
+                    except OSError as e:
+                        logging_error(f"Deleting file {filename}: {e}")
+        except Exception as e:
+            logging_error(f"Request handler: {e}")
+
+        self.backpressure_handler.decrease_current_load()

+
+
+

+[docs]
+    async def on_rpc(self, a_message: AMQMessage) -> DataResponse:
+        """
+        Dynamically invokes a function or a class method from a specified package.
+
+        Args:
+            a_message (AMQMessage): The message containing the package, class, and function details.
+        Args encoded in the AMQMessage:
+            package_name (str): The name of the Python package to import.
+            class_name (str): The name of the class within the package.
+                              Use '__global__' if the function_name refers to a global function
+                              in the package.
+            function_name (str): The name of the function or method to invoke.
+            kwargs (Dict[str, Any]): A dictionary of keyword arguments to pass to the function/method (in the body).
+
+        Returns:
+            Any: The return value of the invoked function or method.
+
+        Raises:
+            ModuleNotFoundError: If the specified package cannot be imported.
+            AttributeError: If the specified class or function/method does not exist.
+            Exception: For any other errors during invocation.
+        """
+        package_name: str = a_message.method()
+        class_name: str = a_message.domain()
+        function_name: str = a_message.path()
+        kwargs: Dict[str, Any] = parse_map_string(a_message._base64body.decode("utf-8"))
+
+        return await invoke_command(
+            package_name, class_name, function_name, a_message.id().as_string(), kwargs
+        )

+
+
+

+[docs]
+    async def reconstitute_data_message(
+        self, message: AbstractIncomingMessage
+    ) -> DataMessage | None:
+        """
+        DataMessage may be serialized as string in separate queue (addressing == 1) or be a MultiPart message with
+        files streamed over individual queues, one per file.
+        This function uses 'addressing' mode from message headers to determine how to deserialize (reconstitute)
+        the original message.
+        """
+        amq_message: DataMessage | None = None
+        delivery_tag = message.delivery_tag
+        addressing: int = message.headers.get("clevermicro.addressing", 0)
+        if addressing == 0:
+            amq_message = DataMessageFactory.from_bytes(message.body)
+        else:
+            amq_message = await DataMessageFactory.from_stream(
+                message.body, rabbitmq_url=self.rabbit_mq_url, loop=self.loop
+            )
+            logging_info(f"######[{delivery_tag}] AMQ Message from stream: {amq_message}")
+            if amq_message is not None:
+                extra_data = await self.file_handler.on_message(
+                    message=message,
+                    json_data=amq_message.body(),
+                    rabbitmq_url=self.rabbit_mq_url,
+                    loop=self.loop,
+                    output_dir=self.output_dir,
+                )
+                logging_info(f"######[{delivery_tag}] Multipart download result: {extra_data}")
+                amq_message = MultipartDataMessage(amq_message, extra_data)
+        if amq_message:
+            logging_info(
+                "######[%s] AMQ Message received, ctag=%s, msgId=%s, %s:%s, traceInfo=%s",
+                message.delivery_tag,
+                message.consumer_tag,
+                amq_message.id(),
+                amq_message.method(),
+                amq_message.path(),
+                map_as_string(amq_message.trace_info()),
+            )
+        return amq_message

+
+
+

+[docs]
+    def ensure_trace_info(self, amq_message: DataMessage):
+        propagator = TraceContextTextMapPropagator()
+        context = propagator.extract(
+            carrier=amq_message.trace_info(), context=trace.context_api.get_current()
+        )
+        self.tracer.start_span(name="AMQ-Adapter-Consumer", context=context)

+
+        # logging_info("CTX=%s", context)
+        # current_span = self.tracer.start_span("AMQ-Adapter.Processing.Request", parent=parent_span)
+        # context_with_span = trace.set_span_in_context(current_span, context)
+        # logging.info(" [*] CTX2=%s", context_with_span)
+        # propagator.inject(context_with_span, amq_message.trace_info, self.set_text)
+        # logging.info(" [***] NEW TI=%s CTX=%s SCOPE=%s",
+        #             map_as_string(amq_message.trace_info()), context_with_span, context)
+
+

+[docs]
+    def record_duration(self, start, delivery_tag):
+        global last_backpressure_event_time
+        last_backpressure_event_time = time.time()
+        logging_info(
+            "######[%s] Done, single ACK: %sms.",
+            delivery_tag,
+            last_backpressure_event_time - start,
+        )

+
+
+

+[docs]
+    async def send_reply(self, reply_to: str, response: DataResponse):
+        """
+        The Service side code. When the CleverXXX service has output ready, in DataResponse object,
+        call this method to return the reply back to the caller
+        :param reply_to:connection.channel
+        :param response:
+        :return:
+        """
+        if reply_to:
+            pika_message: Message = Message(
+                body=DataResponseFactory.serialize(response),
+                correlation_id=response.id(),
+                content_type=(
+                    response.content_type()[0]
+                    if isinstance(response.content_type(), list)
+                    else response.content_type()
+                ),
+            )
+            _res = asyncio.run_coroutine_threadsafe(
+                self.reply_to_exchange.publish(message=pika_message, routing_key=reply_to),
+                self.loop,
+            )
+            logging_debug(
+                "###### DONE Reply Published to exchg:(%s) To=%s, res=%s",
+                self.reply_to_exchange.name,
+                reply_to,
+                _res,
+            )

+
+
+

+[docs]
+    async def reply_received_callback(self, message: AbstractIncomingMessage):
+        """
+        The handler for reply for DataMessage that we sent out earlier -
+        the code matches the received response with the original request and passes the response to the caller.
+        :param message:
+        :return:
+        """
+        reply_id = message.correlation_id
+        delivery_tag = message.delivery_tag
+        debug = f"######[{delivery_tag}] (RPC REPLY) env: {message.headers}, props: {message.properties}, BODY: {message.body.decode()}"
+        logging_debug(debug)
+        # TODO - figure out implementation of this part, as this is sending reply back either to a service,
+        #        or to the user
+        logging_info(f"OUTSTANDING RECV: {self.outstanding}, size={len(self.outstanding)}")
+
+        future: Future = self.outstanding.pop(reply_id, None)
+        # if reply is None:
+        # logging.warn(" [W] ######[%s] IGNORING REPLY. No outstanding request for ID %s",
+        #             delivery_tag, reply_id)
+        # else:
+        # result = DataResponseFactory.from_bytes(body)
+        # reply.tracing_span().end()
+        # TODO - figure out the right response format (not needed for Clever Swarm v0.1)
+        # that currently runs Java version, this method here is for the future compatibility to enable
+        # internal, service-2-service communication, and the proper response type will be decided than
+        # reply.response().set_result(Response.ok(result.body, content_type).build())
+        if future:
+            response: DataResponse = DataResponseFactory.from_bytes(message.body)
+            # Complete the Future with the response data
+            future.set_result(response.body())
+
+        await message.ack(multiple=False)

+
+
+

+[docs]
+    async def send_rpc(self, route, message: DataMessage) -> Future:
+        """
+        Sends an RPC message to the specified route and returns a Future that will be completed
+        when the response is received.
+
+        :param route: AMQRoute object containing exchange and routing information
+        :param message: DataMessage to be sent
+        :return: Future that will be completed with the response payload
+        """
+        # Create a Future to be completed when the response is received
+        future = asyncio.Future()
+
+        # Store the future in the outstanding dictionary using the message ID as the key
+        message_id = message.id().as_string()
+        self.outstanding[message_id] = future
+
+        # Create a Pika message with the correlation ID set to the message ID
+        pika_message = Message(
+            body=DataMessageFactory.serialize(message),
+            correlation_id=message_id,
+            reply_to=self.rabbit_mq_client.router.get_reply_to_queue_name(),
+            content_type=(
+                message.content_type()[0]
+                if isinstance(message.content_type(), list)
+                else message.content_type()
+            ),
+        )
+
+        # Get the exchange from the route
+        rpc_exchange_name = route.exchange
+        exchange: AbstractRobustExchange = await self.rabbit_mq_client.channel.declare_exchange(
+            name=rpc_exchange_name, type=ExchangeType.topic
+        )
+        # Publish the message to the exchange with the component name as the routing key
+        await exchange.publish(
+            message=pika_message, routing_key=sanitize_as_rabbitmq_name(route.component_name)
+        )
+
+        logging_debug(
+            "###### RPC Request Published to exchg:(%s) routing_key=%s, msgId=%s",
+            rpc_exchange_name,
+            route.component_name,
+            message_id,
+        )
+
+        return future

+
+
+

+[docs]
+    async def send_command(self, route, message: DataMessage) -> bool:
+        """
+        Sends an RPC message to the specified route and returns a Future that will be completed
+        when the response is received.
+
+        :param route: AMQRoute object containing exchange and routing information
+        :param message: DataMessage to be sent
+        :return: Future that will be completed with the response payload
+        """
+        rmq_body = DataMessageFactory.serialize(message)
+        cid = message.id().as_string()
+        ctype = (
+            message.content_type()[0]
+            if isinstance(message.content_type(), list)
+            else message.content_type()
+        )
+        print(
+            f"Sending RPC command to route: {route}, message ID: {cid} with body: {rmq_body} correlation ID: {cid}, content type: {ctype}"
+        )
+        # Create a Pika message with the correlation ID set to the message ID
+        pika_message = Message(
+            body=rmq_body,
+            correlation_id=cid,
+            content_type=ctype,
+        )
+        print(f"SENDING RPC COMMAND: {pika_message.body} with ID: {message.id().as_string()}")
+
+        # Get the exchange from the route
+        rpc_exchange_name = route.exchange
+        exchange: AbstractRobustExchange = await self.rabbit_mq_client.channel.declare_exchange(
+            name=rpc_exchange_name, type=ExchangeType.topic
+        )
+        # Publish the message to the exchange with the component name as the routing key
+        await exchange.publish(
+            message=pika_message, routing_key=sanitize_as_rabbitmq_name(route.component_name)
+        )
+
+        logging_info(
+            "###### RPC Request Published to exchg:(%s) routing_key=%s, msgId=%s",
+            rpc_exchange_name,
+            route.component_name,
+            message.id().as_string(),
+        )
+
+        return True

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/service/amq_service.html b/api-doc/_build/html/_modules/amqp/service/amq_service.html new file mode 100644 index 0000000..6fe48e6 --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/service/amq_service.html @@ -0,0 +1,431 @@ + + + + + + + + amqp.service.amq_service — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.service.amq_service

+import asyncio
+import logging
+import logging.config
+import os
+from asyncio import Future
+from threading import Thread
+from typing import AsyncIterator, Optional
+
+from aio_pika.abc import AbstractRobustExchange
+
+from amqp.adapter.amq_route_factory import AMQRouteFactory
+from amqp.adapter.backpressure_handler import BackpressureHandler
+from amqp.adapter.consul_global_id_generator import get_unique_instance_id
+from amqp.adapter.data_message_factory import DataMessageFactory
+from amqp.adapter.logging_utils import logging_error, logging_info, logging_warning
+from amqp.adapter.service_message_factory import ServiceMessageFactory
+from amqp.config.amq_configuration import AMQConfiguration
+from amqp.model.model import AMQRoute, DataMessage
+from amqp.rabbitmq.rabbit_mq_client import RabbitMQClient
+from amqp.router.router_consumer import RouterConsumer
+from amqp.service.amq_message_handler import DataMessageHandler
+from amqp.service.tracing import TracingConfig, initialize_telemetry
+
+logging.basicConfig(level=logging.DEBUG)
+logging.info(f"CWD = {os.getcwd()}")
+logging_conf_path = os.path.join(os.getcwd(), "amqp", "service", "logging.conf")
+if os.path.exists(logging_conf_path):
+    logging.config.fileConfig(logging_conf_path)
+else:
+    logging_conf_path = os.path.join(os.getcwd(), "logging.conf")
+    if os.path.exists(logging_conf_path):
+        logging.config.fileConfig(logging_conf_path)
+
+
+

+[docs]
+class AMQService:
+    CLEVER_AMQP_CLIENT_VERSION = os.getenv("CLEVER_AMQP_CLIENT_VERSION")
+    MAX_WAIT = 300  # defaults to 5 minutes (300 seconds)
+
+

+[docs]
+    def __init__(self, amq_configuration: AMQConfiguration, service_adapter=None):
+        logging.info("***********************************************")
+        logging.info("**************  AMQ   Service   ***************")
+        logging.info("***********************************************")
+        self.loop = asyncio.new_event_loop()
+
+        self.amq_configuration = amq_configuration
+        self.service_adapter = service_adapter
+        self.unique_id = get_unique_instance_id(amq_configuration.amq_adapter)
+        amq_configuration.amq_adapter.generator_id = self.unique_id
+
+        self.data_message_factory = DataMessageFactory.get_instance(
+            self.unique_id & DataMessageFactory.MACHINE_ID_MASK
+        )
+        self.router = RouterConsumer(self.amq_configuration)
+        self.rabbit_mq_client = RabbitMQClient(self.amq_configuration, self.router)
+        self.tracer = initialize_telemetry(
+            tracing_config=TracingConfig(
+                service_name=amq_configuration.amq_adapter.service_name,
+                service_version=os.getenv("SERVICE_VERSION", "unknown"),
+            )
+        )
+        self.amq_data_message_handler = None
+        self.service_message_factory = ServiceMessageFactory(
+            self.amq_configuration.amq_adapter.service_name
+        )
+        self.backpressure_thread: Optional[Thread] = None
+        self.backpressure_handler: Optional[BackpressureHandler] = None
+        self.maximum_availability = -1
+        self.future: Future = asyncio.Future()

+
+
+    # =======================================================================
+    # =======================================================================
+    # ============== P u b l i c   A P I   M e t h o d s  ===================
+    # =======================================================================
+    # =======================================================================
+

+[docs]
+    def run(self):
+        """
+        Start the AMQ service, initializing RabbitMQ connection and message handlers.
+        """
+        # self.init(loop) will initialize RabbitMQ connection
+        asyncio.set_event_loop(self.loop)
+        self.loop.run_until_complete(self.init(self.loop, self.service_adapter))
+
+        logging.info("***********************************************")
+        logging.info("******  AMQ   Service  Init  Complete *********")
+        logging.info("***********************************************")
+        self.future.set_result(True)
+        self.loop.run_forever()

+
+
+

+[docs]
+    def backpressure(self, current_availability: int, maximum: int = -1):
+        """
+        Send Backpressure event to the Management Service. The Backpressure logic determines the type of the event
+        based on the current_availability and maximum values.
+        - OVERLOAD event is triggered immediately when the current_availability value is below threshold
+        typically set to 10% of the maximum value, or 0 if no maximum is provided.
+        - IDLE event is triggered when the current_availability value exeeds 80% of the maximum value or is greater
+        than 0 if no maximum is provided.
+        - UPDATE event is sent if neither OVERLOAD nor IDLE conditions are met, indicating that the backpressure is
+        within acceptable limits.
+        :param current_availability: Currently available capacity.
+        :param maximum: Maximum value of the backpressure metric. If undefined or set to lt 0 (e.g. -1),
+        the maximum is than determined from max value of current_availability seen over the time.
+        """
+        if self.backpressure_handler is not None:
+            # watch maximum & current value to always have some valid maximum reference
+            if maximum < 0:
+                if current_availability > self.maximum_availability:
+                    self.maximum_availability = current_availability
+            else:
+                if maximum > self.maximum_availability:
+                    self.maximum_availability = maximum
+            asyncio.run_coroutine_threadsafe(
+                self.backpressure_handler.update_backpressure_value(
+                    current_availability, maximum if maximum > 0 else self.maximum_availability
+                ),
+                loop=self.backpressure_handler.loop,
+            )

+
+
+

+[docs]
+    def rpc(self, service_name: str, fq_method_name: str, **kwargs) -> Future:
+        """
+        Send a Remote Procedure Call (RPC) message to the AMQ service.
+        :param service_name: The service name to receive the RPC message.
+        :param fq_method_name: The fully qualified method name to execute the RPC message.
+        :param kwargs: Additional keyword arguments to be passed to the RPC method.
+        :return: A Future that resolves when the RPC response is received.
+        """
+        route: Optional[AMQRoute] = self.router.find_route_by_service(service_name)
+        if route is not None:
+            message: DataMessage = self.data_message_factory.create_rpc_message(
+                fq_method_name=fq_method_name,
+                swarm_id=self.amq_configuration.amq_adapter.swarm_task_id,
+                **kwargs,
+            )
+            result: Future = asyncio.run_coroutine_threadsafe(
+                self.amq_data_message_handler.send_rpc(route, message),
+                loop=self.backpressure_handler.loop,
+            )
+            self.set_outstanding_future(message, result)
+            return result
+
+        result = asyncio.Future()
+        result.set_exception(
+            NameError(f"No route exists. Service '{service_name}' not found in routing table.")
+        )
+        return result

+
+
+

+[docs]
+    def command(self, service_name: str, fq_method_name: str, **kwargs) -> bool:
+        """
+        Send a unidirectional Command message to the AMQ service.
+        :param service_name: The service name to receive the RPC message.
+        :param fq_method_name: The fully qualified method name to execute the RPC message.
+        :param kwargs: Additional keyword arguments to be passed to the RPC method.
+        :return: A Future that resolves when the RPC response is received.
+        """
+        route: Optional[AMQRoute] = self.router.find_route_by_service(service_name)
+        if route is not None:
+            m: DataMessage = self.data_message_factory.create_rpc_message(
+                fq_method_name=fq_method_name,
+                swarm_id=self.amq_configuration.amq_adapter.swarm_task_id,
+                args=kwargs,
+            )
+            asyncio.run_coroutine_threadsafe(
+                self.amq_data_message_handler.send_command(route, m),
+                loop=self.backpressure_handler.loop,
+            )
+            return True
+        return False

+
+
+

+[docs]
+    async def data_message_generator(self, route: AMQRoute) -> AsyncIterator[DataMessage]:
+        """
+        An async iterator that blocks until messages arrive, processes them,
+        and continues in a loop.
+
+        :param queue_name: The name of the queue to consume messages from
+        :yield: The processed DataResponse for each message
+        """
+        # Get a channel from the connection
+        channel = self.rabbit_mq_client.channel
+        queue_args = (
+            self.rabbit_mq_client.DLQ_ARGS if self.amq_configuration.dispatch.use_dlq else None
+        )
+        queue = await channel.declare_queue(
+            route.queue,
+            durable=True,
+            exclusive=False,
+            auto_delete=False,
+            arguments=queue_args,
+        )
+        await queue.bind(route.exchange, route.key)
+        # Start consuming without a callback
+        async with queue.iterator() as queue_iter:
+            async for message in queue_iter:
+                try:
+                    # Process the message using the same logic as in inbound_data_message_callback_no_thread
+                    data_message: DataMessage = (
+                        await self.amq_data_message_handler.reconstitute_data_message(message)
+                    )
+
+                    success = yield data_message
+                    if not success:
+                        logging_warning(f"Message processing failed for {data_message.id()}.")
+                        # Nack the message without requeuing in case of failure
+                        await message.nack(requeue=False)
+                    else:
+                        await message.ack()
+                except Exception as e:
+                    logging_error(f"Error processing message: {e}")
+                    # Nack the message without requeuing in case of error
+                    await message.nack(requeue=False)

+
+
+

+[docs]
+    def get_unique_instance_id(self) -> int:
+        """
+        Provides cluster-wide unique instance ID for this AMQ service instance.
+        This ID is used to identify the service instance in the cluster and is unique across all instances.
+        IDs are managed by shared Consul KV store, ensuring that even if multiple instances of the service are running,
+        they will each have unique ID.
+        """
+        return self.unique_id

+
+
+    # =======================================================================
+    # ======================  Internal  Methods  ============================
+    # =======================================================================
+
+

+[docs]
+    async def init(self, loop, service_adapter):
+        _reply_to_exchange: AbstractRobustExchange = await self.rabbit_mq_client.init(loop)
+        self.backpressure_handler = BackpressureHandler(
+            channel=self.rabbit_mq_client.channel,
+            loop=loop,
+            config=self.amq_configuration,
+        )
+        self.amq_data_message_handler = DataMessageHandler(
+            service_adapter,
+            self.tracer,
+            self.data_message_factory,
+            self.service_message_factory,
+            _reply_to_exchange,
+            self.rabbit_mq_client,
+            self.amq_configuration,
+            loop=loop,
+            backpressure_handler=self.backpressure_handler,
+        )
+        await self.register_routes()
+        await self.rabbit_mq_client.request_routes()
+        logging_info("Starting backpressure monitor thread")
+        self.backpressure_thread = self.backpressure_handler.start_backpressure_monitor()

+
+
+

+[docs]
+    def cleanup(self):
+        logging_info("AMQService.cleanup() rmqc=%s", self.rabbit_mq_client)
+        if self.rabbit_mq_client:
+            self.rabbit_mq_client.cleanup()

+
+
+

+[docs]
+    async def reinitialize_if_disconnected(self):
+        if not self.rabbit_mq_client.channel or self.rabbit_mq_client.channel.is_closed:
+            self.rabbit_mq_client = RabbitMQClient(self.amq_configuration, self.router)
+            await self.rabbit_mq_client.init(loop=self.loop)
+            await self.register_routes()
+            await self.rabbit_mq_client.request_routes()

+
+
+

+[docs]
+    async def register_routes(self) -> AbstractRobustExchange | None:
+        route_mapping = self.amq_configuration.amq_adapter.route_mapping
+        if AMQRouteFactory.validate(route_mapping):
+            try:
+                await self.rabbit_mq_client.register_inbound_routes(
+                    route_mapping,
+                    self.amq_data_message_handler.inbound_data_message_callback_no_thread,
+                )
+                return await self.rabbit_mq_client.register_data_reply_callback(
+                    self.amq_data_message_handler.reply_received_callback
+                )
+            except Exception as e:
+                raise RuntimeError(e)
+        elif route_mapping:
+            logging_warning(
+                "route [%s] failed validation, no routes were registered.",
+                route_mapping,
+            )
+        return None

+
+
+

+[docs]
+    def set_outstanding_future(self, message: DataMessage, future: Future):
+        self.amq_data_message_handler.outstanding[str(message.id())] = future

+
+
+

+[docs]
+    def remove_outstanding_future(self, message_id: str):
+        self.amq_data_message_handler.outstanding.pop(message_id, None)

+

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/amqp/service/tracing.html b/api-doc/_build/html/_modules/amqp/service/tracing.html new file mode 100644 index 0000000..65e075f --- /dev/null +++ b/api-doc/_build/html/_modules/amqp/service/tracing.html @@ -0,0 +1,327 @@ + + + + + + + + amqp.service.tracing — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +

Source code for amqp.service.tracing

+"""
+OpenTelemetry configuration for tracing and metrics.
+
+This module provides functionality to initialize and configure OpenTelemetry
+for both tracing (Jaeger via OTLP) and metrics (Prometheus) in the AMQ adapter.
+"""
+
+import logging
+import os
+from dataclasses import dataclass
+from typing import Any, Dict, Optional
+
+from opentelemetry import metrics, trace
+from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
+from opentelemetry.exporter.prometheus import PrometheusMetricReader
+from opentelemetry.sdk.metrics import MeterProvider
+from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
+from opentelemetry.sdk.resources import SERVICE_NAME, SERVICE_VERSION, Resource
+from opentelemetry.sdk.trace import TracerProvider
+from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
+from opentelemetry.trace import Tracer
+from prometheus_client import start_http_server
+
+logger = logging.getLogger(__name__)
+
+
+

+[docs]
+@dataclass
+class TracingConfig:
+    """Configuration for OpenTelemetry tracing."""
+
+    service_name: str
+    service_version: str
+    otlp_endpoint: str = "http://localhost:4317"  # Default Jaeger OTLP endpoint
+    insecure: bool = True
+    debug: bool = False
+    additional_attributes: Optional[Dict[str, Any]] = None

+
+
+
+

+[docs]
+@dataclass
+class MetricsConfig:
+    """Configuration for OpenTelemetry metrics."""
+
+    prometheus_port: int = 9464
+    prometheus_host: str = "localhost"
+    export_interval_millis: int = 30000
+    additional_attributes: Optional[Dict[str, Any]] = None

+
+
+
+

+[docs]
+def create_resource(config: TracingConfig) -> Resource:
+    """Create an OpenTelemetry resource with service information."""
+    attributes = {
+        SERVICE_NAME: config.service_name,
+        SERVICE_VERSION: config.service_version,
+    }
+
+    if config.additional_attributes:
+        attributes.update(config.additional_attributes)
+
+    return Resource.create(attributes)

+
+
+
+

+[docs]
+def setup_otlp_exporter(config: TracingConfig) -> OTLPSpanExporter:
+    """Configure and create an OTLP exporter for Jaeger."""
+    return OTLPSpanExporter(endpoint=config.otlp_endpoint, insecure=config.insecure)

+
+
+
+

+[docs]
+def setup_trace_provider(config: TracingConfig, resource: Resource) -> TracerProvider:
+    """Set up the TracerProvider with OTLP exporter."""
+    provider = TracerProvider(resource=resource)
+
+    # Add OTLP exporter for Jaeger
+    otlp_exporter = setup_otlp_exporter(config)
+    provider.add_span_processor(BatchSpanProcessor(otlp_exporter))
+
+    # Add console exporter in debug mode
+    if config.debug:
+        provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))
+
+    return provider

+
+
+
+

+[docs]
+def setup_metrics_provider(config: MetricsConfig, resource: Resource) -> MeterProvider:
+    """Set up the MeterProvider with Prometheus export."""
+    try:
+        # Start Prometheus HTTP server
+        start_http_server(port=config.prometheus_port, addr=config.prometheus_host)
+        logger.info(
+            f"Started Prometheus metrics server on {config.prometheus_host}:{config.prometheus_port}"
+        )
+
+        # Create Prometheus reader
+        prometheus_reader = PrometheusMetricReader()
+
+        # Create periodic reader for custom metrics
+        periodic_reader = PeriodicExportingMetricReader(
+            prometheus_reader, export_interval_millis=config.export_interval_millis
+        )
+
+        # Create and configure meter provider
+        return MeterProvider(resource=resource, metric_readers=[prometheus_reader, periodic_reader])
+    except Exception as e:
+        logger.error(f"Failed to set up metrics provider: {str(e)}")
+        # Return a no-op meter provider
+        return MeterProvider(resource=resource)

+
+
+
+

+[docs]
+def initialize_telemetry(
+    tracing_config: Optional[TracingConfig] = None,
+    metrics_config: Optional[MetricsConfig] = None,
+) -> Tracer:
+    """
+    Initialize OpenTelemetry with tracing and metrics.
+
+    Args:
+        tracing_config: Configuration for tracing
+        metrics_config: Configuration for metrics
+
+    Returns:
+        Tracer: Configured OpenTelemetry tracer
+
+    Example:
+        ```python
+        config = TracingConfig(
+            service_name="amq-adapter",
+            service_version="1.0.0",
+            otlp_endpoint="http://jaeger:4317",
+            debug=True
+        )
+
+        metrics_config = MetricsConfig(
+            prometheus_port=9464,
+            prometheus_host="0.0.0.0"
+        )
+
+        tracer = initialize_telemetry(config, metrics_config)
+        ```
+    """
+    # Use default configs if none provided
+    if tracing_config is None:
+        tracing_config = TracingConfig(
+            service_name=os.getenv("SERVICE_NAME", "amq-adapter"),
+            service_version=os.getenv("SERVICE_VERSION", "unknown"),
+            otlp_endpoint=os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT", "http://localhost:4317"),
+            insecure=os.getenv("OTEL_INSECURE_MODE", "true").lower() == "true",
+            debug=os.getenv("OTEL_DEBUG", "false").lower() == "true",
+        )
+
+    if metrics_config is None:
+        metrics_config = MetricsConfig(
+            prometheus_port=int(os.getenv("PROMETHEUS_PORT", "9464")),
+            prometheus_host=os.getenv("PROMETHEUS_HOST", "localhost"),
+            export_interval_millis=int(os.getenv("METRICS_EXPORT_INTERVAL", "30000")),
+        )
+
+    try:
+        # Create resource
+        resource = create_resource(tracing_config)
+
+        # Set up tracing
+        provider = setup_trace_provider(tracing_config, resource)
+        trace.set_tracer_provider(provider)
+        logger.info(f"Initialized tracing for service {tracing_config.service_name}")
+
+        # Set up metrics
+        metrics_provider = setup_metrics_provider(metrics_config, resource)
+        metrics.set_meter_provider(metrics_provider)
+        logger.info("Initialized metrics export")
+
+        # Return configured tracer
+        return trace.get_tracer(
+            tracing_config.service_name,
+            tracing_config.service_version,
+        )
+
+    except Exception as e:
+        logger.error(f"Failed to initialize telemetry: {str(e)}")
+        # Return a no-op tracer in case of failure
+        return trace.get_tracer("no-op")

+
+
+
+

+[docs]
+def create_span(tracer: Tracer, name: str, attributes: Optional[Dict[str, Any]] = None):
+    """
+    Create a new span with the given name and attributes.
+
+    Args:
+        tracer: The OpenTelemetry tracer
+        name: Name of the span
+        attributes: Optional attributes to add to the span
+
+    Returns:
+        A context manager that creates and manages a span
+    """
+    return tracer.start_as_current_span(
+        name,
+        attributes=attributes or {},
+    )

+
+
+ +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_modules/index.html b/api-doc/_build/html/_modules/index.html new file mode 100644 index 0000000..bcb76fa --- /dev/null +++ b/api-doc/_build/html/_modules/index.html @@ -0,0 +1,134 @@ + + + + + + + + Overview: module code — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Overview: module code
    • +
  • +
    • +
+
+
+
+
+ +

All modules for which code is available

+ + +
+
+ +
+
+
+
+ + + + diff --git a/api-doc/_build/html/_sources/index.rst.txt b/api-doc/_build/html/_sources/index.rst.txt new file mode 100644 index 0000000..4fc59f2 --- /dev/null +++ b/api-doc/_build/html/_sources/index.rst.txt @@ -0,0 +1,23 @@ +AMQ Adapter Python API Documentation +==================================== + +Welcome to the AMQ Adapter Python API documentation. This library provides a Python implementation of the AMQ adapter for routing traffic over RabbitMQ to intended services with automated service discovery. + +.. toctree:: + :maxdepth: 2 + :caption: Contents: + + modules/amqp + modules/amqp.config + modules/amqp.adapter + modules/amqp.service + modules/amqp.router + modules/amqp.model + modules/amqp.rabbitmq + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/api-doc/_build/html/_sources/modules/amqp.adapter.rst.txt b/api-doc/_build/html/_sources/modules/amqp.adapter.rst.txt new file mode 100644 index 0000000..d7802b5 --- /dev/null +++ b/api-doc/_build/html/_sources/modules/amqp.adapter.rst.txt @@ -0,0 +1,77 @@ +Adapter Module +============= + +.. automodule:: amqp.adapter + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.cleverthis_service_adapter + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.amq_route_factory + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.backpressure_handler + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.consul_global_id_generator + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.data_message_factory + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.data_parser + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.data_response_factory + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.file_handler + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.logging_utils + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.pydantic_serializer + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.serializer + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.service_message_factory + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.trace_info_adapter + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.adapter.type_descriptor + :members: + :undoc-members: + :show-inheritance: diff --git a/api-doc/_build/html/_sources/modules/amqp.config.rst.txt b/api-doc/_build/html/_sources/modules/amqp.config.rst.txt new file mode 100644 index 0000000..986f01b --- /dev/null +++ b/api-doc/_build/html/_sources/modules/amqp.config.rst.txt @@ -0,0 +1,12 @@ +Configuration Module +=================== + +.. automodule:: amqp.config + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.config.amq_configuration + :members: + :undoc-members: + :show-inheritance: diff --git a/api-doc/_build/html/_sources/modules/amqp.model.rst.txt b/api-doc/_build/html/_sources/modules/amqp.model.rst.txt new file mode 100644 index 0000000..93a83a0 --- /dev/null +++ b/api-doc/_build/html/_sources/modules/amqp.model.rst.txt @@ -0,0 +1,22 @@ +Model Module +=========== + +.. automodule:: amqp.model + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.model.model + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.model.service_message_type + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.model.snowflake_id + :members: + :undoc-members: + :show-inheritance: diff --git a/api-doc/_build/html/_sources/modules/amqp.rabbitmq.rst.txt b/api-doc/_build/html/_sources/modules/amqp.rabbitmq.rst.txt new file mode 100644 index 0000000..a7acf76 --- /dev/null +++ b/api-doc/_build/html/_sources/modules/amqp.rabbitmq.rst.txt @@ -0,0 +1,17 @@ +RabbitMQ Module +============== + +.. automodule:: amqp.rabbitmq + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.rabbitmq.rabbit_mq_client + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.rabbitmq.user_management_service_client + :members: + :undoc-members: + :show-inheritance: diff --git a/api-doc/_build/html/_sources/modules/amqp.router.rst.txt b/api-doc/_build/html/_sources/modules/amqp.router.rst.txt new file mode 100644 index 0000000..d107b4a --- /dev/null +++ b/api-doc/_build/html/_sources/modules/amqp.router.rst.txt @@ -0,0 +1,32 @@ +Router Module +============ + +.. automodule:: amqp.router + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.router.router_base + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.router.router_consumer + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.router.router_producer + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.router.route_database + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.router.utils + :members: + :undoc-members: + :show-inheritance: diff --git a/api-doc/_build/html/_sources/modules/amqp.rst.txt b/api-doc/_build/html/_sources/modules/amqp.rst.txt new file mode 100644 index 0000000..df1b2b0 --- /dev/null +++ b/api-doc/_build/html/_sources/modules/amqp.rst.txt @@ -0,0 +1,7 @@ +AMQP Package +=========== + +.. automodule:: amqp + :members: + :undoc-members: + :show-inheritance: diff --git a/api-doc/_build/html/_sources/modules/amqp.service.rst.txt b/api-doc/_build/html/_sources/modules/amqp.service.rst.txt new file mode 100644 index 0000000..a81f753 --- /dev/null +++ b/api-doc/_build/html/_sources/modules/amqp.service.rst.txt @@ -0,0 +1,22 @@ +Service Module +============= + +.. automodule:: amqp.service + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.service.amq_service + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.service.amq_message_handler + :members: + :undoc-members: + :show-inheritance: + +.. automodule:: amqp.service.tracing + :members: + :undoc-members: + :show-inheritance: diff --git a/api-doc/_build/html/_static/_sphinx_javascript_frameworks_compat.js b/api-doc/_build/html/_static/_sphinx_javascript_frameworks_compat.js new file mode 100644 index 0000000..8141580 --- /dev/null +++ b/api-doc/_build/html/_static/_sphinx_javascript_frameworks_compat.js @@ -0,0 +1,123 @@ +/* Compatability shim for jQuery and underscores.js. + * + * Copyright Sphinx contributors + * Released under the two clause BSD licence + */ + +/** + * small helper function to urldecode strings + * + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL + */ +jQuery.urldecode = function(x) { + if (!x) { + return x + } + return decodeURIComponent(x.replace(/\+/g, ' ')); +}; + +/** + * small helper function to urlencode strings + */ +jQuery.urlencode = encodeURIComponent; + +/** + * This function returns the parsed url parameters of the + * current request. Multiple values per key are supported, + * it will always return arrays of strings for the value parts. + */ +jQuery.getQueryParameters = function(s) { + if (typeof s === 'undefined') + s = document.location.search; + var parts = s.substr(s.indexOf('?') + 1).split('&'); + var result = {}; + for (var i = 0; i < parts.length; i++) { + var tmp = parts[i].split('=', 2); + var key = jQuery.urldecode(tmp[0]); + var value = jQuery.urldecode(tmp[1]); + if (key in result) + result[key].push(value); + else + result[key] = [value]; + } + return result; +}; + +/** + * highlight a given string on a jquery object by wrapping it in + * span elements with the given class name. + */ +jQuery.fn.highlightText = function(text, className) { + function highlight(node, addItems) { + if (node.nodeType === 3) { + var val = node.nodeValue; + var pos = val.toLowerCase().indexOf(text); + if (pos >= 0 && + !jQuery(node.parentNode).hasClass(className) && + !jQuery(node.parentNode).hasClass("nohighlight")) { + var span; + var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.className = className; + } + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + node.parentNode.insertBefore(span, node.parentNode.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling)); + node.nodeValue = val.substr(0, pos); + if (isInSVG) { + var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); + var bbox = node.parentElement.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute('class', className); + addItems.push({ + "parent": node.parentNode, + "target": rect}); + } + } + } + else if (!jQuery(node).is("button, select, textarea")) { + jQuery.each(node.childNodes, function() { + highlight(this, addItems); + }); + } + } + var addItems = []; + var result = this.each(function() { + highlight(this, addItems); + }); + for (var i = 0; i < addItems.length; ++i) { + jQuery(addItems[i].parent).before(addItems[i].target); + } + return result; +}; + +/* + * backward compatibility for jQuery.browser + * This will be supported until firefox bug is fixed. + */ +if (!jQuery.browser) { + jQuery.uaMatch = function(ua) { + ua = ua.toLowerCase(); + + var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || + /(webkit)[ \/]([\w.]+)/.exec(ua) || + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || + /(msie) ([\w.]+)/.exec(ua) || + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || + []; + + return { + browser: match[ 1 ] || "", + version: match[ 2 ] || "0" + }; + }; + jQuery.browser = {}; + jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; +} diff --git a/api-doc/_build/html/_static/basic.css b/api-doc/_build/html/_static/basic.css new file mode 100644 index 0000000..9c0c9b8 --- /dev/null +++ b/api-doc/_build/html/_static/basic.css @@ -0,0 +1,906 @@ +/* + * Sphinx stylesheet -- basic theme. + */ + +/* -- main layout ----------------------------------------------------------- */ + +div.clearer { + clear: both; +} + +div.section::after { + display: block; + content: ''; + clear: left; +} + +/* -- relbar ---------------------------------------------------------------- */ + +div.related { + width: 100%; + font-size: 90%; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* -- sidebar --------------------------------------------------------------- */ + +div.sphinxsidebarwrapper { + padding: 10px 5px 0 10px; +} + +div.sphinxsidebar { + float: left; + width: 230px; + margin-left: -100%; + font-size: 90%; + word-wrap: break-word; + overflow-wrap : break-word; +} + +div.sphinxsidebar ul { + list-style: none; +} + +div.sphinxsidebar ul ul, +div.sphinxsidebar ul.want-points { + margin-left: 20px; + list-style: square; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar #searchbox form.search { + overflow: hidden; +} + +div.sphinxsidebar #searchbox input[type="text"] { + float: left; + width: 80%; + padding: 0.25em; + box-sizing: border-box; +} + +div.sphinxsidebar #searchbox input[type="submit"] { + float: left; + width: 20%; + border-left: none; + padding: 0.25em; + box-sizing: border-box; +} + + +img { + border: 0; + max-width: 100%; +} + +/* -- search page ----------------------------------------------------------- */ + +ul.search { + margin-top: 10px; +} + +ul.search li { + padding: 5px 0; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li p.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* -- index page ------------------------------------------------------------ */ + +table.contentstable { + width: 90%; + margin-left: auto; + margin-right: auto; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +/* -- general index --------------------------------------------------------- */ + +table.indextable { + width: 100%; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable ul { + margin-top: 0; + margin-bottom: 0; + list-style-type: none; +} + +table.indextable > tbody > tr > td > ul { + padding-left: 0em; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +div.modindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +div.genindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +/* -- domain module index --------------------------------------------------- */ + +table.modindextable td { + padding: 2px; + border-collapse: collapse; +} + +/* -- general body styles --------------------------------------------------- */ + +div.body { + min-width: 360px; + max-width: 800px; +} + +div.body p, div.body dd, div.body li, div.body blockquote { + -moz-hyphens: auto; + -ms-hyphens: auto; + -webkit-hyphens: auto; + hyphens: auto; +} + +a.headerlink { + visibility: hidden; +} + +a:visited { + color: #551A8B; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink, +caption:hover > a.headerlink, +p.caption:hover > a.headerlink, +div.code-block-caption:hover > a.headerlink { + visibility: visible; +} + +div.body p.caption { + text-align: inherit; +} + +div.body td { + text-align: left; +} + +.first { + margin-top: 0 !important; +} + +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +img.align-left, figure.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; +} + +img.align-right, figure.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; +} + +img.align-center, figure.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; +} + +img.align-default, figure.align-default, .figure.align-default { + display: block; + margin-left: auto; + margin-right: auto; +} + +.align-left { + text-align: left; +} + +.align-center { + text-align: center; +} + +.align-default { + text-align: center; +} + +.align-right { + text-align: right; +} + +/* -- sidebars -------------------------------------------------------------- */ + +div.sidebar, +aside.sidebar { + margin: 0 0 0.5em 1em; + border: 1px solid #ddb; + padding: 7px; + background-color: #ffe; + width: 40%; + float: right; + clear: right; + overflow-x: auto; +} + +p.sidebar-title { + font-weight: bold; +} + +nav.contents, +aside.topic, +div.admonition, div.topic, blockquote { + clear: left; +} + +/* -- topics ---------------------------------------------------------------- */ + +nav.contents, +aside.topic, +div.topic { + border: 1px solid #ccc; + padding: 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* -- admonitions ----------------------------------------------------------- */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +/* -- content of sidebars/topics/admonitions -------------------------------- */ + +div.sidebar > :last-child, +aside.sidebar > :last-child, +nav.contents > :last-child, +aside.topic > :last-child, +div.topic > :last-child, +div.admonition > :last-child { + margin-bottom: 0; +} + +div.sidebar::after, +aside.sidebar::after, +nav.contents::after, +aside.topic::after, +div.topic::after, +div.admonition::after, +blockquote::after { + display: block; + content: ''; + clear: both; +} + +/* -- tables ---------------------------------------------------------------- */ + +table.docutils { + margin-top: 10px; + margin-bottom: 10px; + border: 0; + border-collapse: collapse; +} + +table.align-center { + margin-left: auto; + margin-right: auto; +} + +table.align-default { + margin-left: auto; + margin-right: auto; +} + +table caption span.caption-number { + font-style: italic; +} + +table caption span.caption-text { +} + +table.docutils td, table.docutils th { + padding: 1px 8px 1px 5px; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +th { + text-align: left; + padding-right: 5px; +} + +table.citation { + border-left: solid 1px gray; + margin-left: 1px; +} + +table.citation td { + border-bottom: none; +} + +th > :first-child, +td > :first-child { + margin-top: 0px; +} + +th > :last-child, +td > :last-child { + margin-bottom: 0px; +} + +/* -- figures --------------------------------------------------------------- */ + +div.figure, figure { + margin: 0.5em; + padding: 0.5em; +} + +div.figure p.caption, figcaption { + padding: 0.3em; +} + +div.figure p.caption span.caption-number, +figcaption span.caption-number { + font-style: italic; +} + +div.figure p.caption span.caption-text, +figcaption span.caption-text { +} + +/* -- field list styles ----------------------------------------------------- */ + +table.field-list td, table.field-list th { + border: 0 !important; +} + +.field-list ul { + margin: 0; + padding-left: 1em; +} + +.field-list p { + margin: 0; +} + +.field-name { + -moz-hyphens: manual; + -ms-hyphens: manual; + -webkit-hyphens: manual; + hyphens: manual; +} + +/* -- hlist styles ---------------------------------------------------------- */ + +table.hlist { + margin: 1em 0; +} + +table.hlist td { + vertical-align: top; +} + +/* -- object description styles --------------------------------------------- */ + +.sig { + font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; +} + +.sig-name, code.descname { + background-color: transparent; + font-weight: bold; +} + +.sig-name { + font-size: 1.1em; +} + +code.descname { + font-size: 1.2em; +} + +.sig-prename, code.descclassname { + background-color: transparent; +} + +.optional { + font-size: 1.3em; +} + +.sig-paren { + font-size: larger; +} + +.sig-param.n { + font-style: italic; +} + +/* C++ specific styling */ + +.sig-inline.c-texpr, +.sig-inline.cpp-texpr { + font-family: unset; +} + +.sig.c .k, .sig.c .kt, +.sig.cpp .k, .sig.cpp .kt { + color: #0033B3; +} + +.sig.c .m, +.sig.cpp .m { + color: #1750EB; +} + +.sig.c .s, .sig.c .sc, +.sig.cpp .s, .sig.cpp .sc { + color: #067D17; +} + + +/* -- other body styles ----------------------------------------------------- */ + +ol.arabic { + list-style: decimal; +} + +ol.loweralpha { + list-style: lower-alpha; +} + +ol.upperalpha { + list-style: upper-alpha; +} + +ol.lowerroman { + list-style: lower-roman; +} + +ol.upperroman { + list-style: upper-roman; +} + +:not(li) > ol > li:first-child > :first-child, +:not(li) > ul > li:first-child > :first-child { + margin-top: 0px; +} + +:not(li) > ol > li:last-child > :last-child, +:not(li) > ul > li:last-child > :last-child { + margin-bottom: 0px; +} + +ol.simple ol p, +ol.simple ul p, +ul.simple ol p, +ul.simple ul p { + margin-top: 0; +} + +ol.simple > li:not(:first-child) > p, +ul.simple > li:not(:first-child) > p { + margin-top: 0; +} + +ol.simple p, +ul.simple p { + margin-bottom: 0; +} + +aside.footnote > span, +div.citation > span { + float: left; +} +aside.footnote > span:last-of-type, +div.citation > span:last-of-type { + padding-right: 0.5em; +} +aside.footnote > p { + margin-left: 2em; +} +div.citation > p { + margin-left: 4em; +} +aside.footnote > p:last-of-type, +div.citation > p:last-of-type { + margin-bottom: 0em; +} +aside.footnote > p:last-of-type:after, +div.citation > p:last-of-type:after { + content: ""; + clear: both; +} + +dl.field-list { + display: grid; + grid-template-columns: fit-content(30%) auto; +} + +dl.field-list > dt { + font-weight: bold; + word-break: break-word; + padding-left: 0.5em; + padding-right: 5px; +} + +dl.field-list > dd { + padding-left: 0.5em; + margin-top: 0em; + margin-left: 0em; + margin-bottom: 0em; +} + +dl { + margin-bottom: 15px; +} + +dd > :first-child { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +.sig dd { + margin-top: 0px; + margin-bottom: 0px; +} + +.sig dl { + margin-top: 0px; + margin-bottom: 0px; +} + +dl > dd:last-child, +dl > dd:last-child > :last-child { + margin-bottom: 0; +} + +dt:target, span.highlighted { + background-color: #fbe54e; +} + +rect.highlighted { + fill: #fbe54e; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +.versionmodified { + font-style: italic; +} + +.system-message { + background-color: #fda; + padding: 5px; + border: 3px solid red; +} + +.footnote:target { + background-color: #ffa; +} + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +.guilabel, .menuselection { + font-family: sans-serif; +} + +.accelerator { + text-decoration: underline; +} + +.classifier { + font-style: oblique; +} + +.classifier:before { + font-style: normal; + margin: 0 0.5em; + content: ":"; + display: inline-block; +} + +abbr, acronym { + border-bottom: dotted 1px; + cursor: help; +} + +/* -- code displays --------------------------------------------------------- */ + +pre { + overflow: auto; + overflow-y: hidden; /* fixes display issues on Chrome browsers */ +} + +pre, div[class*="highlight-"] { + clear: both; +} + +span.pre { + -moz-hyphens: none; + -ms-hyphens: none; + -webkit-hyphens: none; + hyphens: none; + white-space: nowrap; +} + +div[class*="highlight-"] { + margin: 1em 0; +} + +td.linenos pre { + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + display: block; +} + +table.highlighttable tbody { + display: block; +} + +table.highlighttable tr { + display: flex; +} + +table.highlighttable td { + margin: 0; + padding: 0; +} + +table.highlighttable td.linenos { + padding-right: 0.5em; +} + +table.highlighttable td.code { + flex: 1; + overflow: hidden; +} + +.highlight .hll { + display: block; +} + +div.highlight pre, +table.highlighttable pre { + margin: 0; +} + +div.code-block-caption + div { + margin-top: 0; +} + +div.code-block-caption { + margin-top: 1em; + padding: 2px 5px; + font-size: small; +} + +div.code-block-caption code { + background-color: transparent; +} + +table.highlighttable td.linenos, +span.linenos, +div.highlight span.gp { /* gp: Generic.Prompt */ + user-select: none; + -webkit-user-select: text; /* Safari fallback only */ + -webkit-user-select: none; /* Chrome/Safari */ + -moz-user-select: none; /* Firefox */ + -ms-user-select: none; /* IE10+ */ +} + +div.code-block-caption span.caption-number { + padding: 0.1em 0.3em; + font-style: italic; +} + +div.code-block-caption span.caption-text { +} + +div.literal-block-wrapper { + margin: 1em 0; +} + +code.xref, a code { + background-color: transparent; + font-weight: bold; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + background-color: transparent; +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: sans-serif; +} + +div.viewcode-block:target { + margin: -1px -10px; + padding: 0 10px; +} + +/* -- math display ---------------------------------------------------------- */ + +img.math { + vertical-align: middle; +} + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} + +span.eqno a.headerlink { + position: absolute; + z-index: 1; +} + +div.math:hover a.headerlink { + visibility: visible; +} + +/* -- printout stylesheet --------------------------------------------------- */ + +@media print { + div.document, + div.documentwrapper, + div.bodywrapper { + margin: 0 !important; + width: 100%; + } + + div.sphinxsidebar, + div.related, + div.footer, + #top-link { + display: none; + } +} diff --git a/api-doc/_build/html/_static/css/badge_only.css b/api-doc/_build/html/_static/css/badge_only.css new file mode 100644 index 0000000..eb61d1e --- /dev/null +++ b/api-doc/_build/html/_static/css/badge_only.css @@ -0,0 +1 @@ +.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions .rst-other-versions .rtd-current-item{font-weight:700}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}#flyout-search-form{padding:6px} diff --git a/api-doc/_build/html/_static/css/fonts/Roboto-Slab-Bold.woff b/api-doc/_build/html/_static/css/fonts/Roboto-Slab-Bold.woff new file mode 100644 index 0000000000000000000000000000000000000000..6cb60000181dbd348963953ac8ac54afb46c63d5 GIT binary patch literal 87624 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

!pma|lSQ?8FBe{DRl|@FzhU7Cb>&@ataZS{g zrCQo@Lushkm71KyL3$%QD?KeSADp!x{f z=8g-xggQyFIyp&U(+DO4!2ygCg$vPu1pqEc^*Qa)IPstXB!i@fDLx<-```)5UsmT$Yl%a2onC zAFmUqUVZ7M=U;sB~=#ZhJ zS2lbGii8+5IZ#kxQUi*iaRi9X

#R4x5a04mzf2YJ>#U<-Nc81}`=EFMdUjIP>d| zG57p9Z{fmuKgy=mdh|^p{vLBqr2nl~Uvs`o<0(=ordV4cwH1`u!(29-sxfB~U?9oiFvwlQ~h zMtU+gNR!Fi+Hj^AdqXJb=<~`-ovK?Q2R#<$zZh3ihYT*KQsJfd{QuUW`+mlZ**7k| zA+K}pJ!@y)aP?O)&%QQq-p#X*@bHBL*FI8|_w@2%-GiKm@1IvS?Pe;LTypfH#`^kM zfQIh3iSL1qiZgXY5~NUv20JiatF#2(>ujRX)dcQ^917nje3D-C>7-LO9D|Qr2Cw)-tt>dQFl~e294@LmTlbdf46VkAe*1~ zyZBW!i|uL`RpE%lty{b14)U|xxc)&pr`-?go~fAw@C`=J=7)S%*=`Utg#?VnlSZ}r z*t%tNu^Wee=n9lZJBvr%l9KC?*fbsKwZt(`REc-Qn7PEk!O?Qh=n6XB5e}y`r?9V6 zOq5wG?G^EldQlJQp(*LT-5;TjsQ~KE`=E|BEJ*H*53j#E&bRx)^OO>avtf&Eg4ANuBcw@ z0pJUa{U`|K8;6dzlw{-ZfDuShv4GK(Gu)6WW0Tp{xD-WVZ`))kl{cRGxK!Lek93=J z?))rLI8WS;w=a$Co_X=JS&_p{X~ae1)5GB;u>q$hg~REQpCT8HK6|}bmuU9cTmU}G z;3|couJ$<2jD68ltnyStBS8M`21&8SW^9l>5XBUYOJkFU&pEH1pH2J=#7xDH#Qgch z&p{VCcv=sK9TA5(WN@$nF@mKjCL>Hq<7GEjOcIRMC* zOBs>`N$QZ;rZU8dve#2j5M_SY*_=ozHm99VZQe=ti9*+zR32X6yellOzn7JU@s8+O zmI#wR+J>k~LcusO1|-Bd+fXVA{-%=1Gc9$>Li(&;Ek@zfeD^PVk6S)7J}0qtIbC(> z>;eImn3EVi=dgRwlZYKiojA+Gzr3wppCH2c_e*vGC;?gx1d)scLaF6bq-$Pz#k3z{uaZ7|A27A7BNZ*ymotzA>JCQk;Q9_goe1Sd(4ICW{YBDkH2xns_xE~ z4Y;k_^09}Hi&M4Nmru^jykg)D6S4JMaeCD7Tlp~AHkOj63W=fyF$^xxuldM-}a(rbpFuYmT?3 zVjN5{Bsg=*SHhFgq2HT_xs-F<1N{G}-O0?Ki#tmf;nc z`?V7RdkyZ7x46T)ek@X);8bBuIXuA+=GW6JGMHqtI16sIyCo%y$S73Fs)+f+(VH%Iq?yw z6vJ7LjLB>$P*JI&2EJUvH5W3TqEtO3ln;>B&3rLZ#}vcLVnEZ0%psLUITDxM+-o`d zIau_7An@DSf#-KSUwP(W&5A;&5Z`?^=B0{~L8~gJPwT$y^8IHpx9$&RwOLuU{ijbM z4z=}_!*6T;_`TLH{zGo>vYCVXhS2xbnnw$};d_N8G6WDh0I;8A%x0@uk`jUj<&fVo zvgyf52(lzlr79#V)X^|tX1jO#oL&ca#H65T!7}@*nf>Zcx7Bh?3*0&J&pTH|-da>W zp>Iw5MUl58>02nX{odhK=ROm|jqdv5qH8+mM_w?-Y4iJ0N^E(X^^@^iFpe`H86CUy-&mlopl&gn;DN6iEUyOiyz<^pqqEW$com z0RSeJwxWg}m6-HEsX=RKlxlgSgMA0w-hcBI#Ia;I>eq?HK2I!^zF*B7!!2{ako+oJ zs+Ch+O-=1E@n?gGF9ZM+8=0YeZ=Uw3(rJ2LVKDt|kE%<0%+L;*E9#R~l~JD*?N5g3nx_fn$&)F%K9{y=mzAiX!ErdvVeRU=W% zbIU%gBBpV~Mt0XFb=!$Cjl*u7KswEX=b-0z-#_bz)~~)stN7;2Z^Sp4+c@)vYo^_J zV$1W3_@7q>VB=Wj;e`1Z< z^Ca$#61Nk)Dl#?Xkex*sw<2Z9Nm9HcRHBYi9ivCn%hfTja;k1rZG-u=DcUC5e^;!_ zP9L0bTcInW@}v9GF$Ydzu58kiva@SslQxTV#gJvcey^}%NuR#5X|H{}TUR{Sy?Fcm zWTJTHf4Iu7KWt zZs_vVRgpbrm_2y;WD6HR(xR@BZ&iGm`UO47M*NTZh3kLPFO0(JZ=+wR<9-w4Gke;* zYf48>9Jln~uI57v->jr>9fwQpOM473|vZ&RXhO)SWp9P8bdWAaMM|Ym>Ww?4bo-M z1U*hd))gl(H_~PDbHy8U{Bqm2;?C|aS?Ps!J??pQ(EyN0!P&AGY}KbtIeihqb5lkqdU!Y;BJ8t{TtFsv=N()rdfpz7J$Kxxkf zC85CY^$XR*8Z~69LNpjP-Wt;}?7E>C+0@CFg?f!&Q$Gk8zw%leIOF{H2epIWU6_Fv zZ)(t9+w+DtbtYbwnTOT%~RG z3%^C)beM{H;=`%<$&|+)o{Imd7Z=gjAoMAlw~m)mRtjE);Pq_Y*c7crqks+$8a2D@K!n|AB+eil6#t25q^0_DO;Jf}Lo_6~sLJC~j$xao ziW|E<@Sv}M=bU7B!q5t*M{Jo&Y&YL&)wa$fHoC&vd|}pui3#r#HaIwj&QFnoh8SIe z*y=DfrwIV`eTgYa@xLUbT>B4N25@d|D`m(XGr!5{GY=!t_`Z-6cVXAW|L5#G;G#OZ zx97~vy?2+sEK3(ymSquah=5{S6?;Xn02b`nHI~?GOt+<|38a`_Owczm%^1^TG^W3) z8jWeDnqHJ0zB%{aEf`|n@2@{#(Jg2CnRA}!IVT%eQzrfhKgA}Wk^s9sbk9~;c(49> z9M?h}(0O#-5{e9K4dZe2(Aok=reS<|MZa+qCXDM>(fRp%MpsvlzUTQPx|O%LZM%CWT6s(H z*$0nKoBQg#DMugtvDmPADy-nour4GC@c`<)x-xZ^_4eL0hO{W2`K6F+2&cXRZ@(Kpg-*>HU-Mc)w5Y zww~I7cy4YGSHr!$1Ti`-;)oEi><>Me&|bJ#d<<^=>uUDo?*Q125l!KoDcK|oqbZ4w zSZ3Vl!!48&7J98$fJ`S$&j?qmfcxceynbSoi_pG6(q$qb&W_nOk_B18yS+gkpt9#< z4R%5E8~y-!!?!YaG=H+>*o z2;t*p?j#Elf=QrRpf}Mhibbm-zzKmGD<}vU1cg@;i$yIbsv6gaL9;ku7RhpDX4>T; zgDLe03BE~?^TJq51#a)qUYwQtYwth4-dkn6N;G;snHCi@Dy(;sje^&u8A}pj9T?T}=Yra`$;pn7%j7ZUY30#824Jt)Q*8Pg z#R<4PbtV9W;52#1p-)bo_Qc@zo3F?(=v=sM^Oiw-C)NCC@b)b?6m%|Vf6bQ0WoI9J z;OyB49y~j{d+%P|FWYw2kVhs@dvf^o+qM^X>)!c>?K_7(K6TQ*!JD_!l}|K@Cm$Dr zfR69Me5i{I^A2`q$V4bn!>pJ-;2b^jFe|Z!ky;B7O-H|0sX!HAvcZ+%V6{f{F_2uY z%=EOBWSemu*G>`#Q{OiZX8h^omKFOa-CtJURySB z#arBpao`ASW@c93Wh}HBf}KI96GidEna!b2A_&s$uf9Jcjwlq8x6he<>GJ!3`=(+<-@cIY z{jU(KQ1RvRIhQP)zxR)CdOfg@9--hsW59?d7nOI z9lZzkjJ>*T$IX-Xy!FXpb?l-seFhKh;5`r%79Sozs6*MvPGNEQpnnyiWE=mSZ8gUu z-fIt%yzq<&f)Mop^H%Yj9PbGH&Od+cwbuw?7&BJhQ(nZgo)nTX-ij!o3=lXRK)Qs1 z33c%=F;0leNj1?l9k!}4tU@;Q6oN*>F>$3Lfv`GyA78<^xkbZsuMQv0tIBIOi9f|omWyHN zTAJx3#N&46W#-A(XJpH$xm9+33sG~2$CDihnumtW2U)_HbN;YPH{5^6Rb9LE9&k6P z4_tfsEfG=Tih?<|D+iUA(B~cPliPP+F>C&^f*!p(wU1OMZ`g9Vc)4I~?uKrz8Qykz zZ4npC$znE{U5~g}zL;dgk`GRR21{T{(+TuuWEfQ8pnKR1^lSvv?-~>^A7PKR$LauE zAeX>Wwx79)Lb@A#iFnEP>y`Z{51X`se%O3oLAML$-9w^*jl6PA$(Z!Cxq~{l?&XMal;sxnFTK25=K&=I z$aP8to2%^m2Y(N{ajwrzKUN~{HumFL>@Iq_@)Gu8Fs>5d#$g~15Wa52RZIdLqGm%* zyIHp{n0Mj9G>|{C;Ep>MTyo2;3k&=AD=Hc^$oMS0Aibxg$K^&#>O?kuzdFtUUv> z&wchePNs>pj((`TLXt6-5Cv2xuyUOhz!9XxaRQABa9f}hX*V%S9QKhrK)jLORDkrC z;G`e=w#(3kt9^cP=U1t^?}lx+%w9E@LKUs6YwXykwWqLKdv(^14NFI^o-tlEeA$t7 zEB#jH;d04H@9=P-5CEY1uYUXLTffp8Qx848+DP#!0cwO&@?X)xOXWcHw(ZlJzALHoqsT}{k zTol3wL?zJ}*8rdlK`D$N`WQ($rdMLZQQ~azXrnp&9>WtUhN0o!(U0G!6?F3sOIN#u zj~p?3-R{=8t)0piV}4GjH^Jj_{VOEV+=b2bI+X+K-+qxJ2amtK7Ru;Nbm?sggp#@R z5teCU&Qc_D67Od)Ca`@lGZ=eOqVU|OZ@u;4)3@Aquwm?|kz*^%E5`7pHyk){!;%}H zeDcOoGiHohQeInIZg4%kWGB0yJw{wS1s{`aSo#+M4VJ=ILNE>^*M-Wcekv)9GrfoL zLGWa3Fltiu!08N9C>6ffPm3EC zcJolk79Y|2%^Sy+Trsk$cJwIq(9zQ`to~qd+liy#*7L@>Mznk6o{~gbAzvjGfF?*J z4pB5Eh%{HjEQ+cF&ckqmgb|ApW@!#Q*G5`F(;~G}ls>SVCtz%NB8KX847yz!YR9W{ zC`ZH7`$~Eb`|D)5*bxK2hUj`-yK=hvxXWO;?}LphT=CMXSY{Clx=Gg5(SH;Ziz zsXOnEYM}jSE+99Xyup6qn@PCj5m}K(WCth)NC40PxQ23x^wY&+7 zpeuB}OB{isyQHV`(p^v_ju`xp0ZqG=1pyYZHFK6AZnJz>Y42^bR$MMlbZDoFwAM3wJ^7R`J=3Ma zhn{hrp4e}IU)#31^Xyc}*{1_J-L8fEr-@geq6?nx0gW%YvLuvq>iu1TwMjs5r-?Zr zgr7qUmoaxO8lxPDJr+})6laEtH%?`o9*f|#+L#BpVlhUW7T*dzPR?_(`m^kDWn~=i$S1A3pX&gCp(a*Z4LklxsQP#3&Q_e|7xFZN3VJIE%D3#k%P*{ zA^W-M-Rbvr?SAK!cYpRRrF_+@ajS+6?eSh?UCA2vBa`Qrv&@MTGzzmuIm(8VR_?#$ zwmn^kR}bzSt8RO`xKpQM@#pDV)dib!T0hZY;OpIU_m1t^wJ&{i+l_zL-DTg=5cl%v&a2`t}F$E<}7a_{xqvZdl=0!=7;sbdMWVU;5_IvzhD1F5h(3 zB}=YS=o0bL!66c?`4A+%c^YhOJbdtm!gUL0+S4OHa`ekzywF#W)9Kdr^KX9tUV~G1 z7w^U&(_<9jnByRZ6I6-Yzk=*Zg>z-7c?>8#RDGe)={7l(yxaLk&c$~0u<(m^|Lmc! z&;RhXv2P7&TEqwPL&m;^SOu#}RU$Vps!&s?f~$(k6{LT$**f5bn0S|9A~4bJF;FgM zhZPtXL}K8^FeHS#k_+_tV(dzGqZ5b7#B|$=)_v}nJZ-MbP8ZhX4Z35_gvs=yIJ+v& z#kNgeI8zLYj8c3tnKmx;*w1La(m zDQrqIMGfDgCSv{?;}Qvk;`z+s!W6b*A|L!fsEektZU3Ie&V)nlH;np+EVjf@`1X1G zUYN#KQyY&oOJfsCvI$Wn#-GUD3eVR}Cj#RUF|8pxN#}x4J^qQrP*xdXrO2`mS19^^ z7L|rz6bNaZkE?;ygn~DCk>)JH@clq77Wt~6QO|Ro6En!chTgIOB(=k4X%uZ;4mn5tvgd5~QTkNqCtQ@7_ZHhzyi$v8Yszba9 z^6pqDUKm-`@p=-_R_xFMtUs+#w~bz3fBZNSgw8)%clFh>!xfSyc6nd$iq?`SB)fTs z=LHWujevF_NrceZh;>38fM`<$#;_vF(42uNQwbnR&$<;GY@p!B!H3sfhaiTvYvrlR zuF8KQUugPh-jw@7E_Ir?`BE`hjl)Sa&8K43UWeZmGfWu^E1&$@7E&s0Bl;>eB|{ zv~l#f^?k(8q5+0ORNpPb*?k80v@xt?QRl9Uy4-NjeI^YxEF6Y_6*|bTArV%cj_R9j zwX$C<;RpAN*B^TZ&zo`5ulY@mM<(e&x}esW3L0?$qp9(fBNow0D6`VaFbmZ*KR`zX z#(22`I@P#ieoa~Vk1|dkKZ_3Z@$Q==5v$83 zVs+l6b%RIresANFgME4*SlkRO#qN_ZRthu5=%>)oe*K4p!dQn47%(IhLIwRySSye= zgwQi;TVltxX#tSoR3HX9%#3D8r_+RzWwBVCYR&MgII-GXt0PwvQ(LF@A5!PrFa5|b z5ViWgqLvM8Ou>Dq>3cDlX=+;o^^^>%Vg*VpfJ7?4npwP_rsQRa`i&06fs+6MDhQ6z ztE?G?vs@l(A3c0VbZ7E%Xj$ys>GlYKlH4P_PS&K5y>L;AK_FlOCDx!&tXv;fuvk}22K=gPap zg*XpqMq)y&P1XEjW4*8$3ZdgvjxoMaIU9$&&?S#7>AQh$B_`KH`BeqYxL3+hb=~lT zls$1$JRKlgx$Ej~MhX@@%WnpH<6X)ZKUjRf2l-Z^Of0lj*Q%S(cabd8)!RAKnGx@> zg2tK5=Q6-vMW=j%YJiB)DXX9c=TFb7yIgKpyhCT#_`4O?ho@y=6)#tNaC95EO`mB2&aro{^YiI#xMT|8C=X8u!me(1IAifYcEaxYSZ2>h5=U#oZwYg5b zGESRw=ym_fxIym^D)+?ixQ&nSWAx*I5j>ahGl;^eQfUJ7agGJx`VROfj6N73P!BQ; zoW=TzMIklRqwzQ~VHW)jB#J*iIq?&{95MQn*A0?8-mN3XM=()0nvW3ge3kQyI0~T2 z-EG!2IjtWp9N4&e<#Z)^!aRNas$}l8n~Zf>kmI8=yp`xsD@tbL3Z|v8u{MmK%ILf% zBd7(e+lO^GzYEFt^YaPUU6=f$9{ZK=(L?z)_#UPn3(Q7$EsFTxqqxAKxS+5Ap1My1CT3Zv47!xzYuV#tJVZ`y#fKr_D6nk~75zq!RPAs7qN-QQ+o8<_YjVcFj zy-nr=UM?Njzf{?)uHC(Rty(f{e-|*F-9T4ROJ!X%`6oCHU|2#W1U|qq9@0)UeAM+kNge<0cml%1_CQ zu-t4AZ!Hu;VDxiN%o1nat7f@K`fHq z&y|-}_uJPgE5Gj2s?LWxxeAomYOWa5t8MOtYsPrn6ROXthvl47NEqhh1DRD41#&9H z8u|DHaCw+Bfw}12ph-;3NAw2Z^v4s*52|QXKv9Gqmux3$;O3@#aSU*FnQS(MxR^cT zAB2Q|7=(7Sh7GB$9Wrdz!kqNf?CjL^9MONmg#P`;jqlsa<7t)Q@#tePj6VcVD_>%- z58i8)(Y^2x*~t_m^&4|x&LgGSvnneeF%fC30G{4=@GJS2UGRD1`G4Su@?CSC!YDBL zdj-t(`ImJ7Wd$hk0i z4P-6pLwajZ zzBHyM@E@;YX-;>>rrK)n0BbKJMkvSop5S;l6WNWm#Tp{JNY|4+BRP9R=r`gs3JG-3 zw?9&dO@9>#A*?bK?eW*Ds1p1mJ zN#;5R@o#TaCyN`f)#Ng1^WEwJBOZeqizqHcxKh~+JrWGUNWV#uU-(As?jL^e9sA*j zrI57udL2Xp;o?A3lRrO(V~3BKN|qARVmoX!)zsgTJ;=8sKNY}qwc}* zx_Rrh1@Yp3-gYmk=rTfbwyT3`E?c)DWgEvQf)M2Z;$s3#RE(0=62Gv{Nd2xJgvx-N zLg1q1kVm_pD}&4FUE)zy*?VrpDYlg03Xx}it@4t5WFzUA*9*k3O!8q|XhaDwU4cNB zauMwYwpv^UtKi#Lj8d_BeYM?(z%>3nodLxY_?+&I#Xn0tm2r~Co=SsE%SD&E=gDxo zBjV)w8+o5o5xxh)Pkk=gF;~NaZ4y1G;8;s-Ki}>T19M8XDSHi7Nn~SjDz7Qn5kM@c ztfWt==Dpwu&Z$5!!9TN*pfG0Y zO`8&d$b6Fhu=W06DXw1E^CnhA_})b`K}m?5B4vdyEaiVTWsHtELF$$yGt(CH71 zbkzL@1>)Fm*n8rat;-c<`Bv6-^D;%bbPF)`+|f7X_ugsu-=Ef76HRX%ZB)Cb-FIIa zwai)$6yBzE-Msm0DHZJ~tT42MRLs%kVEovfQh$^XGgAhSuuV1a14=eTZtJeJbM=G|ZjA^aD)Pq+|^9YrWLVuR)u z!2v;1iYee0pKVLXMzlmxta+2dZ2?Vnnn|$?f`M8M^PKNbU%Y+8x~)rQ2@8--cf%mC z$iGAH-Uy1&e#?Z&U)sO=_B)5$|0aHQ{`Oflw0p2EB43=s+1>IFAQm(|Ajyks(wXnz@Zbm-wG$RBT zn?&I3PK9PXhC5wZYB*0y?~+};E~CR$;|_oF$&rfn?c>FiiL<+nN`=&ll39~^7hlHU zZj`Ac@8zv`cgnZequ{zoTBG?TP>p+sNs@|p7~q`LWJhj%uG}iZNgTvkLuFXv{2-Q2S@r;8#}*$1 z=g?7a1FIRe>WZ^(47{$pI1aYwCyX6GYWP&ooIcZ*Etp=Ty!8H~lXmClJ+<+TFWlLp zSh@YVKYTl8P8mM$(wfHeY3a)+%vt-o$-S7!2k^cmg{<*LB_&1@4pgC(1T>3NjH3}L zO@uNs-Gtx}V$*%Kh<|uWg8wNOeS^x%$KvALS$2$2Xdqk60@p4aP(SB}52zOJi{sx! zWC?}1<2}^{x#`i<_?r_>+Vu(xSJ#nDw zB2LnttoMei03=&GMfp-jf@w5km93J_MXHOp$tmq%?xjIh40#J2M%nDoA<2a$*YZX zYmDp@4<9OLak+OyD^OI#se}Vi_BZuC3!wa7wO`Fyjx2yl5Bo=;Ss=}4ASbf^0pMIv z;Gn%~X4He$I(J^mah3Kd^XA6{8GZp;BV;_X{Jd{D7^$DW3r zRqLEt%LnYZ`;qNxk#|tX;+_ZfHVqc5*kROJ#yc&T92!Fz9m=TTWf}s?8R<+K=>P*+ zEuqz#DVkm+F#u?1Y_Yua7qY`**W7WEIZ%HkY#)0=yLM2}W6=J)F1zL!^))JccZ*T$ z53Q*j6`$B{@`4dBbe)?&HpA5+#@>G4j+-FyfuEIAdS5pQF^QL>P6J}v!`b~r&a zn}4UnP^}q2w=uLajikBka>v8-*$k6=nsI%d{^0pN68e^yl$O1sd(EY`qFX23^|&}b zazwAm87#bQmZH8Kms(a{R`uprQktxA@s##?jo<5M_a$;a9<1ZB;!VHO02QF`^mmyn zm)#T?Y_7o$PIHvOY3@>daC04YF&9)-V;6r^pb|T@9fq>(`ZziyN3kIo zJ5m`+O9S!8jtGGYBamanj-WXm5o1UHZPUJ0W@cLZisD=Dm020+)vKcx{&rmSgALSU zdlT<(iBp>FAFj zLL>vjuZ-H*K^%wh&%Zb? zj!&LBaXdiExYF5^ph@PjyO;O``}AAL6t9S;n-4v44KxuWlP$YMa>In4^BLp~XMoqL zcn5`^#(@;8s~b%ulo~=Q33v+G2vC?E`fruq2q1E2<|Gp`Il37^;*?1%G4?)_i6WhE zT6*|rPQ@Q%%jZwJbklv8DVxXcYTvd~r>{Q&l@B|4NF6orv1`*dT%|*jQb9^ z{1QX^(PwFo#sEk_x4$#Bi)T)rGHc;XHn#WvDUK83qzvjizJb=h5A@Lf6%RakxiR0| zlB0bOFEL_qctH%)#XF5mj$&kT079ho?Zl4LO|{Fj!Fl0iD`xkIqoK3x1K=emeP0IW zSNuuib7N)utNBnvK`;dvKySaI69<4G?9jNe>j@9D)!EeJl>R^r#m{WE@jKv?(k@e% zv%+=|U*J7|{?$)iS@xvFwCt7LFIf${7fw6AbuG}1wZeCkI4_?1=o6S{?*EII5=tsX zrt&fGPm+n-&<&xKq$EZWj(61Hq#^p8aXFKd>^6BsDp^FHh1drgUR^M~mOizH<6uZy&n+YW1-Vz#v)tB90?$M!kA9T{tDv5#fTtKh!~3*{;3^CTxE$ zh0-po9ukK>JSkqx5FO|tn)v93s~cRcLiouE$R2T^Oi_fvO^)~*H#sgoF33$*AcUC= zCNDWld^rs=A!cWgm;9MHeyhPtu7N7sUJ#cZ)_KVfin^EvxZ+);CF?pJB2z7r>#sG& z^jyG5W}-vm3T7AraUHy1b6uiCj-@9d(P4~b0^aD29`fJ>*SpM?Eu%5b$Ml<(b5z+! zTQ<@z`4HV@fZV#?6UTkxJ6Be0Or|lobnq=w0*;k6-ba&Oyne~g8>jrf{TJ~_n&<%U zWf*}1XzCT%)EQr=ifc&>tiEJdC3ML z*4=vSsvRf{z2mB5x2^-WUZ0}Bi05a|m@ylALc~pYHz0@+m$9yJ8amf+SU^x)#e2f?0jZ7GtF3+_EKhV+tEn_W8Bf^XEm= z`+FWdES?d6iQmP3=v4PZ)iAZSC$HeYd+VdVduYa!Cq6vr^U3A(A`JLTB7S}Sb{(QW zm0x0^FuYgqK3*gK#eY@~6Bp|4C8-pMEy}=vDL_Fn!~_gw?Km@8EiXKAhBH+Zaud+6 zKk&Ef4=e1xb3;Z)M-p>IxI4#+({fdvv3Jgj$YKd`9i1C@bh|NDwev@AT4f3U1bC-B zUyX3VcXWGRCk~&4TbAw;Ypbe^d(ap;FHXpL5l`BnN>mttiVR(%5>2gD7$wAnMPsG4 zz!hB1ia47i%dH>6uK4)o)1atWp1^>!9QO!g=Qh1U^~Acw)K^X~eki}-p-Vn{B_-)n z^>T3?Yn9Y^C^?n(88&PZbeuSRXkWH);4PzYLd=^rYaULB(YFkE)z>)m))B*R9d_Gm zSM4}9MvfGSJ(PgF@4i5*b%oB}XyDEm=$fPBZ>pR|wjF?1LR<0UO zMV5^6IkIBoTsA%2gh5^GZZ6lT+vCC69x9mQLiWBACd0j-^o$uMY7s5~Sk9p5+VslLF*T>~C&giiXGZw6g2p5Blz@1(U1c*)Ext@`H7#GGa zT>x4}(AUY*4i&Y~r2Qt|z;rtkoH}-+McMdgblLd( zUyWhZ<~z%xU%9ts`S_QmeEcW-)zj(|r&^GYr=%SrmY%xiWftaIlM*R#y^aaN95m78 z{gg6`F6^l4xmGjWnVL#SYF4V0=$EfecDig?uCO>=npEB(@Z3i)P8#bfl=j>7IJ+OG ztUOb9?i}QZ56<~ci#0L~_HACyj=A-G`neUGHmyM9oOnz8@#fp&PyU7&B&x-=r~ZK6 z@T$y3XNsunW=%KsczQ|OuQT;>hj<6tVhovV3nLlnSf51Y8t&*;uqezjjsQ_KP)w<8 z+5cS59D@k$a^<;lGwl*(U0{z3OYp~VgF@!PMwubqAn3YRoeupgLzUIKx^w4cyWT(N z>tE+SnrlmE|XGPZ4)2Cd8H3tY$A4EJE zjs^#=%UmZQy3vXV3oW=7P;01K1prGKu~-7)-_o;20VedV1B)PoJIsh>r@yTM{*w#{ z|K4?32MC93j99MQ++k&B1e84`=l?;R{|Bw%-~9YL8vgs{dEr)(8Jzt_tX%BE^=n`c z5kndo0mQ0F(?AdAHRD|9A&^Lpxr`Kh za%PrOT4rgc`)@+-gCp-X^F7X$(e{KH*f4?Q%4%5LUVr9U0-?E7dt zR6UvBFE`#9m*=W3oO9WL(>o=Cq`rRVCw(uQ+o>vBVvOSQ`n7)wM(*^zQ}O|>zG-_T!?tZXOUG>4? zsrR(cduY|GpTBoZ9kqB#^`hAy>-kecR0qb?&|^S`l+FxC@9cmal= z%R=iRYy{hw%jXx2b?0X!#I+k%{5f2IlkZTu`0>H!brG&wF+olnO_9^)u#6W>p%1(onpq?UHb(m2v#_oQ+GFZ4F=_>1=voC8 zeL0v``Do#5cZ|Y7iIXTqnSHV6RC*Izw{~W<&TrkJO|HkC zk>kw4gFh=XLT1h+X(t0|F3tk~)OHv*W2cUVx0?Yso6~;?P+Pqw(eDqy7_ezZWfKNA z7%T1-KQcKwH{QH=@68&xl$-YMy=h3=An^S9C*%)HyW@_uVdAYne--Z!O1pz^di?&o z9;W~C4cm9;{rk-`b+_7E*=y*zVTKYR4Hm+z785^DV32X5@(`UJyS>n_k!~ws{`0h; z*@606wD|6PrmpQDa-jNr&%?wEk5dDytDHg~3vrZbt>i8d9TjG^Qr)%9NC!O6nT{~y zl#F8l;Fp(i6iP%gO1$Yhff-qa{?u;}jp(1*Y*SsIyS!4J^J9HGU$>>ly}gZkAbPeO zrpDOL{PG7{_Q#evwitNRKgS6%_cBWg)(64)ot)$+gD@I_ctD&(Kznma{mFV|q>-SO zHEX2L=f|=KJL$p-Hhqy-C+(@Pr&V>Z%dB7XXKrYBHT#K{p+ z5fP>$2f~i099rvlpv?LR0Y8epP+#wNq59Q}_2DPkX5EiMlf@(GLg8Mv6&Coo=}B?i zW3?HGPtk8KIhgJ8WaB0)u?mDHCE|in0WBw1X);mAg=x&fO>_cOaN|gGyYU|5&T;1$ zcbSxAxz?jeRF*T`mIomwV+TVBv?FLe(*J)9*e|=Bd+Y0s+Cz<>>+P6Ouk7`GVYCCg z{#;WC0L1Sd(ndof0BcK{K5R5eB&o>MN=c54;DjPZfnkd@;EeEb7DZ)xgBXJf!&6L3 ziisg4DK#lICNU<#ZZq0qZJ{lp_EQ#WKV-FNwU0M96z}cd@i&y0jC(Hul|+JWpQb9R zrqmM3QF97~S2$I8rJpMo7aA_sZ@qS-mbi3(%pzpLdLM|<4WM>4SNlqcc>uByzal<) zK>S$wVOsXqv3EWbO$7rVjeh37>W#T+AM!7!tq`-tv-#pVF=yFy$apTVd zbj*7W{cwBJH`)f}MdX!WrYHqFR3(xM#N?eZ*+G#~4}@#Lt8}{qx5hvcL;AInM`AY> zdvSip8UPDDG!^h%p&35QE+@t{4wwoK$N>YD|ChKUYr9^kYOf!oWmLo(AltbV(OL02 zUaJhE#ASwmBre2jG19x~52Z-o13e@US1$#s@&o`Sw{{o~l`(Ti7zWLa`gq(V zXRj=}ZFa#JS9V;hxV-+JOLp#n)bsF{&%SEefB(CDCA6(q{L|khUR<;~IpMgb_DilynxP>UQ&>-YQJ#5KZTgq z3hM{9%1z6SwOLdm5h0q11UFL>v833K?^pF2wFyBXDHLvB@HtTN)7c-zPXKWzCyhVN z_*17AY_jv>>x&lF)-IA<1SZ5+CmmmkQ;_}THF8Whw23L~rar&MWxsl*lHcRg`jyd_ z-?Mv@V`aUuuB!>*PxF%hpPGo#|4U88P`wxb@^+ZZ+fz_vR`@ya!B5l1uUz}Zd%h~& z3IA&7p#CGi+BbB-$nxF1WY>-%OVblKRo+x@kg|MNebJ?J=WfqHr-H7<1V}eR*pIx# zz*y?igouS}31b-@#8@IK5Iw|TWt{ix*rSg}h}SXDz~;zH^2R#f5}edH&iUeL?$i4x z8FP1GR)up-ufRir;@#MMf7PNe0KcdOA;~gAf;k?{DrQ?HO}QlGr?2N^}EDQj<`gcld(t2hq{L$N8ug>zD60nB%5iVl4Ww^Dro@g7~!5$j0E zTd}UVhYlx`{bFyPX-@DnP78{gU05_bdP}-1O1G?D`=*$4!xw83d#5>KQ}R6{3Z`D! zb(_p9q^()9t>nsS9Y^Hkr^d#m_fA;z*^Oe(8ynX6PB)|-7PA}TVeO0VHi~v6F?HgE zA795tzy9NdiK&T4G^LIEMX^4<0d733b2)oAeaAlV<4G>2TlBZvZ-RdNtepvT|1n6K|MRIge;PZiYNGJH^`!Vi#k^}p*@zM4_4M){T{;c$7OC4G zxohXZ<*tmi<90o~=MJ^=pkZD5^?Hf`8HF{TYJHRy3kBHFd8xLrsO0JGF`6Ymc6Iyt2#=>dh8z&F=eUU+`u zexPV_PG#b*mKn(zQ5bQ60;uVjptN|qjSk#yZFsx2A<6vWGX;&Trlp&v-qHQ?sU1gn z^3$T@()uJ`d;WSc|GNd7d{5W2tAi83!rQrC6W1gf69A1heC&aQa9sb1m~)M@M@MnO z5b|c^841x>qq$p|zLi6Q=wpowfD@AoE>AJ;t-%W|y|G?2zVv-No-wssJ^RY^_USd> z%Jc4>FX67!O*k{L?})#@)SGyTQM*Bk&_}9@N&st9>fG9(a`M$Stubc@L^vl2~J`TQ>bUBDo_?t19#=Ppx zOaAxTnb9rR&U84N$5iCM83vA`-Pgd>)vJwL(F?0Z{Tkm3#?YNPgZ*S!_x}6ls0HWx zzhjuA{|5~7DCyXKA$#V9HR2}u$@m$;Po>x3E^gN9viH&2mwqWCB%5x32Bla!qwa zQP2efI0dD57${1VS*eKY3^EI78fG#UWK??W#4(M3luwFI zi;ij)T{Buu6v>g%etCqbi1)GA-;0R!qgkUOAYK-vY`p1N&U~{OyJySRyD6hP8GEKq zuc3WNN!N3O$wqz$dqVDagjuwZ8>p%&9M^AXFd-p9c29CbvV5%rZ=p7Mw8B5$K@0h+ zJLToGu}F6=Hf@6G^6S|;Ueb8C?-cY3%$LRVTK&8+YV|9z(zXn&E0)$u--s!y$;SgD z81vxBoj2)9;}lK-LZ(dyNtf%|jp4G;paM?Y;LsRR2Re84gaz(_*=uNzdMwE29-4Vp z_+&Y;?d>aYIvZ<9>x<_FVw;jMwV`la*SM;KafRsSaRrxj zM4ZNoHo6G^HVfp9!Z-(bAPYQt$fN$R7+lNPKdh?p9_%ADC%BeJibL86)ON@HB`LAR zc#xqp-#mo7T^a7^QYIZgHLnng+7&Opdw??^{mtejH zv$v{3IY_sb={Ikxa!gfW%z&!ZNYymT=bMCEbNeF%Q!epw@;zd+WY?kIDQ2d0nIpeb z8w?jftkhYbUw`!YU*|sdEs?j?qg7+aRI{;LV8PzBtuNhm-)p!ZiT{ZImh~>JAcW(& zp@r#tQWD7|*`&-n%$=1aH$s(A9LIl%6ht?R6u4Z;$%MGFUD?T*$<9_O7|UrEDF}7H zm4I4D^LuuR-)b2pe8tf5Xnan$zkR*j-|jT6$BquDdx%?&me3BkYW(+z1H9yaj1NTr z&+&oK7W|{#kkz8SzBfay1k&5AVU~$XEjEN-f(B_oG-e7k(OQD>BSXPKqkyDdv!({R zl4^yK7YBkV6NeqcNt$Y)-K>ZPxgap0r;muKv7>vAAf``NnfM-JsddK8HpAnb-?5$_ zul)m}#JQgjHc5l5r}hPX3rZk~MWtHw@7k9IDHl(7VweiDN@)>~?ebE9<*)hrY^ zpd5KC1%-&1VpJ2eBDsiwMyiO#(p-e7%jupqGxI#YM{$9&=dS6S zR^O!W(K1e<=yQIocNEs`O97Q<0B8yj;3)L3DqO9_77;+9R}JL51q=CEnicYsy^$JH z%n#@NMT`0Q;UaX5jWz()aqE;_R@V z-3Aas_4B$LFZn-ULZbg26Vlv44>rK`(gUrKzH*4S{@TZX$yQu%cCpmGVg(`OJwz@uY>p5HZbjy|OfQ**-hOVg7 zX<$Jx6QijXCeK-gbK`UZGCQF63nLBk8s=i$Cd2hY6i9I6sS+ndIwC=2$4+0fM!yP) zbObjvb1#FJMj&gXeh}6o&p>@cO|SZ`sdz6m05hb*sP1Vvlo^Ou$Z{cA(kx4;`;bAv zWblDz5kGxA|B)_T_s{!C`~vP7)itvrd-nJVwaVT`+v#6N3>!A$w@=yGM%$_t%U1_~ zqD^b%xl+SR{%%wBzu6Sv#$~r;lUno3;VHLtD%w5e6)Bf8WWdO=;2u6=&`@6DTYmhz ze)7+E$LSTmo}5)PkHL zeXjYPxP*j+^n|obxeI4GCHyYIK=lXKM{wQ+)_GD>lU&{BKa{Jx9;H%_R*oH8$-jS8 zeE31bK3N5h&3SZ!6l+cr4^13AU=lI#08QU%`4VSWAoWBi6y&-YSo5+dfk;r8D~)m` zGd-TET=^UFE)1v!h`p;K0M_zA5e&850=k!x-@a{|)-s-Ng76{|FABo*$M%EZuvi_G zr{(LQya!*6V(^WyQ_HIl2SIsf#Fm&XegH&${q`i71F->!-ltEf2b7n8^+WWQLTk}G zts#Inm${Sa*Ri#HVPA zs%kYH$<&HQbomsJodBSR=qwdsV6iwXrS03wk`^vkte%m{)H|V|=z=3g4l8y>@D%d6 zLLnb?n**$$2Tq(>wHp27PpV9s?mv=F3K6#z-ClGg>9V&#F;Ab%XDN>=^DZ~eCFR{e zg0U4!I+@&iJ4rAQ6+t$-334SW2MQ{!(&1bRqb3<&ueF7DpCC6~4xaqW49#3urv-2b z+Q8Ebgjzki>bK#e#|f1dL*i9xLp1;Sd{lHpgAFv%1zr(<*&66JxXsiKe@OSg9hjYu zM6N5^!c{J9q2R~cV(&tk-{A{0)49qp?v1BFk2zAT=cd_YKc|r_%$B4i({R03XpEwUwoEgia#lU$ z7pB)s3N+0n5m#xc*eaY1`kZ#!^)|7<7!)^ak3JN#IqOfEgD}?|m3;ARVB+pH#^oD2 z0>>jbJ{vCa&s*PKV~k2<8)hndQC}Ccq>fl>VYxspo@^W^j9UVUKzE#*LQ15XSS&^j zoIaXjP93}3AwzSHOlzW{KCcGwoLO$O0DpXZ2*y+2pup~=Z>*WWei4@bga|C0^RTkA zK{Wo-xLKa+i`R`>9V+c;fZD^-IB zz-5MB86j#PO>^wy-`Hfh^CTSZlUP)!gQi(rqAeK z7C`cHTj!wWZc1`Yw8Du8JSNi=TjNN`E-Gev6PcuQ78hb0v4v)1iwo>7x_jzaF?pq` zy!`BK`}iGuZ-4w*uC5f5Dkn$C7OvT@uJXZ_nw5_4zs9C_a(cQbS~~BcTRm2?O6LN2r&M~(JO2|&Qhz~9Mc>fUBD)a#=noI zf3)Kh#AR~nsjYEv{f9^?ywKvfhK_!}#T~>ofuSapBoJcRCC9px?2Xah@(3$q;e-N& zqqb#oCD^)ITxZ^9)Ep?XpmRi?iG1k zT>)G_dxV!~Yb&v?40;`1iVB!TGjO1)oZvF}%X<=w#xx77wPJvPXtWYHA&evia$!2? zB$x}s34v1gc{#28XwZ((G2EXI^O$JRqGo7NgX4+$9h8v@&Y3x9z>NDCtSNK^;Be z)n}I8+cx*XRYyK6XxnX2@`G82HgCIr_UL&FzGgT06~++1Jd7Pue0qOO@zz|lKbm)g zKR=|Ep}Kw4|Di_;i<;Fo`S%`qa$IHggbvk7Nw4=ly84r*38UvO@x7bhr~BZ-ksI%U zhi>jXeaWSl%&PPE2c0{lXHjoRv0eXX|DiYESh3peTvoB`e!V+x$vv=oUIO5G*X0m=GOh=+)U{qvE6EB?`ut z2hG%dK#z0D_S(_=!f=mx{kD$H+8n*wQdmjm>^can}P|y)!B))IIeO^(X z|CZaoKBOqme52bx4Ef@Gm|;J9S7!aeO247aHTGJzxp}2!@SDo~#t&;&ZCOm7VWDt4 zwa%PaGs8;7Bx<>^@G?|iF-KA6T;ZFrah{^g+erKvb!D9L0&$>riya8l#qEgh)YO`p zN9<#NVA*L3P$1t5*wqe^Hg+s5z2iBm3Hg^C2FrrpXn|dR!Nqi?y1e)zec=V#;h%-2 z_!M~gui@|}Z2DJuDc$}}+{+*J+mCn;g41k*UPJ|3p{m#lMWGYXY(t>}n^Ga0;!rMZ z0Fz(tixm8(TX*hMckJ*z^$&%=&%=}F-h!8p|8xCsMi$Du*SA_eX-B-IAF1_D>(_@8 zYwuq12!ajQm12m>6|O3^B!YxRMTAvHLu5EuNu;%!L`6mQLC}=}`IgQdC`y2g*S>w< z()Ql=J$oS6qM&03bQWSASu!LdJ=WqP?r0v5=#-U^fTdOc76OoswL9cf^aInSlO=fp zc#1u8OXTXi5Gj8CaL&Gxu6t);)FR@)YISWbMlRxKO{%J`t(upxUcA&gzi89)1^uAY zeBml9fyb2lC~y2q@H35r2MrqBcm^83YUK384I2dCxPJL+IS00{UcP=KG;Y`c-(0?| zpdi*gcg`|VUOeae^?JXJl6&OO%6n$N&GpVI?IruIPw&uvlc3_TC~K|1|3dmLEG(j& zL`1}ebY8-Ro!77LMLJKqR-u6t*(un0L9mz8|DeUrQ#9;7o~6FpboROG>+?HaSM~f4 z;)pt;YEbXK!@)7EU$4Q{!;dAb6EC*zP^@=c;e7Gjts}d_W4t$G-+y%M;~xg}??2#& zkB@!yJ!2m(UVLoH;zdjDzkkW1#Y>JYUJSnl`s|y>isx=J{4PCirD;SXIT*)uf`x+~ zJDU}bXnmNahx=qsg!!3ymI|wJkGEI|vE*2C5Gp1kg>kwTk$fk)S|VffK;GP)vUQ3r z&L2k#KH#z+^l-VHV^n2JLG0L1FRz_2ezy2%c1`sR@i9bxG;e>`E|1Lr7^2mk3l^+h z`&FZD_3{;~*xBIEPk+Pk*RQ8_ZV@%&UCO?TwMC(`jJ8DoU)lmKwFSr2ANq%{SZ7r< zJW5lC4jM6Bd^~pKfFa`ePp?ebUDWB8DTjYidSOe%Ultu=R_+vVk zd9^nzLPx$K!_CmUY(*$TT3&5)&1SPyu&IEV9C(shd(Qt{R+@70cR;lvi8wXO)7i3V zA?meckbv$3HoAaSh!gMp37rH`Naa*~zI@|`Yp>n#w73o?JE8Oka6&kY6u$4(%~!sC zpEz;V))OGR@txib_i`d0yyzf%Iv0pi5|hEK)G{@^|$J{btEC--~~?jhn7 zJhx}v1L8T@^5D7$q4vQI4?;gN`@yvj=%0Tzzk`ied_+SHb6p8^qA4O{()J<{nP^T` z9X;kLc6t&V&~+csOxUMntbrfqz;S%94N3xAr88!hYn^@7=W!x(!^o`pS|HdE(%PMCF!cbLP5Z3ksH9jyf|+5=>BM z5{1~jSdD>jT|a4(4Pqorp+HN}W;_EWWy8IwFtZVkJ1VR1f> zjOyQu+G3U78I0=UhP>7-Z+4oZs1{YR)Mlq7Wri!(u!t~gL~WK`KGilm4tP9Z7OgrF zEXg28JghnuBGN$e)}pHAz{{Bs8z|l!(Z`eC$`!3d%0HzG-b+G$fpOdK(Be0Am6QRUv@-r++B4;;|9PluizdUo%MCrd{A zjP`BwTFcESCOt-S1!M%kZb~WV$PxBrH!Dhe;qUf~|Np=L{x9#xVyLoUQq4k6Yx6sH zY!6>jWnoRtC7jOeP|&em8UCjKr~IwGc)QuJzA?>S>Ki5hH~6dgve}cnH+x_Hi#mM9 zjNxitNlBjgRvlI=AGhfuA6tWueSd}g`{(M2>C;EZ$6eYe$^O^=^Ye*5x29<0^m>z4 z5=HDJiKG!1$svQh{WG2MjL{rdT2g}C1dzQL775Ig-71w6(7CG2B-?Qa7HwCMNM=>! zc0oAdv1&}7k|4JR=8?Ms6e|w5+!|1I#GRljpeY_V^RQw&B-k~^)5BNP^ec&w-)LGS z3>EjBUmPhOfhtx{p;xI}G&TN0#j|}OJI{7Qua{Yk?Z)0Ob&C=Y!6bf16pWPMP+P>R z$^Ea2@DtI`|u|DVVS`}EV-%tX#pPs!BWYnaGUO81M6W+LbL z{W6nr{$wDL!}PuTG-~N$MKsK9+G8mvNH^lRkAp%1k*@%~2t#l=pzfl%6Poxhg{P$^ zN-A2ol{=I;H5w_3#SA(6+!d0Y0e?_{zc)<`npSxZoZ{rU-(_e_=fC~FV)g13ztfm; zaB4gp5>0QuCB#909NO1w(~Ox{Nqd`q6*as@o{bFIB6!D7(YRhWg;B2XI8;c`GqMV! zp|w+5E}P^)V1+ameV2bPoy2?36zgXAI>CKW9WJl@hZ0Ju-h-tYwf$yu<2%AuNky6yG3>%pxYR-rvyS(Mai}>3RHVEiVvJM+FF7H4As97)v!;IT0_Km9Nvx?0AR$zs0LfFR zby6t(UYzsIG_CK1c<3w6$t`-v47h#QouL}nVu^T1e0EM+Mqht@*Aq{Pc}6b3i+GJM z#{3K7GiCM#6pVRutV|LSj&Z(#76tOWFv_QwIE^+5pl*Af(@5!KSD^?+Jk?BD^w6v! z`~I;AajX;w6wzlNTQPO|_VuO4V6sGduv-CQf z0a=2=0!K^I1mKd6m)^sA(Z$W1%kOm_>wD$APE}d?4rg4OzWEP8uQjq`f9i5?`DWiE zLFRa4V?c7CV1W3`Eh(rO5#xq z&uRU#SRW^O1G{z|PpiYWxCqgb<@k88Ey&;JkO(TxcI*6oO;Hit%PH5V5JE&NtrqH+ zn85&vU)9<}JO-KHX$wm*z@Y{I!sf@FG*U82huv^-N`D=H9f6}4qx8$M1ASk^yw@N( zHg5Dhg6+X%P_lCI)HwFvl;pwZ>d&j|Dau3?J^}GmF$_pMPhRrJHCI2Uzqc38!w9l~F735h2 zZJveTEtY>W;_e{T0@K*ML}y!|!M??zbPH)N?(O?5g{WhNdwZ6_D0O8TWi~Aej|3gg zuJh4(wXQr$#}HLDw{~-aNGnmqDo87BX4N8b6fo*ZqFiG@u9#x#J6bH&%{Py#p%B1`dmLxw71F1!Nxv4aO<-^gDMSIeeb7Nx*i!`Yn`*$3^4g zoByn_T50&QSG?U1E`0aFx?AcAB@>#?aMTXXF{;H$;;2Hqw5F=!PM}=H7W3Xjp(<5$ zR18)5bY{qQhqSn;uwC06c{P@8)?x#tZ3#9|wprENtfPMQ7-+1+-(uNR&6SP+Z8V*W zsSge8cI5z{c;Wj4YL{MDFHrJ39=!Rsm;3c{4a*g;7PeM%JGF1Cwk=3ZPEJgMu0M`H z1`(Wos%@Atar0g)E4qFBjgNjW&b_>K>fTaKgT>pcF6Deq`Az+o<++yjCqPogZmk>E zB0vO)QHOv@hgqdGs0*i1WsnBwGlp5IA&Eh$I+ExoAt6}%TSo$6z92l&BpEqvp$t(! z-)Q`)@MTgH1LYn}os2ibPbzY~Z)uFx)e?eA86fvtV~^JHx$uqfinI=?Hs}9acUkyJq(yD@UCF8>v}TdXw7F(0EF?6b z-N8sUS?W#Abf%`*W96m^4C_&n?-EE?9#Sj=IR2gT8X&PRvY;qPpivg{@*wZS#QJnKE z?vk9OY?+mkmpsf${VOx6@!osa{sTGbEY+a&-}p&|(x|VMy?zcA1+EvqA-bTG&Zq*a zbEqf~T8-jE{(>bYhsxphbEqz&6o-~>tLuHY7e(Um6kop?hXkV;1lX`(*L{`Jqs z$ZVc#j}jg5A$RCCJoB2qmieC-5l@aaJe}cG1rAJ=vyi12JC;fqS6QV6f@R)uM)~V4 z;HH(H2E-+$Q`55(ar>RB!%$v6;={G$^Xwxq;Z@x>fd*MbFLl~&QfT>BqS+db2P*5qQ_HRu~Xx1v! zDadrTa;Lcy(4&dabgcqxmBd!+jcTcmC-c|qq+fh4zSfqkd|VzV=bx4}J6B)@yGiSY z4Da*bTV#1o2GhqlAnj!K3){MmO+D~wXoXI;!K}z>)Un;COjY(8y6H|Ua*=_AgQCL; zxvInh(;Gz;)u>d@I2&W&ob+XnchW>#fRBvMxsGd!^~-PKgz_K$rL?+kIxK>9_lh@9 zHtCKF?5Mqcr#O#O%J5lM)3UwEqC7)YiHT#iZ4<$&KiH1Po9eSRC_sF4#Vd(NzR z%m6!;WA#)=99~mF8VhV3TI*k~_VzY=oDvsA^%vL;?9qiTi>JO`s)CLE0VZGn*d342 zLyxVPG97Ndb{^iJP0ac0P`@`(eBJI;!)4;nt_Rz!o3MHXlIKkwr@^{5q8rZ!Ta2Mg zWWkw?%ppb27d0`oYpa5N+Q(lCDoMu@U~yM1K2)oy#cIKUibJ@IVnu5CQ&uK5xh>vi z1&Gl5zMxz%-6R(HZLbi6l_Fm9|7UyjzuWHjz6<_td*J>ltL03&7WUQEnYQOkUXHj$ zI<{u7o22K)IRR1*y!O6%4)ksMM#)lM!k8)YSM>Ukk(A=8r?9^lk&OGFibxvDE^gdw zoW(_dFCsY|M#3C%i=51Fhy(0V#$NpIrB4sdFFyI>)_bhfcgb$$C9z$+b%!`Et^$}1 zJ$9&1eeFs4G`0AA!fU&g^qZg5`@Fl{R|e_vp~2n(fITb?SHeLLi7K3NrG_xza$OUk z9O!g}v6rDfo18R3XpvEBLf-vl>J6y_3DB~t0_fGTcpiuw4jvO9e*cDe50wO$Oqwrq zhF8D{Cbpvg^SGFi{>>p>LvZw>CDmIuJO(q=fc|G!v4ju6IFZg%0YcL(R0SI-M$vIq zCp&SXa%n6Ew5Ah6%m9o@e!}P|nrgG*24WcH{3n~~TU1;tIiOF1*mdA&(CDQ#X!Mn= zT#@e26QVZb+h<<+;{Bs)#iAvZTQ{Ptnq<^mDyH&pP?L+NTuMkb*;6UM!`nZ`g9guo zr|G}Q-9qp%!N4WA@D$MG#8EYzx}vX5#fw~~J=2|~ zyLFDR%sf5zJy~qzy>uNF8*$=i1+`QxJQ*~Wbg|EhZuzsYBBV3cDL)IZxUm>jXm%mT zs&UM5K~eFX5GfY;!`Fu%Z1ebCvVw7xqho4LTQ*lJtX@`U+;X99o$q|ZeUDkJCsnma zw*~_Puf)oJw2@@e)7vd7QZ@i6mSy3zw|~dg6E7Sx{eTv zv1j#OWv`#RX4(b42?qtR^aBuufnu0uQ7O`GG(T|-OyXKXye(R{uN5A}LHo@8wm_Z_ zMY{gGrgB%%)@r}4Xl&o=DI7AShvLklT%0)~cK+S;CYU*4@IAw)?C5{&ct{%tG<~fu z(Rp7*sN{s0O2rAl3$iIu)N=@dc+X61wY_PIIoZL-{`0v19X^ zIhPDv=1hEV=-C_o0?W0VwyuG;o~o&e#X1wJGBW|Y?%pRYux85g&uZsRn8~s;c7r;8 z>c?*_z9-*x&#KZ6J>Y>|on{wB?Y;bwD(pIT=RP7!iZq>8Ch=jU6VB=s;H+a71!@Hq zbV9X;;(QvW1*a2AK&4O}^(%VHM#g42-EM3pPG1#G*IhG@+1{WQPfN{JQZnUq z{&DXU`@^~viY9u~gzD11y~m2*sPfYzZ+%`-Ryz*TvwIKZTv-5>^z`)W`oI4byJW-Q zj-3w=@7HYr^y{MTeBptcDpq-tE*+KMHXp8Bk=Dx@jXWR83*N=IDUT5k$;Z<#3V#;B}yp3T2*-&F~fcN9psy2x55Fn$jV$78B6J2JDhTgV;_K7 zFs0CWYX9cd%?5Jg>Pu&4=7_g*5|+-Rzb-1@=E((>Rv1H=o~#3?KYnY$-5pv#w03#7 z%hTgCZs@yY&I;fA(?1_Ltly2}KEid)#WG&W2a;^k0i&6CDUAo*WUzgCxq38``&TuSz*=>d%k9@#W<4S1z^1iFabH6DsKq zX6xXJ!y~-ihW6{M?s%c$<}vHCleWzt>Kq>%Wvgj7cu1MJEZ8&xq+Qb)Z4uU0L|+_b zGB{zaz$lo29v7`OMS{%m3{{GE(mP;#ay>eb1 zuc@oU&1p8bSa5|Io717U!}x2Wlek1|`OF6ya9Z~juhTcBg4xAUd(CZ$J!5DUoKcta zk`UV!w4I>sj4*`+Y>)m&+g&=pxmZ^?YT0(xuw8xal`{i*>#Cu3>|yDg59~RloNL-_ zsKkXO8V|kvQ5YNbm3Usf`7`W2D$sCYk%r%RS-YD2sJ$!qjQ(BxW!POR`}{N6=k0J$ zXcrxYnOtJwBpFnYe8wEv44vi=gaaOYDg)JjzhF$Mz=*R0BhIoN^8SMn=a8GlKlguO z;2wu@GCIs)G#W>Q#Tp!iXWkC;{U>;%!^=i+7;uXV8HTR|S34jTay)*Q$Ds{9x^i3&rJ%9OP5ooXbX@U>C1m9?;%;Ju^j^xY`|$IFpi@_8RZ6OJXn>@ zze&60A0!FY%S6(V3l+cs}FU8n96f8KivR?N*Fo*TIrF@VzEMAR=p9)RE8 zjC9(P!3m)TJAwu~)Sxy&z+i`AFfI({i;Uu5K6zf8fW)82Z*AAE{j$E7EMC33Z!sGV zV`);i+IA1_gObm3PeX|-{dj8Hfz`R|o`SC36TT72n9Eu3jf~RS*$al(wXJoS-uND zh2?@bH{KVV$SV$xGbb_|yV-v)Dv+^yoX6?tA?NndUx5KV zd-dZm8y3Xals_Jo8_8NTJS?gQa?M$pB+8co)gkD5jCL-Fh6NdZ{kzO-% z*tVS3zw`f0Io@BMyyKt4yEl6q)~kucia1StT~8e-Q;M$)ocIN>e%26qsQ;!^PCe0Y zc;6c*9MbU<;vifN>A}zJ>Hkc3@Re8Tul&8wloS2%v_B!+StdVor<#cUqd)EsGvRGQ zo&_&4(4_$@k|4$Gn`!JP>Qg)8Yw$72hFXPy2DLC63$%Hq45Pw1@d8K_l9B>_I*`3h zKQlfHAIsOxjKbH=gvq$~cw>#%^#m|J(0C=qw$YFEw%PIBqar!OXX)>rNNpi4RQ}dh z7;!SJc1D&q&z5Pc&6dapD}|?8EFAkM3PuOZ~gkYbJw%%sq5BGtD3fI)iiyq5G=O|2#ys#CfOv$g0$Zl_!R5v zdhHAV%q9fpzVSL`^o6e@9^-ZRdiEd8;&~GkM)3_erRF=}A2lP7sHBV3h8U*f@;#)G z^dV(r6vpK%Ae@hauy7SLQVyy%(oU(W^d@0MAz?~206~!bu#FzMXq@_IB;o6JGH@IzQUmt;E}_YquUhZlSMifoW?W z>YSh7`JuH#*X=2mbxQZFW9!yF{Ls3gYxnF~+jy)?+2Ec-yOaP&K)An^br~9XM87N< zKD=aTNm*IR`Tq{)mkcJR=KoG;VviA(q^!K5lzY&GNI}w7|R6CO!7C69VXFwrQoH=mzEPG6> zu!|KS3zgzC9b_(>rQ{+w?h#5LC$Cuc+@09=xu)@yU%+3A(q-3+eE3WLx=isM`2Y$s zvK9_nd*y$FvMc7NNq^)5hjz``%|x?1w>w@P)FCZOC|URV%QD$^WYcG^B{o(1ybY}P0Y%I$0ANPri689ckk`|wwu^bN8bOQQ}Nlj ze*H&qm?m~}sDUGNz@oO>#I{qBS4thNrF&+-{o~2U)tc(1vuDfS^cZO`$rpOsj4gIV zo*gzJ+=D?%=6sKa((sh|Np*^j_1ytbLN~g zXU?4X_b#gv?@(G)vNP!F zxPYLmE9xr*Tns@|A84jrZv)_1kP5l!>Pmg(T6RB`R@O}}b=;K-U|6+4gb|lj{M0tt zW%Qk0i8E%7=}@My3LO{GfG>YR-oW>5*l^O_V`%$PGhrvrfSpjUJ8iz1*#i?(Fn*}J zV%Z9#SKwr7Qg3RpdXCA8Wi;QD>SsQm;NwIv3T46>qbU9GjzMibT=iMblgNU#IyX-% zr9lGpBUP%lhUh z(?0&U`Kr+QoTpG)wS98RPT+T7JQ>{sZZ0MWd3qBGBiHzZj6w8fDj-i0 zobP+8X4$tlzRevG)yCP)Q;6?kjM!IKSzX;@dU{ZG>D94SUJLQb0qw?*WtBbwVLdbO zT?pOSgVK<&hVD1~cZBQBXjMN-L%FMirICObN<*^mYi~gcExNH{xrvtbj-`GUx>Hq0 zQG#m5SF2Zl{ne^9U)S{Np5Ci>w~U^5R^nT#{emW345(H# zyB8LAAK9&_s2fBQceXQo6&l|+*KzRymKXbqB(saTG_jwB4WXU2xh|z0NY$5VdOM1-Kr(0RMuV@G>Y-J%If<74{a3Ym-L$ zP$Y7xG@F2oZ*MJ*?XmwhEkN z?9dGIeKeR;n*}bgv}gCOC>uQhqz@d}8zWvF-C%KzlkR^;jb*{I&C8b-_mz87ymFcvba?(didPQB>ojAEmWX(r zk?;~rm^nnbwgq7Q3=slNL$pW*(l_!21AQORHPBHb7^Ph#UJnFA;EV(=i`Z}a21fcV zd!^A5n#N*wFEPf%t;$GOME(DG94j);|2ZgxT&)oF&Fa-7y=!t}LR^RTEjzmD3gC^r zP3+a@mOMhoAijpuF^|&mETfC&Q#vA6q9f-*z8gik$N`wvfIt8NnFG(Y^CV? zLBM_d}`+KQ4<9r1P9`cBbyj}4D2pG08?L2 ze#=?!4+qaJ@8=z|YRZrmQm-Ceevf!&753>PAoEh)DK_X5k~^9pmW&}* z1@_Q#O-l8GWs>P_rB$t6O?jQS_`$0c_Y#xuRlUOX;P7I_z2wCEU%mh*d~;OUq)o;~ zTP6${{eH)YVdYzm%{ERf8;Rf~&B!4@5 zFQ-n)p5LBV$L?^~57rsz|H2E(E+54Q@Gn15`Lq}EWy?`)-7yV z5@)7Euf{(6pNW3u(Fxf-60>5X%Ki2I%cEkm5_@DPM3?(ne)d1?ptw|U^>TMfiN6+~ z;^OY*3aN3wed2G@x{qi2vmdz4j0K^Exh`FI1qpbQkxviWi8@3^K5f{9Sf{!> zWoXtZ=sW~>M(qa=W$)IXu74J{nSA{*j_8oCOlx*8S3z}1*VarSu?no2yHQN&m!Jc) zo9?L25Na6c>2Roxx2UTJk>{^+bLsPg=<}`&&oq4Qc|zCLghy$=Ii4{g|1r{KMLCuM z&}w+Jke>zR*~MT3L-9iV6fZ<|2P_23eFw=GzE+0*Ist!VrO;T;)`xuItQePB>?z&?$0(s=5v zV|8_C5|NT^**-+<D0H)C zf$*xw*0P;yjhjj>Ycd;|pL)L^@w9YrYc*@jd#+i9owm1t}@zQT{9YInG zav*0>A{zv2g&CO1h{wV$h-M{%LR}Rr2!e>*s6Si&Y@yEMmGkN&AEljJi=Wx7$prERp^{KYx`S9vapmyYcl<@lB^ynfQj{a>tL)9nyd7 z*#5t!CHp2AnM8ObC8=)w8lRdPKO`C;IZhd541ZwzP*U@yE53b*%|nmVa!$`nD-E;1-E z#W5taSD)>wWKO@5)9981TqWZoo-^HD4MpAZ&yD^+_xW?M8NW0Y<(202!QXjW z_ekGYt=hF@$r5P2y?a*QZri!aZ#Lx4^LANK6lqptQ52}`nsH5(gEu7GxuI)(bdTox zhnydQ!Gy6SFpvV|0uuGHdPeFW3z7l3B-UYPZP_9wbzL(@;UHI?1`EL$-hN*|hb^c^ zU$Lq}$VV2^e)l)dfjvy5sN;Fje@8IV+VY4LsQUC?FgUW0yp^?|bC8>VU}U?wN%=$V z&A-$&^mg#;q+o!VimPA?v%aMrVJ3qu_$IW*RmecZp^*ELwH59Y9OMKCxgE=(W;a7f zi27t~K_?d_QSxcgzp-W@99_Nom<~GFMVXc~CnvuBTn{JrvDuxxmwGvP@U=qTq)B-~ zKv=jxm?oCS1-6!T85A4Pn#@_monc*c^vIm9WKKI%eQ{1L`StK{BXaH$L;^@dq(#+1 zxhbjXNr#ZmSL@au6#%E0b_(bDgczO8wHXn>*ZPNr`3nQe%LfQfgGhj~;9y(WH6gIQ z5X>;*oTpd^VOaB8eG*R(TKbH&1mW1~HOF+|V3IN|c}N}FzMNn)prT@c5D*y|@B@FC z_6^{kv);lfT6KYp=V-12bUYoo2l;SQgnWu%-sq>*Ykoptw|ZZ4N5849Y#s9xJGxc2 zvUcHK3xv^c{SwhP+RMo?A~&k7Gozm4rSJop!;Z{ht|!4P=gF=~K0H1mkQK7ug?~ps zty%pO>S+`a#BmX!I+e@11o77%3iIX(<43Tzc7n4*S@By^UG5nL^Hh;Q9xnC z%3<&Zu#tvg{qCVVTL?gO5Lm+Fza%{8uySGl|6pxMTPzvti1_c3aAB`ieF-v4FTLu2S8@Q2&tJ$;#4zVO!{^Pc;$oXjV{FzrHTYoiK%TAxsl9 zD&HtObyB|Bm7byOzKg5eu%_FTR<;ZKZ`h*NO8xQgkA;G1DRIvA{T^&55Lsor(je6+Xn&RM~0cbiiZp>%266ZrEu~hSU=zN5*#l6 zDCB0ZnZ0?&s-BWhiQ>7O;Aza*68f2%(6gGRf20OI-b~|OLyPW#JHCET^`(f^mi&r} ze6A9|y?pr!{!2pTj>><*kSk>iq`Y-bLB_V!=s|@v9*x+QF7D{*DwYhzX52NvN8t<( zf=&i^q=E3t=}pWL{B$~Ar5>v@8Ow~GAvo}CSrCA_aHR}&j=y7wH^E)(O0>0lm<3

b(7>T&1{%W+D%3_gwxcBR7_myM-&X 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�D$@9_ujQzel>X`S`KZ*C50A`-AgSJA`4)uK@cLtTM`G+KK}29MX4+jJ z@%h26q;*B(7FC~-7tO22ECE^;PQYmw z-5@36F~?pBN#cx+nPV$QN~+T?=WFVp_`3cU^<*fi_WbwC&|zfOhxmrKZEn2U? zq(XScmYjJ*5EwTemw4`6>S2u0xOfkqXv7nhy8-diff;}A@FPJaR;c|I_Fp}(ZmORI zZZ97W|LJ7SHyNK-2blHAy8Zj%iyxjI6#x8r&*d%-@#C}*_ak0U9t(*umK^Gy_F~6m zBqG~(Stk+g&2e7P;8bc75!W-@roOGqJkHkfB0?wxvgn^k`Hg=$tfsuIeb{xSD3HCq z3>h>^_>b1N#D<-Zn4Qo#wEm)EckRtu&-UfA$K-rHeN(pUtW2Wdp^(nNqm9tv^ukk@ z!dc=rEF{qRJ66SsZoF9UK?bRcOw=4EVU&G6FK9<8{}M3=AD$y3rw2nqkR`|kW$P8% zLPPbn3tXl?SBN3MC>MY_T*V&!W``9KlKlvjU4mggWo{lB7xLdGPctD&U>fZ%Qv9B1 z0_ZRPG(df<@3{p{lH%=k8e}iKO63(7=EQ9?!qzqRA<8gHVSJlvVT8d7gp&jijIRl6 z-3J;&WtpvTJ2Y|nuF{YSIVUQMf)IpiRe2zpCf6p&MlWh_F9Gxy8`s?l;trD?cJ3gc zy~)oCY!5|1(tBj$YWcDy@0&h)3b{Ip**D87XGRY})h+7T_F~`#G1K|oOm!m^E}r*n z+~>-ZPI=STv>i*vzoqOY=M@<-vm%MSBj+v93%W0X&$Y@a}8c)>mx}u+Z zOQ^=AY)fOcy*J6E_cQ)_VVf5)zcaVU0-s_~-)Qq1+45O;Dv4<_GkcB{hO94>1{kDl zL4^ku98kngC|r(vDSQ?j^wITORqDc?3)j4Ly_|K&b*bqhls5QH$AXyAxoUvIaX5W~ zoC6r)t^1pvTq>CqVS2O<5ZZyfdhj-8Nh&d94_$0huvJbmLoZ&asIEX2xvv^tEf9s7 z38WbLQzf|;4&6vbZWCq~I;$<8d^ai`dA#JqaSrDv&*u~Q%2z**zaQ6l+3p(A>;>Ar zO0nYenH8501rT6Ig#qM#cpuBYB^+04*wH&rilgcR?5YhX877Q#o@`MEgv4HrfUf6surZ1X6!S6eY$L(@HtYl;9F{$iBmgRZN(k71BpPipWNx?}9fi1PW$lj8S^#8=1^TB!lC9w^8b z9dZ$>#1>SBg(Pc9cGM#b8VeZiYuz+$X?8UM`nkyYdK-Q86wSlxpk;tOdDI;HqQ*

;%4OjVNLUI}t;2vfRojLU5wWvbH-4$|Tr| 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 B{|Nv9 literal 0 HcmV?d00001 diff --git a/api-doc/_build/html/_static/css/fonts/Roboto-Slab-Regular.woff b/api-doc/_build/html/_static/css/fonts/Roboto-Slab-Regular.woff new file mode 100644 index 0000000000000000000000000000000000000000..125af8f557f0f2220cdb2c24f469e31ac433ba87 GIT binary patch literal 86285 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

Glr+>R!!sE8KSGd1ry}7s2 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�E|*r!4^z zwqpGaBL*Y+a_z8^njLMU1?#k^-Y<0T0;0rZuiySo<2@muIyHIw%QMksIl?7VJ!7Bw zf@DfX_C}I--e}Oqi8;6JwQLLM4}1x8{oCv;oy>mS>_=b7>Hrv_Z8q9msGGaX#C^~n zsFd(5`DRcjRN^2O5-zc#R#XX21SjGm^ltPZ8|ldi;SF=Ovj&}K{3o%LKT$^9$fmor zWwx)=f(YHDfCS~i%XFJS`D=?MHBdp;id$kP1UyQ2PH2HdwBCTOHg;aAEj)AipbUdR z)l>KES;rjHy*E*IwiWVFyvSRXq|AW=Wc5l7Ku8GQGPA#_CrENFUf?wCw9{~|o-{H6 zBkAXwTynRb4yb^cBYs5GpuR^D5TD*1C|z}doZJ#V!Fopbx$ z1-R$ssbv>Ga_;8Z!>Vii?i63~9C@=LP?&S_!QoC#Ocz|jonK0(KRm1bUSL;Zx+2oB zO8!+X>$xbvUS`MhMr>S;K@uE34PYTdD#-RKAy@{S z8{(OBt*iXBd?IJgFmiTFi3xT<2oV<6hJ~gytGe=aWbav0O};?GzzKevrUZ+U=LKj zR_&o7HrfW@()o0kM$MN2xwFKnoBMU{!Ln6_<2S6PLpzLbz3I{e4if^13SruH-r5P`rk?skyx3vP91Jp+_|RIEe20kI-@plCGI1!heR)6bUuq{OdMTBCzGZ~? z^un~Od2r&8b<1OZ%BD>}GdGBL=lxAa?zEExBDUc=10-@uJZb-`j=-Ld{{!YGB*T?r zp8i_uWGVDR(lFPQbHymw@3)B}@){xw1v76nv?kt}H4rw7#5;S6O=MNXc{4^wh!b<= z!H`S2F-+sQicfOFC9qydJ;zsij&JlFAF5$q`W)S>7m07Y96?gO7#V?49f3h|1PrT? zS&!)#MG@VF>^!)bmAZ&h|}t-Gm!xKmSj9tt2I}kS@57wLV=fxmuXGRh?feNDJ=VS zHO0LA@|&QyfG6_hKdRy&qaar@tb1wJud~I~ge#{|{)W3>hmxfUwN*zxk08p_KZG>%0Pslv@8=;2U15 zW_gybuW|Qdboo-|6@NLDWTpJbxjZ9pE0jLVd{dX+|0TRRUwV=&qR2>5dg;ycooo^f zqU7*-Mq+o4h@wcQBynYn?Of)h_smsi*(6GG%t?gu0J=o|W_^oo780dRB|rviRV`=L zhl1{L??3a0<6j7aa<(K%WHyzaWN>SIQ0$9Te3HScaTY`(BN+bz@vy2sfJ7$islbey zLpfyD*t)7o)xs^KXG1t*i0-L?XW*r^9qJ4Y{(XA^ai-~XV@*j@EqVU zpgoXnLYVfiRx(90>Qw_{5&(o1Z(XjKBN<;X{svwu9VCZW(V2YDzj42$8F=jeJ--Np zQ-;olZKp$B1DlY{{d-~&M%ZUz=kOv7DQP;O_GD1k+sSKbx}$Jm=aeE0e`z`!=ADkm z8raWs2)(4~ep0wUeY*2Hvk0RnhwyiV@E6vd*Z0SWYGC`^AMm9JBl!LR_CE{M7h!nk z5aN@#Kh>HHy2v4vmZ5tTF8qair$h43ok|(HpQI+=6JMa0N#p&b;C!l98z?%4o|A(q zJ#i@l{QO!@~d=k#0_k4~wTh>#!mJ~BP z;>9BkjmM#pA4e6Rd`ilBO1rkSu~abc)8N|xAvHa@ZAl{WbKb?+Pg7=(`t^Hrp7oP^d>A-+Dv;a^p8d=sGBC@E&Q0_fY}v*cf?XmLV(`n=Z7k>fnl zC)P1>x2dKZ6B`pd&i7ro1{htXXGrRp6W8xHT;9|2_HPXx`{QZbH{!Zxj9st3DP5?_Yo{dT z{E%jjXJs-}RvNR&iJKxNkzsN7lyw`kI$;{AX!?D9KmR0yl4}5<{~AXz6eKeC{)Bm? zBIEaUUA*!4%s9LcpKOG&6=c;Z`X32vo@E5ZQGCcN62)K^`N?4zYYQ?175vCSyCf%Q zY_REI&Ou9_9a-RhA$9gNc}tR0nuwa+XVlsEYnyx>nNE?sc6OIEnXuv6_rNX5o*Zm` zVzC#Xv+sUm!6)}6nS9jSwE-|`WD8fA%o-T_qEw^QCN%vh@-&jM|Zt-p< zcsyU_isw+(kqi~J*~pF|T2yam6il^HQO~6Dx&mTpkT75Vc2<$LcaU}+Sb^Y4K-%3c zN-;J4C;xeA;FN3f;ODc6M@juUd%`(83=wF8!fNlnY*KY!Xye{hyH0IB1mH;=KEJ|x~v)2fqMb;_xDEC z>iCLUuDUlhZ1NTSe^k8%R2;z)H5?#>;10n9i@UqS;_fa1f(HvOi@Uo+aDvN1a0%|a zNN{&|myh?}uXFlzS69{aOwXA!a=ZIhGaul&=uDxUXrd*`b;8|!q=WyCc8`F}`0(NJ zlW!a|LX_Xp=eH#)yD5lTM)70Lb!jLHg0$&(VT(IGOTL?jE}d8@U99XV`XZq4zc*;g zj7SxA>C*5pdW*71xtg+#PQ20kxMrjK_j!;8>|Qyk(&@_O&(KjY-E2z3)>CU>;>;dw zWN&fJG`7xN8v*yt1Fcs=ZhvDU$C|=Rz&;rLpd8c$PnCCJ+3|@*yCz29;d{!#*hB{o z7RlP(0f+Y)QwI)q)zWZqxyhRn=_Zcf((Po*Vb_bzxlWtwg%p8$G?dUsH)NGkIU{0A z{w^!v3O}XF6op6lceQhFO|WrIiNWZXiirl3RBq_kf5_~S-|}-;h}-+ zZ+^wx@8=zvvUWC@Nw>GxH`iC!cPQs5wZ&i24ojIL`oyNYd z!uIqWHchpeIy8DTx-|NwI;DE0x~2M-LmZO^habu#s9fvH#_#CW$IV9)!<*?)Uq@`kQLKhv-XnUsx(#bu);JT80F{rwdVPynCevj6{Y{`n^zne2i zqmDKj_@81w`eggH?3*gl((sFFe*s?;-gsS%RVe{9cHX`4{*!igi*W z+StVid99axLXNn#S%QJyq^rc*V?awJ9x=6 zTN*E8WXL@lR!mKfl@G#jhkk#-H8{z;IdW&U>YM7zV#J|)e3_p;@Wz(qx3NG=P=!uo z*KNTII9}jSBoM}q0m%gUKgyrow*_+~Uu_J@RF6JI>bVz{xxxXfh-htAL{*Op3g)=5 z!PPBguH%wbN3=GE)&G@7@xiC8sz;ZSRqs-D!@CYxHHr(at|)W$ESR&1(A)cwJi4_; zlQw9VJUVSS)0$uA3STgHW0gE=#yPS>hXJ0z15Ys6nMmYa7nE3ksa7hCzGsn?A=FnLtF*|b~P*^5OYzsPvFK=iuX08M{hw0aq zxt>T?5q)+4gFD(`-|wvbAC0i;k%H<`=Fmdv`^o>OLll+;!tWiWb??EA()%Yip{NL~ zI{Io^R#GtMiUF>cJdI+&8?VmEZpa+vtBA95JJ}{}`PL#`t#g{dkm|i1x$|CCy1 z9;E_AH!Q{4DyzU8N$g|VOcU>S_b5WE2sEn*SgZFNC-Rm@oM;j~r=;el@c%cwex{CbuUNM=;* zE-uM94$Hh^`+AS_ph=x`hUVq<^ziGg^Ul%RqwQS>eC=RP@95#WnWp652@Y87zJ7-x zUyikdn(%g`z=qe6$2>}{)iMzIrViSu!7WYPZP06~jAfAUr`^{IL2{>}#XZuk@L&>|6SR~8Idk&OE zPc1VqI$XZkS<53a1-NbD?ukd*74hbZ$=7(MY#Nc(N|u>Dfl2ukF8qD`YeUKBv_oW# zU!6K<@ueVx$y8fs~zG0%wfBT39BHVM~YIowbD`Qf3w7_f57gSr~AHo@U z8NbOa59oHx(NFv`#}8&UzphTs6rvAw@0_E4DJ!&j`B zOt-%GyUvw=Bw!6rB;F9542Bx0HH-1AZQ)NeI1KDt-q7wv@Fj9_CCnSf>VcGX56dba zA_3GhXPvj8ys5L-O`fyVNA%kbovo6N2Kw+1ckTZui}j0gM`!MHJ9Z8%Uyem=nTrpO z*_sHGLt~zPyp@hVi)gg&{Aj~Hz~Y%nSN-D}=PjlVHegoPdNiH1zgsjeY^$TBu^abm zre9iHe47~c%sh1PQKw#!z)ZEWZ3r`!zwCS*a!v{>lE^A1z5sl9i;K^pNl!dx}Js2+3V6GYn%4 zA`HwwM_3+H`(@{k!4E z+EtD=8nnd}uw>84^LN|C!m<9T3ZW9ADy%ZBO1d&)u8_5X#?;&u4IwDNV$n3ruqU0n z*B|`C9q+4FK5bGqdK7N28Ku0)so{H8f zl&LPn_*>LW4qRxhLlCzBUNu)Q@vr5^6`53JPG$22(`C|)8KcEZ-JL?FHIq|EOBb?E zVvJ5ZWaC?8b+pg_OIPC$6pv|~J!?|C+l3;M*-`2vb*dFc6g{`m+>=}QW^ z5JnMtC+=)PSQ#F(DwBdLlUJn82L5a>!^<|_ECucF5Gr3hoY`Ky*@EISJbNIRHlg#F z`8P12437_5b0S%@&+G;4+{a~-toa;e1QEY}=V=v~SPVB(rSt;k?&G!;XyZg!G-7lV z$XrJ%Kp5UF5XI|A?gH&b%(h{?j)D*!<%E6Q9LbvV2qV>HnHt(3McNhrLS6$`x> z4*@#D|J1ol38iCyZ-)7(aro=P?(PA#W(X5l#T*7JLUavb`C+_XY`9<|1Fs-9Hs3SUDk_h|c zsvw4lJAGM$HN(wEQY?$R_={!3%_CAQmiitGKRY~sy0Tl)1LB@DRHPd>s{Jb zNM=fK_|6~K$Hzc`wM0r^XMZPkhYOCMZ))gkQcQukDJ&g$bfDan^NZ3Et=Y4{X?`%G zdLw{MYK%yI{!+1q-uo2^>3tC~=}*{|Zqt00FCSw+4F;)yFjxVR{`qWxRt?jq@w(Kr zvMwf?y$&L5|7-+z@AZc8&X~jJ|8~E@^x9(bYtIQp1LAozeeHY|do6q!d{Vy1+Yy-r zCA>MmalK|eH$R=-itK~N-WuP4Z?><^FJ$*37ogL(#kUSnHHiGAHt@0L%HiVdbD2L& zJZAXE%#TQLzyP#>iGb4pqkz`{@_>zign((-LRd4{w2uP_)yT_O=@@@_&K=hyx*G!0 z;A#+7QGLGLbFvDZE1GDT_?bAF$mUb1V9#UB6V9h>jMTD=6Yvp?v+I3t9N$leP!&o` zoka%_{AHIi&rWud8rYAnBiLfE9{EGQH5c8+ema?+eqlavMUcd?I_4p=wH0kmVElb- zC_Sg{DD*#n2RgO z;-Pwexz5#-71)e$h9>;Qhw=XBdH=d?Pje92M-fCn(r5mAU&kMgrmUC-m;6h#pz5t*yNFv!*Jio~Jga5>@MtC7ENPzSqp3p z^55geRx{u@!YpEk1nI7##~>MI9D^1{DV`F$RT=IUt9g8ESHoj_95j}l84rHDgBjE8 zU1Qk^d;%_F-x*zWziaMhjwxm=aUAvL)`}3LN&ki4nA^DBP}=yh@weCaZ&0svSR8sD zmN0{l(S5=B&W3F-PlyBh8i^n4v(Ej&dDO{igx~X z=60%ffV{;+J$pTcu3|k>Lu5U_x$DGX?kqzEXfD2TLl@AXG)kDlMSYZ5d7=ByVkMD_ z{Ajf@tRZ*Ei~DG&@?XR1_#^Albmf8Wn)!R6nmjPCt*jPMOK~o=vP!p&qB(!yNI+|68!5>FSeJhC#vF48V;#=^V)<(*dE%1zAe==gRar@qaCEOmv)TjdtA zFld>V=&N<>xqxqBoa?K2tGLi?xt8-{a%;ArY}u9mqIbKrKxPg~eDS>fx3Fe8Ic}7m zGh~#|!S8K&n|e&bM?aXBlz=^Kov5C!o;*!n>Y{X)ZN&HD61t5tNs!^9H&K?&#+SAo zJ=wy%mzs^pceg8;eI+^3z{j%Jo_qCUB8)F@S7Gvj+EQ!cIlG@v-kILn#+iHDZhRr- zXawvm(Zcs0Q&xYsY5XL8iK7x_{pm(p*R;DH7pF z`ojO{`}4<7Q%+1nOhXbw{1vQ~gwjhNPXf<`c52U%cWNGzOa49A$)l8iA`UXE=j{oe zr8_YrL`m+ltM~0kmp_KH;@urq|9UEK3uWCoufExw>E{>GR^L@rczIcRVr`uFHFZ$WHhVO?QHVM<|DVNhX1VOC*jVO(LCS-e@e zS&><#S)f_HS*BTuS*%%rS)EyiS+QA_S&&(SS({m!SFBb+&w zpZJeR5+N783Z_ZDcp+8DOSo=~$7=H(wc4g@y)Yp`$YHp#%*5Kfb&hfy*S)$SS4jAH z%yb4ue||d}ZVdD?g$N+IUb2Ldu-6rxY$hSO|&Y7O>bQb{GBLjNN6Z;C~k;p z=x9i4sAvdlXl}@J$!~!2_3{nyt?~`?&GP-_TjE=58ETnn>1`QkS#23^nQfVF8Ejee z9P*s;?DbsiH+0js*A_~f-f@LDP}N?Xou3_>9hse*?U`Me9iN?kU!JkXHN@4&1?8IK z>fu`88t0nk8U%NP=fPuOD0mLs16}~HfJedqT)SQ8UB_IZnmbx6t!=Swol7UTEfS}H z1h#%`{@D0&@?-CG|8(>8^mOO+h;*Iwm~@x)gmf==KX)_tG zl^H|23q}esfo72d_=@zIdYpw;Zjk2!AW%L^3#W=s&$zMN$`&$FAOw7hLc=9t;#d8- z_*ckH*0vl8#E-}2DctX`CcbiH~%V*$Rxos|+qI`4E$=~@X+&sC5{IJ;>T@z6g zQUk8ZsVS_9s%fi9tEqADcc^tpcW89Tb|`R&bZB)*b;x!2?QY7ya6@0E`*j8Gs!O{H?f>(EP@-QtqM-}LSMvBN%uI%=ttCHw4@#g_#RBqo$)_wr8eWapk_XlzJPMG- zS1-TPwIlTV!q>*Gx~`0_l&-3-pst3ltgh0oxUMcxJSZGg1gZoDg6ct;pb}6lC;(Ik z$^aFEsz5=Y22dL)4OH{y|5p2!{#MlWTY+hM^e}mr#U<@wMBL({UO_jh9?zm`bTP%1 z@knj1qf%RUtscfAXf!k>hM7p4yUtE-;ksVe;woJYtaD>;0iq%8|DSg5e}m;UyynBP4lZ%!XKA z{O-ykW4-;lN#8@B|CAEabrviMt<^;5$IPF-Veb@Y9K?LT;8K{@O_mjfMC${bH4Zz{ zH7Y8)$vY$)=ss7Xq7AE|BU+%Idv6y(o&uwarTR| zQY_Hx=958jMm>;_rShhT1D6IvNSPz~tg%S-S8GBpPB+fE)K}flI$c(|mye>*I$KD>JSB@?LE8uk|@aP82S#$>7o-O7x^MxSo_u_ z?h|VWrt600bq>>q3s#s|nDBkT z6v;>ZTT#e}?H|3ICh|Bc&uW>l?y!>Xv%X<;JP{TnPhrZuZNBqgE``n!8a#(W_g9`Y z>tHnynxx<5a-su4rY+CUZ|qBOVva(a%ylTL1GZhU zuEwt;9myygHl}K-#-daxR4*hILTD4yDBn1+SgePA!d_MG)-tDHTMeG7p6c)_C!Lb; zl2kq4v#Pc3rKxx=HV)Y-_vTT83Vr*Axe@d z)-%KyM}j&0th4v4O`2<$bR_1M?zv2Tqt`5Ww^ou@ES@trM6kFm|HiE09^>0l*bdJ% z{L^K)4ZX0PY$ED9nn&CE7jRm2iXuY#c5mjISsmReUIK2Su}9?O;X{HIrXP)f%D z&xN8L$J$79-MbQsSG2X!rYpE--=-i?w}^?rgQ;J7N59DC;5@TmHkqaOJ>n~$ zxAd2lkyZQwG67o7Uv=n`on`%K5v>Kn0ui6H=E}e*A^30#r-r*Y7I|Tr>pE_>6 z`|WQ{Z;d037Ty}Dr4}t0K}=FhmP?jVY`1*3e48*&f={q)bFb|$o)@(*Jh%9LAD(-zVqWN&eAaW^5yAS3Lg6NF>3$b;LsW9fdzC$=Xiwx!qd7Y??6uPrYwbzh%E z{`I*mytPp0PJVhPMBCom`-d%mNwjNBr?q38wWisgy2b?Z_YeS?ys|oRf+Sx(E_837 zbY^o!I6x7HL&lk1QZYL<;~;7K#F(=Jx8VVIRfmc9tZfgJ3{vRedNPL2EZqop@a*5l94)@ncQD~ z)R%ipAzsej>x&`uR zYBCdxzGhRko!LTaJ&8rz=xquKqkx)Q`>}>Ue4}WU=!!pJ9q}G+LzI1rc8YU~eTsTY zc#3X{YYH$WFvY^kszUGu^9%MDvUHqu!gS1Zl5{d1934U(OdV_;vU!|$ERbLxd!CH< zodc5>lb2*$%)8dD)@X|0`V(A_6)TAyu^pZrt{u@a#xe0R-Z8;3_AwbT4lx!n0WncF zMmBLaUN%8CwgH9#u>qa|fdSDn#xn6T=`!vzksyX3u^^rxK_yZ-xsV2phR8PBgZM8M z!Q^)g5BwR721a&8aYb}Rzd^b|Mg5G5hKd}67K5yaqKK%7K8`ew%!I;($b?>nRE2Dh zVvl(8`2_6*nFNIdkpw-5-ZE6yu%i7(OX0HmDGPcU%_va{50iuLYDv4VXX$12j?jpA z+8qO#j*+f#fsew&{iW=V`lw~{By*l|XPJ-nL*ymb&e14OiUZS{ZfB_v=;7C8;SSA+ za+v2lX*EeTzFTO=hA1zgQW#NKR)~JcQm8<%Kv-Ldcj!~_Qy4->Sg>^HU?@#6O;~A& zW$0coelUJmT8MV&zfhiFp0MUH_mI0#^kDR`xDe&g3JM#^xS5EVxIchS8CtA3a|%TY zCW+5(THNdAW;B|)ShC6H7IH{=$g1gVCQLRKMukO0WYe)xX+{{4Q@ z{>*;#{_+0ve!)I;KXN~F|8c)$e{O$bKX?Ci|JOcbKVtvjOWcAP*zD%pL^=;%IMD1s zXG^C+r$T2*CroEgr&(uGCr{^XK7T%berSGvK6rk6zHxqRK6^fJesjKleq?@eK6HL} z{&v24esw-zeq+9FeppA-Am-?T|KicfeHkCUf9pb_UA7(A?%HnHZq_c}?%l54?%*Tp zJUk)31^Z;)+}YLH=&wH&{ky_~z8vYaItFPJTu zDwt6zS57CSNuw#Uqx7KmOG7Y4mP-~a16BgdyDGTKx+>qu-6*2Upemut$0)_fD=H|; zDk_i5jmtABFv&70SIJe$+bh`1p2(aioye0YkjRoK=g2iQrdFp^XSo##S%dhql}d<; zvr6$Pf1KKcsH5~<&pJssCLXW1ip!(AS z)85dh=`g7DG!3+r!6T%jzzx`eWEs*-p@LZ@qs>`ur3Lw2U=Iw7oWNb7_tLs9-#2C} z`zF&r6j_IhO;4?@P?4_7R{Bk>e>2homw{nU%dTwRpswSacK>Q59BvpxtY&s)*+?0I zkUEXJ$kxO?`!5B-q+!nC#-YZE#?hZ+KZk!#UXNUlqYR-;po~UOM2{+rDGV!2j*X0s zGLA70Gfq~HRF2w>*$p2L9e*Fmz@Mxf@+0~2>(Vm+ZA^Yo+)wwGzQ)kCAwWR%A8ahF z+ov_q?mt}?8r}z5dxO+T?!X3E-jDYxcoCC+F@iKbgB>Gh{=@OFmGzJ1#Y3Jb_k`!x+de4QWd2wF z5~`PN`4&F1HvKq_PHfJnBL$-JAskWMjlJ9$d}}?kg4;f@_n+>u*ag!zTBr>X3CkEI zl%iP#WQ3yeR27?G_5d{CBPW9wg#ElgWnLl+C73t4%oE2w9) zgU{_)qUSqA;N=YFTzmT@h#31fvmfbuJhV46rM*KllRZEVu8aBHx*VMch6c_U%u9S@ z-XNo-@;845Y3v8ouYhh}{QQ@x2T{Iw1G@5?5N}L8g4u|5r-`IOPG|zI3*-<)u}3CW zBav&m&L}n!lK+M#d|k_qDpT)NH-jF}@5I4twCqiAj<7Cjb}o>BeU)R3^eDCd)zPlI zx=gm1GpI?IU4cXI0oRc)zVWmzH8}m{T#y%@cF$cc2Ly*^eW0|S78LqpXx% zd^>W24?z&vcf*M0fkTRh|;4Dog(p^bUX^-^s}l{xxu)gK`9-M^@YwQ#|T0o|MInx$A*mH~MnJO?IhI|;6inqEhrKnN47 z;Aenc_CUu=@#-IGsD_Xz=%W|U?8ofKxo8vVqE`C`FWDBIL$*rWW8sKg21q=`r>ar1 zrbTh8bfGI>+f-HkWUOW23B}VKGGppxVe`UZ_dA4UHLHH1+c7xwY5=$qsVa4$6r|Wd zlU>!5Jy{7gszS&-rn1sN(+_c&Eb!01;&tBLFdC7-lJR=wm|B^dto_5guw9Fq9M;`J zd~H4T&z}@67@U9nfvhz%X$AR2?6y|tgCEP+#=NP3=C6||=WNRG)Xun`n(fgN#822m9=+W$7_D_PJ+rSnA| z2n_laaCA`l4)E$dO=i!JR0y3j8HBCT>uF;Xa!eM+is1MtwLGWwEbi5Z&_`p=5c1~A z1LnNOjp4ufQhJsMp&c;1syj|qj2Qc?2V@neqQQjy{AZtU>EDUNS^0CvNiRf|S~qJ7 zrTsHi^hZ>U+rUsoE4}o_0#hku9rnQ67I1gi#4jP_QeT9Vp&@Z1iz*1xZA*z8)zdRt za>Ro;yF^ol2i|pFeHrvIup^ou72K~!w<~w`jd*`F;fm|XC{akvR`(;V?NB6TX;Jz#|ZP`sp{V}&WUKrw?C=fz+Q=NHH{@M(DNCGyI&s{Ba&8_ zMa?GY%Nr7e!mvp5F@Gfh{pu@Mo6L=zHt0{*tgBZ(XI^tNYWgK{&hd{7D#=Z?M(415 z!{3zZibBI*K1*1m+?b!iK$=n9085Al4Ax)DEv=;U@2BvFLL<`Tt{*PgBdDJ?2+JGg zD|#0Bl#?$quZ&)7ZrU;02cW~ounbNP#hQWsCt_A!b<72xNJS(Rb6-g%5rYk_a$(zK zWU?Qz6#ZC-;v&#>pfY9O21}u|ZIl{JlnhF{*>JKB?uk|{AL}(-Mg$RJM~4y77S3BN zGSgksB0OguDLY}aMy?Tr=}jGyAFR;wp8bkcwPmm6v6T8c*e!u*os6cg&uPU_(&3(A ztle`({bakM7(7FgOi!cn*1VQ z7wsF`J|DX;cOu@-IZAxozrHLgh27{%!Og!F8}ennxj0i-#1$zK$ds-8l=AEL5k?d# z4f%xa$|Eku6E0n-K2OWfEFOgFc=ab(OnWVA;s`c=7F<4v<0Pn64U#o*AT6}L!Un#Q zwd2p#iJ;tb_|fn8;-rXt3#!3FRFBWRw0o<_T?}_d_2Nt7p>=~i7e6AXiwr+`Vg{+@ zAl4+*x^Z!mKU`D~Z-BUpE~6%-u2v9qea$Da6VabXDLQQDJz%J^MbHg>t1>G%WFuc) z5wo8ggXi@#1O`_US3GFqpDBZ{oUQ7=6!VDf(T1I~VrZ3pjeBe&HZVlZbBy5>_&jV( zv$vo(-jVDQ33kid`klQuo{d$TX1cxQRY&MU5hk(9ajdAo5TcbQgeRTB09ns+Xv^)# zK0tk^1*66y6M86i%9Rw!a7kG$jDh)fy>O;NCVu>+ko*7wSF?K%jlDqBA|`-|rXumT zj9-ks(8Y)9YPQK_UK&o8ec!`UBqdx^c1VAnoDbQu<-0CHrVYD{Z@&6fbG=*>N8>Lt zo)OfS!3_ELE&4n)!%ZKh(|8kma9hN7hsP;780PCS=*oVVHX&sz#;GY~uo2H3H7EzHtB00( z7FE&WB_`A9)h@tlEq=*`*;^qcY%Z1h$GY%>D|}!oO)HY ziVHkwGVSGcVpsBW$958pa8>U%4}gW%C#a-fsZ;S7thn~M6Qat%9hp5Kk3VVzPiC@$t1P=XRwKO>8l=(Kg1f$cb6oT&iI>U@7WH*KxCQ5pQr9{ zYw;?tvz?Sw_XA5X|C8fG0N-sdm|b&|2JIVAolIumNuvFem1 z7oqVCn(R^&?cF)!9BZbzMvLua?9F2TBqHcL-CNUS1;1*2Wym3T0?VEeMNEovB~V7Z zEe**to#K-@BPr9`6K#hvH80M)i$e1f`PS*M62(8Q546&_q-3~G=)Chm0>L|XXr=b>ZjhYkFqyq`>aROw1}D}qceMtd`^$JOZZGkaCBTd`k| zU(~8ZmnJCI=@vk(!~JcZ>exB8uVqx;@wA?;Efj2)Rd7%u%-rR?LhqB>5j6-QM0V&2-H>G`|_WuzIUa&Ou*|UI&|+9`d&Hpg*8jKTF-@ zZCg*0%PE7tdmd|bc&8m7N#A2b>Ym~X$Y+&6H17zQxkRx=!kwY zS*Ik_t5(!QN}9gV5h2qP-Ov;LVkBY^AmXAY8b8wDK2J>G1kAFl85UmS+QqOPX3cAv zjosD04Dga!(9BzhFt`;rsVO_r8&Ty;rZhrztiR73PcFRi+if1<<(Au;&K}$FR&@PP zB3NKE@YU|+>3$>K4-+*;^7@mKmowDDP#SDd#J-a_ewjrylu>dv{Wg&PYIIxllY0(c z9r-)Xm`+xe4lC4pz{Ulz5Tmgqa}&MInfOlz1^|pP->+PZiJ2LbsfwPNlOc(oS&&(Y zo|%^Mjh9f zTaNQh{y&CSmb|ORf(-*!X8x=~l<^)@e1GRxImF34OPvXI=RD!%k;yq-9Ye+6)V|v1 zAihr+afJxfmZ}Dy9_dVM*SWf*9JzSJRRjz=VCNxj{=RH_Q!amy+1NRWtmvFEx<0zQ zh6-kjM5=uB+!ulHiK;V3f3>2kj^B@AZ~O56r4WkoU5t9GX9ZGw}k&m+!{z9VNr4$Ufjvy%A;-A7f*@qL1 z`bPTDEj@#%1uy(!Jbt^L7AWzi=p@Md5BAPq`2js}>mw=59(E(-nI&OnGXKrHka{J= zts}B&YF;&Gqd{FMkfZyM&F_QIhsn%*VLO!9nACPmY094A52HO@W8z921v$Z-aZMlE zDE0*MWufb5Tc+ojn!&s+m^lg=T?W2WqPRchGBMMU+mkpq@e8v9XbF_x>e+rJ->FV? z2~j66h`d44RftKKY|O+V=_3ihtQZ|NbpwQHP$jrnU=d!*eUO6jG>yb_A5)X*@63v} z=hc?F2P-!yt+5jjDpGVlPpGZycgLv^{`}g7OB^Y4Ljz69FW%QE8uW01-VUAB70Ey2 z>D4toj=f1sXIV|=dMcI!2gUgf&Q_D&Y#qqi+X0~hO>(_7R6F9CrGNkscWzpeTyNfIw)zP5sZ1J zoiqVM0{2qQH9EFu6!Lt}vQPw*3{T0VW-n`; z1Kasc=&sl7Z-i~p>p_4scfb$iXDPs-lb)vK2kV^PA2}in)=WCO^f%<39Kd7_FzSo4 zbN!rEPJgUuK%WWV|*5y?ZdE|K4nPV9Y(Vxwa}!?(C&D0AGh zIFzAmj}XRq)qK&H!`aqTIvYGkC|QDC*3csG6g4Y9!f0DGelhz;>Y1^cR+de=~KtSvL$or~?v=G*FQUwcJ_=iMyDT*4%=UxWkOD~acK>byHT z4Fo!h+=IVw^-dR72#TF(1uS3HavzM=8Gs`kcmB?ejF%z?jx&NTllOnK+bA6dc!(8i zI2Ka7^WeH{FK(<5?ofdXTky0eM}3Py4vMjVq>Y?h&N7I6S(2tJ`VufZduqO9#rbTp zpCs|Fy;%7&Ie&LYwp}wn&E2N;YrNBCxnQ93N|4mXUx|AjxOO|%jYuLoL+|{|akvJT zzfsN#`0)PGsB=)_emXkvF?nbE`2xmeM|xsm!!DM9Ctg1{41_6hUX(ltYGP&=qMz+U z;C%6hVt18)4nh))4Bqv7?qb;e>iPY(Apv37`1;1|v(f8#GC-P~b8RniaBC@6h8Onc zEpC8{vgV$LI48bc`7MMEY21CTB>_nmzX#bpwk!nBxsmJ}zTXBDcRyQ^3;SCxZ|JpD zVWw3mu>;judZ=2oxF7nxhj&>!qxFPM0bZs<$OIX<7S@wl(9Kky>32W4D0Plq4^UM% zCu#eeYg%u=zg79}$ihnn{YX{lSLroUNAaqXLyd8%`;5Q=&pywg;SJeQ$F;z9={4UY z$792z)XU_f@s0bn@1yr4-3!M{<79`19AiBk_U zygZT?ZY8sh`Z?0paS4m-NHxA~=#^`gQ)e~u#J`txp>9&s6{pNowCs{LqSAxV`eW7lg&JaW(5@<}nZ8G0sZ(q<`BG2T)!@9+D{o$T-~F^twKHPg zeO*M{v^3JB7Q&qj30S!N01<(?r`B1n|-AYFUbcYx| zH2jgcR_Bg*E$FHTqF}%!^Yj^RGFw!9Vf@6fBw75Wzz$zIoN6R%;mTt~nm6K3BD=2* zljg#&gj5Ut>h;k2rjdMbLERJ1k^XG2iNTHuRo}GO9+%9z-J7?cg5S6oA;w$f9<<_s zUbf<>cZQce*M?kr^J%MbRfxArJ7U@k;Hc*yciWiz`0J(P`P1Rx0nIoFoex>#g5EJ{121@};5kG|0 z^z{pm=;sO|UJknfcw*n!HNn-f@J<3(93H8?nFF+-FCvAkaTmTfJ9lT*)vb5SE=nuj zKiow>peVY!BSRmg~RvU!s3TOW^s1EF@GQ z;;IsGso>u@k^B(VZeC=3|>;c*5BM#=p_x^YC!%qNKJBH=Hj`O#bT z2dbft zIUS5lUW-6_96ZEk&z|{VnMscOQG+cpiN&v9Tcgdb8)Vm^y{4g(Zb-7VMN% z52aZ|4N(kX3P#L$EzJp*?G^5Q?G5PV+z7Y3Z4r{1Xz-KWU$^7_DBi$-=iEwLa6W-9MP;x+bw;lIl9^C` zRd&>TPPtMH#S(&Kd1PyXo#{{aU=&Dxcx=>uU#(upJ>mzuBbBdA=XHmLNZUdSF%#7CJW*C=I?D|NsdV_>+r=EH5vj&ZW4`cLf}2A`YJ9mX>#Q+j z=CO(D1l)`y(%)YSquVICT@Q;FUOYrfwCu2k(jqmth&F^m8o*%|{Mi zyodFZ5sq4!4}$Yh+WFmbD12kb6J!2)YAsi03Aw8r@!w}F?wfzgvhhko-4Pc5_4`%OK~4ptE|dBYV5+*9y>vJXNy|6-|#ncK%PA7My4 z;743EF%#0N#&ZblC`aFuH$If6o5}l8qR|@ie*kPilfMSjP`Z<{D4X+V3QeWED2Jxe zbov!%)7^9r&7@g$FU_Vol&hwyyY1#WDfpGKc!Wu)r_QM_)mKzxSFx+wj$PSy?VxRJ zPn}i&P+zNWY}jO5wz4%9sn68s>I=JqUD2*&2W*>)WLBNPS)4#gV$&$fpfNO-#&I@h zUN~Y}%2{1RPtnt~LseB#Dq3Z$$!Zzbui>XMz)#TtES7gfem2EMTK?g7FKYD?@AZ2R z@Dar|^n8Br+k`7@PpMVD9lQ_V6)N>Ic`Dql#jPguyVT1t)(h<=*>m*gzwmqzxWu*t zoM%OxHJ8##X~q%9_j1@o{2YYajAlRfzbqr=6<(dSt43m6+J1G`R9+@bAoXsLvApdQlx$C)6QzOdVD)tKX>Kssprv zHqs{AOogFLD#9PG2QRJ$FGJ5iJzFlN=MY-bXtiE#P#bB2 zD)?3{opVtgJ)3Ljr_~;{PwiLFs2ys%+NpM{V)d-rrS_^#YO^ZjT6+%H;M3F=^_beK zwyDRtwM8Eaux%NflwJhaL zjrjgle!Y$|)GC#y^3|ghQY*{7*I2FAsI}ai_$KTDZc(#E_K*EAi@JJZGM_YnT`46Z0Z{YF;vj=&U(RpV8;^1+PaB@%+9N%kVI-?vL;)x{_C@ zd_0QPScA1#$E)gkUa>av3a}Z4*rNWd{-RE*Y3eSOqfV(e)$i3?>TUI3KX~q~GTxV{ zSJi9CjH%JMr&G_K;huoh}_MG}Xrd46qxhMbp;(FE7C z=Wjqfnxic`AQ3}w2Uk!TyyAv10h4&$os215Px-6wJlxM!)dDP(=e3-B*Y9Lj*-v(s z>?=8|&aVRfBdb6oe^t>bdX&!4qxD!lPLJ0iJwdP0JM>PyOYhdjdXE$D^l*AQy`4VJ zO-{0t=d5=&I2)Z!&Srm}*6*Efb<72=HvXYj^jls^rF2SzBZhmjhD$b}A7^VAt?~!@YvHCm5p)!wC7ai|?-{Ca-&XMA*y7<8H zvW{TVw~s&`kEa^@Dh1H#dJ_BdPMw2_?5j1nN^jSDP@O$>7KboBCb$?HPRr z&Gn}a(1N`dk4{c^CmA<71DpZq$q~v!FQ>rSg5K=K1l$~K&)!Q7b`K^a%^WpHxo-Z~ zjxYSJQ0*&Zhs87LA@&Rcd4Y8>_Fj80s@k8~pCgK6nSyAxCWrf;sb}JPy+AKOQ;y&o z+#ohJ@Mw>#CH>PU0yIrT7vqZE&!V&5>1R|>|6m1CWO z&OnTFLQV+doh8l^ggAQnm>_m%Iz>(qa>V*+Y<)7O2Tul1;sLh)7+3bCnSUaZ`L%!M zgernIY{L!@t^5lD)AHDjk zEUDZHu3uqsm66QxOyv8z@%s@H$3#%T-%T3J|F4EweD7kmXD#>oBzEB-*IOqz^6%m= z_z<7-4K7uoniNNkD4ur%ov9b~r$ID~>&XyT897{07|6w&rv&-mH_ zH;Z=UYS-69H(Io_wL!FtTV1rPwOO>ATSGL-y-Ku)wMn$6wNbPe@4ze`U1w$@x-joR zALdBh#7xJn%nW-Ub2M&ajtoZndnwvcDB|qySSB@U9AFUH<$PEY=1>&4{IH>r?r;Z z%l;iR*{#XE)jrA`Xdh#4|JJW^Gk)NAxi9_ljw(dGwR=>wt$R!~!96b8&Mgsb@179t z;JzZ-(S21k(S1#{i~ELXSNEi7H}_4^B=`5CJ>9oNdts&@KX(AnbFa%0@uZme6!t?SlvTll{O(kn6p#c-2xvwO0U+J%jsk@t+Z%iHZ0dwaaSy1u?aH`C2^OWj(x)$Mc#ov3frUG)1-zT1N%*4NZA zapoG+&@?jFn|N=lX=U1(9;UD9Z*DPz%#gxtdyjhg-g<9?x6#|=ZT1SiE#70^ zHgBo-u=j|!&wI+-;XNxm%MqND8Fo#(wyvzJ>l(VIuBBsiZ5^xY=&N;8{R)G^2}(VsZ<)8;EAXE5wtGAO2~wA)AOHXW1OzDpyZ{9N00npj z6aWAL7zKC*6aWANx&UJWG5`Pq4+R1O0t5pB1K|Jy|4;zz{{R302><{90Cag!OaP$( z0RI05O8$BQkO#H_svrOXp8x;=00aUBrT_o{AOH(^oYk0TbXB*q$0dz4qmjWj%{1HR z*kF3-y?0FSy_w!aGra}~A+*p!4Fu9i=+$&W?=6AQjp@DjlEB?|c=zV6^*+6CZ=bcb zXC$4q^xxY0X*5Cz5J|VnCZtHbLOo9=`KVlCg%lrK{_mHP1!N1^OLo@%WJ}px){?bl z1G!ojmeI1PtSBeR$?_{XMNXB|bYD4L$I2O)Qx=gM<$AeE7L={LF`*#AB0wY;fg(tx z5UE6Jkw&Bw=|x5nF8m@wM2gHJi^wLjiyR`S$R+E@DzdI@Dyxen;uDcqZ{QWmM%hhj%1ZsHKgEjnVue^M;>1R=Lu?ki#CEY;tny}1 zryA^)hr~#49;$iPaOesBU^tA2iLeNc>9HnNV41LFVTZ!!g)azy<4fZU^HuWI^fmT1 z^)>gk^bPZ^^X>7S^j+{h@;&#x_XqnU{aO5Z{RRES{iXdC{jL4I{WJXQ{hR&q5hfy4 zMA`^{L}Wykh};qRBWgvoju;a$C*tQw6&VznGBQnMhDcvz_Q;%((UEN;J7iLsf-^;A z?wk2}l!#JM$)bXzQb(nWS`@W3>PXb_sGC_tmXcYzWF3*Kd#(Yw(=N`iIO6q(clv#% z_a8odNcuYcVj;xBU>M_RnGD~<2|do!BEph~z4x>%^a)=&pWheltMgGyYu`v;oNu4+ zv@hQG)c4Xa{3$&xdHnhP#r!2bEv@{${IULp{*52Cg#1HG&4~IDqa&t#)RMx}l0Gv0 zqn4P+_DNd&nPW2F&HUlNv@D4_^ballbH(I}^|Yj2?Dw>Y_x>a;|5&B)!~a;X!fyPT z_`DVM&joqAs`sn>zb(}(ss3$s{ZH++n9E%*FB9T&h0A4cr@B1lO7VZUtV#GaVZ9Jn zMZZkeDnh=)ro39;%0VgsSWjCpw9r#v|xV zoaOOnE?)VYKEioK&6-Fc%0W5hS`kXINgNtTvxH9!_BgxNBkg*RwVON+=J!Z@H;J`H zJlcA!6~#T;_VRe!$75}*Tqk;Yyp2yJE`#XH2CLBqtWFz+7P;|rI*()N0*<42{DLmx zBvBM+h+;U89^yCj2>M%-ybaj%FG!J-Xbx5e?MEs3{m zDUnjN!`q@gfz40a)*!OAL>EeK8&aTcB+`m*=8j1zLPS@}Xgg52?M$JzBfk_G#HW$Rq|(Tf2llwd<*?7$%~`a2jCl(ja@8 z2HPt%#9pPL_L|5lzM#qW4b5gvb7(22pyiy3mT^ikM188t@KM!Ml~uh|IaOZu#;;Wc zRZ;a(eN`n@SyfTdDpplh)l@%K-Gr(dYJhF52CAB>7WY=Q<#l;e)lq{~T{T$MQ}xvl zF07`jp{juzrW(o{@|J3(8mlI1xN53KsAj6U8mT^0GgJ#TN`0;R^BaDvX7aOuLji{a zj!@quX8cwI%xZ8%SR;o4mZ5OObn{g_{2uzQ(J{f*qKz)eof8nVrp)GqA~UveQuvpJG+#+*>!HY`Wz4194bbQRc+K4 zs;wG_ZRs#Br$4Eb9Ydw<=TydyrLy)5TF3$FOEq3i5S`RSH3{3{cuJrk>ZvBHuiRQS z1wT{mxDc+OzX)wL)m}|i9qc02QB6}z)KaxfEmtelO0`O@R%_H+wN9<)>ncudFd5WF z8>Kd>&1#FR*|KOscxy;>JDF4chx<9 zsP3x=>Y;k%*17fSv3jDOs%PrCdZAvbSL!t;Q*YE;^^PN9C}-xJFwBbtMsQv(;10Nh z{DNP>C~r3%4WGkUXB@&8FwToBR>7AdE?_pMFxSjwbH!ZsqK66Qo%z$-cPDu}?^hqA zj@@1avK^+FLNJxHa4yd0j=(gS4m03umr7^$rxkwk~vbr1raW0Q5AlA4C z?x8E>3cI4FxjW=axRS1vEA7g-vH@!XR=RQl^RPTtaOGV^SH(ScPux?N%RO_?`GXSy z-?{r3E5_}?oI%>N=~}WuDGj*A(+-Ra1B)k*Vr|4 zEnO|w+Qqmwu6@8d*U@!yU0gTU!}W4~T&zjw2Dm|Ps2kx%xzF7=H^EJIQ{4lj4;4L!1_8#949PHV_xYMG-G9 z*@5D+xFW8JtKz!2A#RG>;*Pj$F7hHfh!^sD_zr%AdG4q?21{TutbzHk%!?FP!8foJ z7Qk{?2rG3SU0CPUMRY!0ROi>lbOBvl7t|$mAzc!Ff}iQKti0lVy1gmiZd0^`;_PvahnPrsBBD2bDGP}$nbIDKWDLs?9`HIYGm)QcgjIAou%TSw- z@AGXYnMs${Rb_ISN0-snbXi?pm(w+Ld0kUi(6w|$U7L&WI`LM9iNB$zL*wvN{IO=B1D65LgH!!$8XVI5q7^>CFM+WF#%ObKyt4K~1a*a$bwGjk6% z!A;lY>3VY!h?1Sg9 zA6~!#cnJsLmG_E{^Hn$mui-Gffg|u1j>0=Q27khF_=^+{qGLFij^l9p1Gid$6Y$=h zbr<*qU*q5SCj15;_!QseKlmQiv@_s$E!;VGkuUKRKF5K4o`d)T2lGXK1ShrRczz70 zw1Pi0z-g`F4BdjW+Q2!Da9$H!&=xLghIsAZk`90boeVDP3{j8;vO+e<4mltvY7{Tws~(pKs^*FQ9*qK)X)GLLZg7A zCX6TAdC(Y|&^fwk$!4+jO}K4mKegZ3AMF~q#=d09Y3Zn2VSL7KBKU?oZws5hps9TV z&7e7Fgci^eTCopWa|Fad8)ysdpgnYej?f7@Ll@`@-Jm=4fKR>iUN7hkeW0&*R_X`+ zVE`9|fiTEBHw|%%+z+aRTa4*2J!Zg+7>Z$Tru)S$#Ub=Nj-t~zn$F-DI*SwO3Qnf0 z_!V8lDRkXjH#cx9-N2Rf9#_!^Tx|ueu@cu>h1)FR9_zzHHYXmox$ubn1hd=Rc+}>> zXSNVNw-w0QIuu~*QZieQf^8E@VVhD)+l*4#=9JFHPjGT62hVY^bK?M9hwcgk#g zP&qq}%G)ogf*ns4?F6c8=TJR6ms;5GsHOd$TG=0{HRhlWb~$ylE2xuQNuBK~>S9+@ zFB?a_?FQ;&H&S1_Np-UKX{>!fU)YB<&OV|q?PD5mpVI{Uf+pHmG|9fEuk2fzV&BnJ z`zOt?ALwfqw1|_@N={9yI1R1l5S!O-wtsPQ*UqlRy0jJR(Kf74+pz)tiVbN8Hlm%_ zn08?k+Ko+V4>qH{*qruZ3)+w0({ucRUf_@P5`UssxR_q!&-4a=p|`k%-r+-A79ZJy zl-~}a0(K}Bw8N;79ZrSq2r6PnQc?SvBbUNim(sCI<(y0H0$dszW^d4Nd($OzAuhQ~ z>jGUm7v$2rV3&brvZDEH>05TRfSGG?J+8wIxHi}4y4(=kV`uD$U9kgp!A{tXJ99Vg z%00LXcgJCZ59Gc)fcx;Gg*?UP3=| z9B<~0yp=cb7T(0$xHy;Ql3bQca2YPe<+w37;-35|58=T)hiBXAb{enb75po2=N25p zt+*|>i6p*#+^;AT97r}3;QX-b$<{0-0Jnfx`+%(9g7(exe4ZyeVgj@nPP{hj<4cp&C@3D{y(PXo{L5rmCrCs+(w2!_+jjOl?!g z)HU@?UX$D8F)d9i8Ex_zNdrnMfP7!R7qiFqjV zR2DK%OpIxx&u}JvR-e=7^#y%V$LrtqNqtJ+(znHY`L&!WXUW-ej+`s!$#3L*xj=p^ z7s^HQJNdo7&*?dwvvYo!qXTu24%R7jO50wi(y4VC9ir39+p?ohr_<{UI-?HNVLDv< zwBPJ8d(A%CQ^x2BHP8GeSDN4DD)WaqV@{g0=9D>Y&YAP(gzDy2%Kh@7JRlFr@|fH!*T|Z3x7?v4Wt`5On5)xSbvE77^fbLpZ_~&0HL<3j>2C&@fu_CAZU&nn za-X~-@0xhq!d#;Isxuw2Tih8nOLbARRaZ4f%~d_rH)_6FX;zulW{p{E)`_x-`8rWU zG&94^2s6@rCd9u0ke^Wq0001ZoMT`h8hi)BeGL0pmoYG~FflOv+sMA{Ul{AQ{~uTc z|9^z=kkzm*WnuXL8KH`G3yTntzaFe^6%f`l)U)-mE@hs^^bsV+HidO9b05=V6!|LV zX((!%nEO!FA=`Hb)m1<~++6^Z0#FBdoUK-AbJJE7mAoWQLY9(+7Ik^z#c66knUq2> zU_y{AyWlR))=E%XDR$C*ftDG5gMZDHX=ms+ep=6cvP~dKJHwP=e9yZ&dUwAH8A_0` z7xAI!9l3AWHW?uqo~-u`)9@nKAybiv z4jsxU(G~Q(O}UkO{Z(_)^E>|b{lJ#C)e8i*+ks7+p(Uuws2YYMNl9^+R-qc41g-J& zHD*3<2Lev?VnLJbAc98lvq?tljMgJ73d7JMvmAz!jCODkh7M(wz&*KQ42SYwJD|LD zX-v9sKO{49D5oU+65S-f?+SjB8s}fiM}CL0B^!EA^h6JLCu{j4!rBU=wiR!Ofei6< zb0@$fi-Q_ib||lC+$;BuOq!Z89HlFfV(G?|**_$+1N)ROIW(>WJ2~Zbp5=^v!8g!m z6fz~MYbOh;KR#u6zFV?K$(~RzCx0@%#Vo@G4-rSg@5z`8p)+MzoJ|rIoE&;d*`kc= zsfnpmUZ-WeWmqplJNnWYr330uO=kVTwxk`FY=@>*lF9hgjq480C=i99Gu~Z(9YDGv zP4j6Rr)iuVn#DD9Iwb-b=)f+`c#-Huf@Y93hvrmkH%M~bdbmu}2l9zSZ>ZK*(Ar6r zmJR*9)}K|0G3)IG$?U90X6({znVS@?>n3OTXBt0bE};_HVmnAUd5G5Sp}cIiWJ|m@ z#8UqSD)CPXAn_}_%~s_vC%h8Q`c%<8HthccLSQ0uJCCJO*tvi zZ?1@7{;#uyQ6ckzLnRF!I#kx+kwfn)gQm-`;p2Po@m<_4;3G>L zKC-+3A6ZKH$Z{DzvMj@ONSt~zu@RnFBMTK_L9ny>@Q1a`X0|8BbWsn0|LuzhlH5D*CLNsKPjd8VVI%OQdAfv`^P!TnJ8` zl#dm0x^wjFn-=P%4jxoSavR?qc;F376Y=Ny)ewiJ+)z?fIBN|o=2}=uD&_(P@YYD( zKC0e)nSCPXwxVkJ#7kX8*UCK@=4OGn$2llVg({$WqYfKpmzztX)hig1^tw8h26p&s zv|{uB>OOX#_e)J;g&e839S(f-IT^$F8yvqa2MHL&F$%efkQdY8#Md2jIA5X5n8lAz z(ci(&H5caT3h-S;S0P%QH6M8u4SdRmdHO_gJ5meqQ`N_w0r(8SWbnD_n_ANb(3&mg z_yF6?VX(s-2D{8*u*aO+0ADbN!I#Wo5HN>9$Q%#g9&;GnXAXm}n8V-!a~c3&Gl#)9 z%wZ5Qhe6C77hs<`3_8qV&}9yT14Y+IX+GowZ2*0%(Ji3wbU)#+iNp7bZj9JJ@IkYG z)QH(XX~fi@71c)6U-+P@ziPzP-!x+CLq#`7)JJ^K)ZaB?>K__0^|5+7k;@GKcyh~B zIH2ru`^oT|;`{@Xg-ve&0RRF2{{RnooV$&zi!mb|yTw;kKD z6UQ^L9cS-Bb^_S}LP$tR!$`s=VV6P+EtF9pKq-_}I-o71gb|=5*7ZC0UdbzV2><_k zFTdEjSC-DV$NA28&ShW>4}*c}@KX#cBh1KRo99af6~ zv09wc)LbO?M|kT;fLUw~!=LjR*Y}hxu5s%;0lyVj+%0A*-9eu**>6j+X@wS1o!l1C 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≷#G?Y0@|tx!ZiFd=1H)lz!=Ay^kjz`9lD-2zlyF}bTf`EZ_ywMr*6Blt z5{?oQ1>qK98>x9RKER>;PBLkMme89^TLA0R=7p4OzLJR(v*-a9iMU*nT)C(`k*z^v55napT#ro)eYUkJI3TIHK zO>rm`jufpf=v09H3VTqm3)mG3^4$5LUBTQOKfGQSBtI9_O}eM)`X}~l)PT<-a}z0? zUjKkNCDHfrS;t8k@R$}f!aPIeE%0wZkGMq9cbI4P!SDTm?L^&BSLAe0V>lQ;6Av;5 zd|TU>E@Ga*aAl&+nrskZzhJt`7h^kpHT{`}WV1wKPBvur*Z3d|CNlvYVri)!zOivA z!6AmoP??c^Kg!l7*~{~p53s^5%b5x0qIo3-ze!w>o!?h#hr9zptQUC~zXZoH#;VFN zn~j|eNCycrePV)i+>=}F_LK$HIPS@-^|(s{>dm;_ZBM~*m(87o`}|cQgCSJq_rWQF zKCQy%2nHRVloSYK2tSWpU=98xj3u};v()Y^PEz8yBeTM3FZ8RHVs^JJfMZU(E17wZ zw=|&B1xmf1;(%5gDE2r50VfFq1*zD4^j=mc1;c$MC}Z9TWQ?Q9n^zO3$>o4FIqmLb z@C|fVX3cfCid{B571F2Ilk`=l>h-CWJ_>enGJ-%qCb~fTF%&Gr-$n^`Ero~oiqzsX z9%vA(!tCK587F# z^J3{=)VlK$$zN1@+Rrb-Za{9QdR{NHROI$?Ew)rIEAG3zjTw${n292PVC76X#vdm4 z!!mzi${@$cFqtwE)oO2S-_BsGJ9Pt!;d1jnXmZ>ZUods(l+8G6i<#Azgf zK52i#{^haN2Jn8o5<9bX!)4o!^Ohy?#%(O7#(afX58fL&Mf!4l!s_&6NLMui-Hf-PW*jRK_N;`7LRpTCM0 z>PkGGQr)F*;5X3G^Py1~MUrUWXa9*)q7fDNmxfTI4_@VA(YfcIznbHs!N`M%rU;=ccGxR#S{&?Wxe}(tB`5m00n_Wq%b%My=yp$6DAeT{UZ=FdFEgkEzOmC3 zbu20ef|(Ze18KufYlagv=p5}ZR|5iwM;Cn?Kl%3Cmjds+gDm`z<~MbAH;X=-p5pjp z#PE^magyoS{20@zdh=%x&h_wyjA9U7vZ>iXHo=k@lP$lo5-tajg&8vosR}iE{1L@b zp`0vfaAZaW@gHqK?pa#IJc{O|B6;_PQI(BZwL1Or~OTjbGfZ4a6TYe+Je!CQTinfQj32Qblv7Az##W;=?^&;*xjg3+w!%{0H1lER8G38fsbq zum#QQ8vNWeJm7&j_Qj2_9cpD0cY;~$)>Z@?d=dUVa?ywohESrgZ2C2A%cGR*XmL8A@AEc6KI7U8Kb!k1IBepZ^NZdv*4 zn+DSDg>9iM!smA3BG4r%Us&nr|0Qu~(<}R{G8Ww0`}TILAAHKsA3QoxwYt%pz5MiG z=}=8Fmr(kx+pkwPFW+0c`>V5k^?RNk8hHB1Vl7=GaE*M8wPF&6fRRo1Er-InqeV@? zL|9C6S7yAodeYM+$Z&L9?SVWFOPQ6PHB_IBW(9WC0+!NityZBzBMf<2P9@g)QcqS- zsncH6v2;sGMoVF$K%&#>r4Jw7Q?YX(uXNqXIUk^Pj}k9#^p>URcM1$Dp*qx&~0ZDKnPjXV<65f3>lM?I!HmJd93ZB0^e%hSmr zh3y{@uG>)-7G`V-nMdl;@tM494N$=TSlhx$K^pEHx z)lJ@%tkCkuH{}9f{nE&mHxAa7ZGUF*+Qj$T>{F}`fRf|)|!F0x-cZ?c}*CyL2$NSFUqQF_U42Fet#PgJFpCr8>t%AD*66I60O-x{v<+&JwOjpw#l0K^&8aGw22Ae=MUbThnY+@q$b&yD+gb-HcW}+L=%8&|7nU zEk96TE-B7cSN>-vJ2Bu#pEM_{QYupi=8_vXhOOv_y)CB9rqt*y$UBh&(jMEPzk`V@ z%vU5-RWw$aBxlXB(rD~yL~&;aO%W8KJssB^)o=mmY}g*u^hySNc^?KK9jz$hPW(@9cb+IQz+}nuCAd^=DA~@k;uvJM4X^>pVsw zgL>|Ol02`EiBnk`GX{}7ESb)fsZ~B|kse6KMF=I5YK$zbWoi?%9O+reX)fw@72{Pm zzI%P=u4W@o!8ZD{xOiiEa$TB&BNvo3MV7au;%k4sC6d&#p{{ysUm*|MZwS~FXhvs= zGyjDSQ{r!kXaBW1clqso59Rx2I+Bf%p{j>g?ySEHAZHOz^`g?EMYW0P3+@;s*Plne z1AoT=S-YT0gQL+QeEfVH+m+tJLG9rpb53)bgpGlywkG zA|gx3>8L46<-L)R9J-?;V3cJIwSJo0YPHq-38z$p-U=9cmnxw}Vp0jjo{EfNX)5_l z7##Y#WDFs5DEs&r=TtC-bY*q4_(@%0$vgy3EUeCwke!vay{0!E#c=())By9AA1b)n z6(xg?`X6SplalZ478#TRWpa6-zBSD~!~RuT0Q)R@`|QPymB`+xuQ-3SF9Q7%@{+8% zG814t7~fxOU=6v;o?EA?3rpfL@}cyizRhAY)?81vug!fL=MHPp~wj5k#i9N}98~ zitO`yIuzIEw`Xa!88dU+YjSeVa8)wCJ6yK1$*0R7tgb0>LOsFj?c6AE`OiR3>tIy>e?6S+p;wQW078P&xTvt(w?w8iQ){r|l&95>qD6761BJED}$;5iK zf~&}BUQriXy|7JX+0;7sSbrMC7a92hJB$*s7~lnTXPI#CdgEMt)hnPiWCe5Sh%7o1LL~ijRo2&}d&m zcbO8+HS@MLm(NTVb;}HL?w)J1mu|gn{(VIB$+cxVoG0O(EV}9Zefcb@*$o(Cj9&;st-xdHP7ZaId*{@6YV-XG=M4aTo7|*Ux%Et6WTh|dOQ6aQ zr7t=;v~`uOYI!Z^0zh(?ot(Gvqf?!k0iu!K3x_=n=cM%6`lAcvl(^_7@pw)an~Wpt zW^HY9>B>lLP5NM10(z^2gM?+WpV1m~+ceX8Ro?PSryvO>@ zzT{o4*SvkKHD~EQ+W!h#OTTL<@J?0EQOu9 zY2}I1n3}Uy9&=<%Pj>0G&#j+-O9tu_2vs^&diVC~;?^9WTAmcjb5tK{f>AEfuMp`p zYM!QW?!g7CUcaTaJVNeO9Qgq~fDTi2QgQ|`!DUL#RBZ&^jwd@u7=@GEXA$uwAM?3T zfF5^yqn{Mhp43;npa5~tHTXw+TG3~r51~3Q(9yUx*55@En?}~hp9b*XoLipl?%306 z<<_0A<26(z&aO&95CDVb&cd?aseC7e2J1IA_7lZDAHy#%-HtE$+#`4MbMoJ}0ZQ$X3_((CLEZx3=&7 z=bi0o02~;k8WOGT!slRV`e&k&E$i|Y{C;z@Z@X>7`W8hF{ z(NMJqK{5tzp0o273|)*At+{*Nb?@CWgT||vzH0*DAdGcKiR0*RFzRGm+<=bFqtI!B zUA%b>Aa^mv8oSoULwO3D##dVq6whRf6Mo0G>hA@6`Z#jE+hFCQxWr{oZ7fIyk(M$?U>12!v<5Cc%xk)N5J_w-V`05v5ceK&Pain|Klwb8ELev=9-C)MhbJvFla^ z_VpzmCv(LwuXC5=XB)iqvqOR-U*Vfze6Eb+L@&UOHNJ$&NePoh`&@cke~=X%n_?kO z2Q+cKK%f+Jiq@R&&6-)@LVPf|OwygIh=KL#is zRkFiglkX8oUU2z(7Z(4CWqWDG1z$twvtL|HWXEYll=70^B!ek4YlhiLC~U zyf)&mbUo#F*hX|Oeja{KL-x+cJ{voZKc+4CggbC=#~zbdxD(7m6Xi_Y95NpjZPWVDIT^FEcV)ozaCIJ4PvpusZ_a*5{c2RnsiV0FziMTf{*df zAZA}OHe>53*(8jpK@V6&?Y~qYT!ii*0S)4{J0dc`H3qe)LV%ggV9}k#>s$N+ zyTDmiUh7+-rJsXB))&dOR9^f*IVzs8=gBn`$tg)DKtNPi9#Qu}^S5U26YRE-YiT6QTJ+hbKisX4aMHW$@^uo-&X z2R9S9IqDjkz34M|z;?_toMXm^~kF)V2XE%Gtq~02(Q@#W)k0+ zJ%~w|zxoNl1^r)KB3o5Po@6js!}zIKjuCql*w_IE)TD)SC%NQCZ)d#0HVe>wHT2O3 z%z5TQUvjAiue&KFOa|M;ecdt70gs;LG*V4)h zmCNlp29T#JbG(MG@MVi7rP(s*L_zqj-r9ZX-pX3k*Mo)^|t z?pZg_-p(~k#AbI&UVZS|gKL)kQgiQyy}kW~ebwnQnTmt!OX~tN*H^50Dv)@jx97~3 zDqXO|yG9_Tp0KrZ0{$Coi0D~>R<5^a=s}Y* z!}b@n(~%+&m*z!}IUV2&w;{R-KLv&00Ph){biMdjBVXg$P;b?AZ8-s<_)BG^7^$w< zZsO7r;*O-wzQHA{^CMZPtX!FrmY$iDn{Pr}un&o^h$Y0oAMCNJRk!n9l^dRb$wd9T z^j>&4Hftkg$0-w@?F+_P@nrx}d}-XMUkw5Ms8#!?$D-opxTO0@HcA#{aQsK{e^6@_!D-eg1fxq7xfr=Z zQCYRMD{L?B$@!kTh;-+I`HO$KwankRV*kmR^6%tJsGF7h@0=^JHPY$%)2JcePyD7QActY0bpj)uh@ncjO zJ2LQ~?Wp_GchJckL4rr%?-%GOK{6Ek3k(kQ_cQ75gV;0YV}lxr$`-$T?~WFWAQRwOT-%c0A8sT^ zLdx}ePHO+{%fJVOt$A@O*NNO2(>2z;aJ)&+e`ekL(2tEIBH$cJ3wWJECr%563`Gy? z9K8-Vi67(->s%%oNxeUAoiNVjoT0cw+J7IEdvQF+n8yC0GeX00XY@u0n8#9#!^AcX zvSAv>^Y%IDV_<#+>1ED>KE?u=l&*=fw$c2il!C3D-uEDxQ$vOhermAzNz${CKK;VT zSJ<8Sqh!uL8e7SysK*wk;e?lVH(@jFZ^%FF>iF{DwzqDq9ejrP=FXF!R4gZ-U#!i@ zuSu>xu(CxSJ*q-FkmTmImDPh)sS25bg+*ud%(?s1-H#Hl{B7fkfkh&z!K>kAF1o${ znK?)1XIed03E7X-0CBkhaUmnX#N$84J&1>8W|`xuI*j{DY->mK%kJrQhMU!Gi7R%ns<#OH>Vb=>u@|3lh;0LD>VkK_2w zmMglV>wCTTraPVPPQ9Ocm(^tz%eLH$+JFZ|b2Ga}}FujFdLocC(1iqn#Ktc_K zU~BI;yL+c*1Nr>_A@c3c?#{gT=FQBTH?Lf_{zEFm{qVFkd@8?vZ0@naCy-g!EzT2Y zJw_2vPS5*rO}YibBcn5D$mjN}|o z5F`fOvZ86Ta)!@rtVoV^yq1~U$5ZOY#!u0he4!jTBKE9Ku78c1`ifa4^s@NxMv^>6 z-k?T5(2zSqXkCgY#~5{VBlg}auaL``c_op+V~orJ=X3*o02>XUY)+~XxlnUrYu2o-rsB0g4`Q^u`ypipR@30d52Ua>QjgJStp<)?P zk}ceqamHgkB*y_ehHQ+Fv<5mFis#pQ;$WT2Nq(~8_>2(W+`Vv9Wyzu@KkU4<2U=S9 z&CTNy&Vr5=NBhxO-P&WdBP$v<-OxU3Ci3V8XAUnQ8@S{|bEKol>gm|o+j89%>wB_t z*FUv0_tO0bcW;_gE1~HUfH1xT=^~+|ZkjHsBVEY)$>Hdnpe!0owS_uk;I+c}O@3ob zuzX3ASLH84{c_x6F*J7d`$Kh^nyxEfT{&&=jH|Ml$r*rFR2)*rrPX-mN4u2?d?$+?J;k=%*z z&_$S-J|E3t&PQX++MHBR(<1{P-~Nvul(T^jk$cMn?($46W%`blw+6(Xh<{o|R18`( z+X}4(Bd3P@uNVqXJMzk!_?)uV;@kzt`nLSz>>NvOgST-v&CA@x_sEYJ)9Xyvuq_%za))Fi^T82(hd3D`O%)b(%e`q z$85?_8`OgIPG^o&<|yrrR<9grs*c+=9=S@9CZCm4%B%(NBz{5{V?R^=hm;*On?na- zq6Ig~&l1gJjA|Emz7>m$;+j*tf=)y#j@1dv#D!hU;)PCONhbC)IZ)F~t~_*Fs@`2y z4OVn-Y_=Z`W+r(G{Q`dg@>KW&oUPJJOYHrk69xv7B^p@DN+%1*aV(hi-nwze_ zA{Oj}-)MztGCBOFw$Le1)8DAlCVW$B)2iLgRXJkxb@1usukWg~xQF4!k;5)pam&2? zmP~~}C;&XsJgq~;ch)a&xOP`$Cn_8B{7kL0(lZ*~%q*8I-C z*wWiq&bXtgh@%lJ-O>8IXiK(E>CUwo+w5GaHcOk^nx(FsmR+Ci5Q~)}bh9zyRJzJL z0=BA>s93(Zt!UHi;{2+a0=dSh(FIE#mVizuUU%@`)(19!yW#6$LvDLs$h@)yJ22T>H+Jm`uIf(R~QY4zOPJu~l=-&C@ zhVOoMM#GJR8HCp?3)D^z0ByY9TH2R8c*oZI!`qRP$?z^(fA`WT02IG{3)kpo45Kp- zLV8g9M%vVXR)UL|I246ILx~`?7c=8Bj5lxms2=5W$!$U#VfBk2!TB7aQfpBQg7zb} z>he6|S#>DwI(eFe04_zA3d7EwN9L$=^`mp-gcmtruGAH+UcbH0>RkR`fC0fyg^A>r zW_nzR#-yNmhKf)5A4pF=1DBcR4zmpX&$^!?IcXo2+UHj53Zf5n3H_Cr={$e*{OgN zMIbp)F9<6Ew4kFq)LIrwmvwXpn@cm(!F|^xLr*SFhN1)yb4A>(>%6sd3eId>>#7>c z1COQxP^JP>(!On}7@r7hA$^~UJ&Ldv&@|45@~#*Y(c0bQT*IN2m6Ot-Bi9jm<#le8 zOTm%o963_**n7V`r!iwoxO`No6`_?y^}citUx073xXyo!0gY_*RY#58RznSYDnB2- z7k`ySwNgJh5+a-9oaCPiCiM(vqQD8=^`V)_LgCW_^$;eMXqpwDqR;ks*gQCgi6sk!L(E z-}EbHZ~x)p#darE5$EZ=tfk4=5k}TnObX_Via7(C5}3l#;&)OFx^sJT3I2uQDWZ*9 z@)_7*EuJ&9t7}r23fNW*cHGsltz@+7i$uS;dfk7rijQ@d59Z5x!T$ugzImM&l>KPE`X#VD4#!oOR;(dh$t#dV$i z3#UZCwO5zKdeOf8LsbB{rf)vM|F2np8JN5$&o#Ef2@>UY!5@}5vapzB$&~ZYvw6z zTF&G)2heAq^N#?H| ziWKA_UwN9ET78zNO=c~fo*P*@ufNjmp0=sIXv3DBRUPgy9M_p}EltqzzLoUcM)~vp z&Z-y266=0iH|qMGskY}kCc4P^pMG;m`ayQ^n7ps{dG4CLciPiZ!e@jQ)}i= zu+4fXqxmN2buJLjXtfSVsdcIw?pQM8*qmtV6)&zFJ{+s$szhR=JI9whSeGRt7s|md z_M#c?;w+C$t74-E^U8`>ou0SlgOlA=RqecVg<9dLm|1vg(*~tlAs4VF`=u7MMXrRji}X1mffus_u11rZw!Ck=?xe zp*i)Nd&BodzTWtC)}2*ruj^X9v~umq?$smUj=_`5i*pv7n6=~Yx6R02aALNaY`_57 zOX+X^4EI=+twkCuNO?=7%&JmyUi!GMoVF)S>2Z*kZ_J9jCDlc@0`10+!~F)2LCIgK z&M7Xp=J*h)*^x)oYD&DhO_|EztZNpbv#rr$T~RT3?OXz!5GW0@m;F&aPpaN!vMqOo zMS_gt8fVUm{ycilQ{w?(=TaT{>A5?F0S7A;d6JlE*xGlZ}ej<@7@nT zychOG5c0;?csd*tf!`k!G1xjK1i{uH`<=lN6Md%q%>11hq!Z-#zd268Yb);oLh^@u zXd1kaZ9{YMn;2h2+A2Vqvaq2~J`D&0EJ33TzeFWP*;#EP<>m9MENoOy?8Gs`i?hY{ zLcdoNZp|?ob6Ue1ufNbPW&xnU79n5a)xS|MIIlEF)3B9F5rVr*JHlbO>%kF~d=-WW zb=b$07S5rx=edxY6xq5fqbh7_DfOXd+0ytScF=(-UHnbmDo!RqR) zny52fD&tYWm|_$#F%u1p#Sn25{)V~v(^j?><`w%7-H_Q(T2S5;DXE3qM4{x|ix)sh z!FUIR@nQT4mW;N5oEl$Y63hYMgyM|>C6chSDWg5mGfomWLAbMT6MKU}qI5y6JG*Vp zKwY}?kklv~`ZxkG3ye=tnJ@Ha6&Nj9es5-hE0W8VQ6WNDM)Ffo0gM!H5RCcYl<4uCLaD{;;hDk?xxx`K zIdbeWxadZIOjn4US*32m6*W-~sM?GIOK{%2nI0&Y$6=k1qhGKrAnKs}4zpQHkQb@8 zAip%iwqz_;Y)Wq#A=ajeRJim4N~6^G_&WM~C*|8PwGR95++WZJqWt}msc@Kn=bobJ zKJ*>%GFw66DGN{&Gohq3J0e)SlFfP8#tF}>FB1!d5}y{)a+PZIo%-VkFU#|#N%=C7 zytH#(p4`fVbliwO03ODFf)p%d-HyFa?|ER|$SADa0&;1e&Rh_p%i+7oSMXhH@?H21 z_$&1dT;Ja$KZJsyo`%OjDJq<_>mOx51IOzp3_R(4q13BGv^=F6=Z5PsQ7gB9QeB-Q*;C1vK+BS#Hp`6Rv=>UxZ!T{jjOC}Kt`-Eas z>!TPjRO?YWQmPXQb>A4mA{*Fk0K4qMFcWhk1nYSuSq}%$A%3DUD$4*|-rxiBlWILC zJ1&um_=9|jsReNv$mKRs*zk>3DAIkS4-4UK zKhEa=d=oPd+zy}3r=M|{rxN&g`{R#O@0@>^{LlIKn0>=FiEEMPnf927A=LbJ%`9&Y zAGFVOl=AUAeXd{11C$DbH68qnv?GtF{J2+uziCJ_^7!-Av!@V%K8f6xdiDU)U8QVy&DAYkY#Y&W1qd{VX0igyF z0^|b1LZoYyOWnD4slD^i;vt?0=Lk#Y);Pi0_*GXODsp;+MQsm0@=*I>pav>nJYK|> zK*46w$KR5pjQ;vh7NE=nE*l!4k^F{DvOe8$CXF5b9nI}FCDg1 zI;X~oM&ef;Pqy>Gqp%(F@8lQc-{^Mq@Q^tyg1Zb8IRq05B^8zuO4ED;~FJhXOP;`+%g`{o2ZEk zPW%KVpHsw#{6!#(T^5UZd)W??l#3H11i}DXK&8Lq3XGEDzT+~x+-}+t-(i&TaMe-* zN#m*Q$9>p+N;anI8|YIgO^$~jl-tAtMOxqBbbdO*R`w0{%QPkzEVfIu(!N0oF7g_z z7=MTMGfG9$H}jJ^04`P^3FavfDGB7QNgz2bU^xwnPFGl3W>)D+tkr>bOGUgyr+2EjNE%pf zagw`vsDy!5t0}Qs3kdX|xJZ};_i6I$M!5rm$rFljGMb)l0DokjI^>N&3JQ`)q=A=2 zVlgGtDiS;4T5u2C_jM#^Aj(mTcGQ_{-_O3NUEz3~rt#2laDtBn>-sW0_CQUqKj=gh ze3e*g3*>v;g+8UTsHv@~$l2a+cI7O%c6M-jbGfRFN`_|*lt!Do%Vw{bT{gYn?2gPn zGB9*y0C~}wli^dV%G|EpfJdz<0{;>V;TBeD&(!JzZigpa+#2aRYcma zyZfuV-y7~bIzP8&=c6O&QtaJdI`Lb6=|n4|{o5O--?X8MuIDb4hvg>Y%%ptU*-6Xu zFqV5Cp-(#@R`Eo}<2zS(m8^#mJ8&D&!glo&m5Iv!jx+ST9KuQ$CK? zR4j$R=M;eF-StbVB7+_E#_Ylu+zm^rvIaZqkV~sd>Nj)+b!Oez1+4QFx*r^&?ev*k zr}U|t3>>k!_->EYh@p1;M)Ln%;|T;j*8meEN5F58f52}npof+hdO$0^&U+HyV&B3& z36E7t&*~|CFXLP`uHhZy0NSyRa(qf|>yBNstl)q70Z^sMRc ztn9sFb~MznDsD35FS=$%%ceFj*k>?t*(zJm=qbxk+ugur&Jf}%)yL|j9EnC2uWkCZ%Il;|rLG(Idxj4HGQp;XimXQ)wSX~4?UeFpiu*SDq+XxD zxIOH45upsf^dV)M*sk`s6gdi(UN=N(KWcYAwybL1tR|h(Oo%Ya9P&Rm9{c&uf&2x> z9(Z%f>OY<6tz2`%^ulg_(bmdvZKldpG=1&SE_*>%fIuDW!r9y6;arKQBC0BB4NA*b z-!QP?=B2qKen*CN zEU*=KWEN~%J-0Ey=8GvQZf4?pwi~~n<%Rv+&thUxP1fIEx6r!_(-tJuk zbKU{2sW?!0U5GAC2IMUz+-VxK>W{^ey&y>dk0kf zUvT|FV#zcaGmPnE0-U;JL)Q+2$f+S;F$0cRNIvra1Ih^N1X_!C)AqRb)GQx!(=k1% zc-9chRQSU2$j-?8!?~xj4@$wy$cNPjoXRsQhteq=Kpgw3_bR0P7CxIR<{uU*6}X-Z zfHyB4y$M98ldoH?z}rdw5$R47lfPI^60-!bB|K`5*@c$jGx2*_QJUWD-%P+XDcYfZ z3{J-cK*!^4BcXIpjO4gmDG&;b8mU|=x8?YP(~4{YrCwUY6{O43 z9eM>Jky&$sp87nC)sPACj&+f5Tcr}<>mpx7y15ea7l}mz{|_Z)G#db$gh6Wp|+|UbA*-#l@ zPrbIj%wC)Ur+4_YB&gE`OQ<%Nv0lau*h<)DY}^_=)dp}fav{e_FH_N&Gsc7`C1M1J zad{=cUTVuWwn?M5Z1SU?8PTkM&z0+rYV=z5l^c$DhN4*mo@31YG2}W2v%_;FcX}lE zh(@PTA6rko80q&MTYFfegDj68_zbzVZxcDe(B{1 z3y;soPHQX-dBIw=#kTI$GmGLQ)2ns;e5G7&3^kT*dLo2iT+C@ALp&7R%|qP=@+5!H z%1}+rZPJPOB5rT%=X*!)TvdW^6R$wn_%igG_0L^iqYGF0d-!6D+j7fwwF-MqVHIJ& z{cahQCuBIkf8Mg@gDqJ7e)xb8Cyg75i{^BF9aX1_7mVoE&_jiv0-@6+2Li! zBXO}yA+!2(-HQ%6z%@AP)sx3C3<16L<&SCe24nR(UWHsE3Rk?aZs^$DJoZxIOa#Y< zkoO0!T9DfuuSh49YURp>K9xfi*7ynMvh{kKUM8z(>nU1#qJO?7Qw`TRal(krXD_1t z7pYjtN&9qJQtC~?hcX6nOhgmP=_ff*iKJg66A+V{GLfA{-8ov7C)dhew?*wQuz`bO zy*%BK31!^kjk5}?FMWEg5p!!heaoIK>fl>sN`GEsc3;uDf&7Z?kFL~Ek6d&1Wny1& z9I?2=9C4e4qxGU4vn>&qL5OtAWpbUKOLi$jb&Hy3+;v$8_b6e1S3FR)P$V^Zyik&t zWi~8t@3?+bGrmb>e_GO(O^t=&gc7swf43K z@ExC!igfm%c~7i9=9U=*+0O16!&ye$3DIfX-WO>&_@|v_+@i9~V*XLK5_H>l*(T)9pqc7(9MBd8v^s(<~vC;Rb}gyVBjDVCE{F1E zGR_CZGfapjxOGYe(xhNZIdXEwWJ|c;LN`(Ty-m#xdYp|;q+Ni>3@+k)k*uPgZ@x-^ zy7ip~LCd8NEo<96y-+?3w|o+_H^&|6F84uPpFkj3uf}J2d1*sZyIyug+}a9614{dM zeWy3pIOF}mXmcRSrR1sUmf;8h_19IcsqY%s9CMw!`| zi`*&|WXw4F{2#YDDC^{${j`n?O6AylN!wz^=$0~op-pgO<_T#Em^jZL1GSiZj1P*% zpktrtvA?oDcrz)S$WFvI*JvTFOl4)S{-+A**l4VX2gu(iTg z;{`tuHrVbm*lrFskH$C5w9BzFt;WKWQ$wJz;k*7MCjTn{JPG-;`cG=|Co$mh$^WFk zN8aZMa%V{txWJ~nldG{f6*nOEEnS;mdTDdl79{T1kS_%*EY^w)5Eg3XLPl;WN_>m| zj6VYR9$_ezcF?DAbe>_j$AUb}{!QsL8jDU1O2^5XDC=V{i|ocT=az{a>bt>tQCiWA z)0GQr9R>6DwKk5Js@alskxb*VxZ;_5g*~iyWa%X6ONEP$cGj$H@f9vS(p9sv)%QqU zZKy7ytFH~#XX)@w>BKLa#B%g#TH~tBj+Nzo*Df#4_O)?^VyW0xHlx5B52_^^0f}^7 zwH)qK*2KGx!{6>TwbN!e;)D6qX4vC1Al}0)7I!5b*T~AsqoXxUvV}&coLYb|ZEi_z zuxN3Ca=C#WVyC*Q(vjy;=I7e;J<5WWrE{yDvB66kOXtwPqm`eY-Dz-$M_)!Tbn&Nm z@01YIbRH6gcVIuVOg_2?*BGMp!O{lm-?IAAM4)kgLBnOU^8$?v;P0$FWcM#Uay9yz zAy;#LC4M8ylL*fTOhwv#r)fDr1UvBr9j`5imcznK%tA&jXid85TPIj>gp-3knJ$X) z%|-s-n_X`qN)taTJg4iRO(!Bg*tA%p5u=2=ky@ae;jn@#hnE}%R|ak5 zBaHk~oA?2%z}8(njwxqK)I6+W;JUX)`cAGW?LYbENZ<7<%KqgjZt=#J_U1YYo4v7- z>3PWI$A7x5C%*Z?k>mfly(hlq!L_Zc>TKbqcW-Q2S!)X~xr;szU?B&w1u2`kXbett z82}&$cYof)7MwBXO3J|v*n)G1kZ-bLI|)ob2RNyHI~2Ll-Eb{Nz=pq4_h`a`9-!|x zegN+iza&EFRtlhe};a(^TpK)rX%(>CeI}bfIf7-se zc^wCzoImZr-25*!!E()hZf(n7eb36<0lX+!eb1umxpDLPbNhDW zuX~i1J$6HUw?cfxR9qQ22~k#$45`8>x>Yf1Q~*H*n#Q@uRFIwvPCUBu%$YMtSYKq? zuH>kOf$e+=BZGNiJ$FJn1u2UMN=qFBFHx)#t7qE+oImUFLc-WZJSFbOxFln*)Z3lh6kXEd&7& zqIu7pyo{ESvdUHS27~X4Bn(V0*mw6sn2INy{<1mB3DMD&Nxvf+&Y;Zg){ti!NA1qe1mQ4*BJe zus?7*N<3|YYGy_`T%9aTzaY~isE|w6An%A#t9qXMMK_5mU4Vn!@&0TO0Jm!k%%dNy z)#%B4L7hc27p*z}6ip8ujXO*^5p0D-|Z}YvUC@+o0g}(M?ZyQL_*u8PRu`UKxC6aqBa-IDup1q{pI%IuAKgIhdNm0 zwl({US9VA1FMViX@BX3i%vqpOANRjPHr^a+SyVW4X|QQtZm=cag6xz?{hiy|=RLBk zId8$??)9H;05@8kWHMLC^h5{~WAjoGU>R3x5RK8n4l!{$nl2hW$yJ-I;=7O@U*_mb zIy)xC=8X^;#JRtS)G`73V?1a!?_qpszenGIV_O3E$?*#@n=r{y{3e?iSSC6_-$!|i zd>U=bGxoNGS_>>nZ^`Lkb*5Tu$#&(`2V_!v_L9Dis?B%J>DV(AU3Ym^W!dr*y$zds zLJMwiRSxBK^%#nW%Bf`*OS2cX1pI}3M_w? zS;T<_MY#*6g=@CmGpF;i{!D##YlM80D007o+|e`WsUD0?pXIKeN!Ah`g~jfjwxMO# z-Ivs7&%C^~YU{?0Wn?Pu!t}(q*hwhQ611h{l!&XGDN02k#ZHF1*6zK!arzDGsxrG) z?>SCsn5%!Z7q^G1cg)I%^axd5GP?lnIsDU8`};F$k9>Ue@Q+V3SC=e2-0dvCp8WCo zg$LoqNkI7u)<7U0!Ea`KR%x4X$Rzoh{lUAa`(9Yz5A^qko}%c}1L;#q`wqH)eZ63mP7Hx6`>%g*P0!H<`F$tf zUE6bXQNfSKNZjdatSa=YjahL={_@@&bm=GLogXc#I`HQMpMYliV#l049S&ppqHEvW zIlQOcQE?Lx)8pq45T1u1eWVlDk0gcQ3i1#!s#OC1Jd}gKDz)kraN2+Nnd5igeK*=i zgw%J5IP7%ZFj#qx&tmeVV}6KBU~COxq8W_O%9EB5CV0HVg-OrPOGDKf@LbtYsky!0 z8PD+wmD#~{+MylSb+uhKkQM1!Q%+u=Ipq1!XWQGTiYUP&#Y-11Demaj1d8l_Jy$t= z&74TMZ+lbE(Vd%0$y-EJsCrfnq^%pmQ+#p%liyiEoKMs3w_h?nXek{m9G=y_|KXWK z`-Tc7i+mLVp(#)nEa)$_s0!y#Q?#$DVF340fMaqB9LT;EO>4UIWsd!GS3Iz>Bs{pc z$0tcQSt_!vq2@W+&eEXnR$wg~C~WIWqCuT6KpNU0KmF$Vad$rDuV6%h1kn>CzSn%C zZxUuC4f*Wj#fTn!sVy{*UVWKdM_vtP>WMYz;q$9f@td#!5Hcbw$Z>=j>+C9DPD5VR{7Tz`c^Nap`<}yZoE0u6|Cq+jo4u=P z^P9(7wHXEGStgU+6zkhiF>^#J^B`1C!ov{9P03sxoUy>i5LIT<-Xvh__@mnu#o;r^ zcBNN6x?7<~wI@`peL`t)HbJ+vi$s~ z#FQRdoL{)SJKDJG@x{}xn3biEHiXDyvU1N~&}U~X@HfsYm_6caT1@)nPMOgd=-JV+ z;EBDh1q+UJ)$d%trkJ!6ChFWM@$ZBZ$wGK66x@*bG{NNM2_+2RuLuImZcKc_lqKFx z7!WJ{-c70Z5?{h^&2-t#iO-T{Z^8FG2!Lg`jJ@|cd{0N0ogORuWvuMh#NU$bro(S* z=(5|!-usDuk80!gR2!@`_@0d}J2M7zdSU~j09#ln_QY73nNhel2>jydW^>PK#+ewXF=axFrlV#_>#zD1<3 z*#dd50k-rD@@Yz54$D%r9o)TxUqs{#@h&gFQ=pQkW8TF6y7lYVgIS?s9)_i{Yn~iE zM(aF&fWQ|)xP24mxuVoO$DT6HrBl-!_`6n%@kc-7A`;0zbwQiLX0iq(VvDsmJ*QzH z7HN*@4B=AS5q*rfN~fNcEw+nZS7k*aYLm-qQcCdjoYriuK3w4r)Rh&QF6Hv*@r*4ir03N4hO?Sty1cT?P*&@ltY~Y2i{D@faWR3yM1=DT z>qKpFo6QjriOnWNKm!mgww86Pq$OEpLnS6fMqSLr=gawOg|N`?wXOmg5tH4l*QDbt zB=HTTQ3dizavq}=0+gA@C~Zk{9s`|nG>!Xra62E7iHqd><>ZHi3b4WDH^zYTlq%au zemzqlKXpox-Ugm0%W0euh;ufqm(ss*qT>gS6Aup@aNeSotw3k4Tu^NfwXZ0zT4XEW zs`+BI-f4`M4h{@00UNk@D2miB6-cuhgCz@^e7Wulfj}aclojMUjXJQk!kR(zsT#JK z2ip{m*@M$`q`ent?c8L6mr))9t=ean2mINk8LNqGjjqIME{&K2&5KKOx(bXrIgbf5 z4Tsmr%mJM*6pwi#U@zfUOO*_gMhY=vyRP{$ZQe0 z`yo&)(n`obiWEpX^2zei17K8X7Zd3#7{6x;gg*xPgwIkl9vIPa1SUjGbP$szTE|3z zRuYW{92xnpIVu~$w>rWZ_Qt5+*RY^C)>ULFZm9QE&&UooQ0vNo9AQ*6^^Rr|{3Xx+V(V5|$3I*WR#xXci@VhCRvB|*sKsi;isi%sCk z{5OB?3>SqQvHY;YBU9%XEM-|{U;X@|SX-WZsJ{~YG%Y{s$|xeAQ#utwfjSuX zhx)4hrrf5C)@}KJ7O7~ul5jpiK80%$98u13`#(d0a}d2%U*ell>Cxk@PA@&z^(21A z^YAk)E4Txp+<>g$Ce|F}DQdn(eqk|o16}Z)oa8%g$#-Vc@0>>H5GYj48`f#85IaQc zHj-LP%4!{Rl54|HhspIyus!@#7+i`}k~6@Gv*2oSCjH$dNF^pheooo-9Y>cb&+kQk zKFgxxpuB|TV6&M#MI0V*@~D9P1o9&A?IGVLH!cEO$&dB`Gg!PBIZ58S0kn~)H-Ju1 zy@7lHRBoX8q>FV6mX95USG2TFwE?D_R!z0s#>6WnIW_iGfkpw61-Rm-ix(bg#ikQWw%D={m2OVW-KLO}gpf{rN9?nn$+{hV9otFglL!MVYQJst>f5lL=k2hbgJ3o~ihjh>(&t~4N}8D9OOi}U zC;63fG-k{TJ9ufnO(l_8gS}o;Vc5Zy1-4aY!8>CiMZWcVumvThPNB9=`UEoA5 z750L43f6ZH*2mb;Qgf~yj$)^sGNwh(3C`b3AcO{N3FT#b$=j9bhyr$yvsjs-;uHQ>ZexSLH^^}d6~W2Z+L3qs^_m=-Qq*f-HsmU+&`R?H}6oV zfqbLm_=@s{Yx^sg)Vmiw4MZpBJaOaB!L00|%WrsakfF6J@jcu}J_zB-W%T15S{@mT z14fL+oTivOR)~*BP*rEm@2`~&o?2d#Ne)ZQL8GN4FH`!mu7CZ}X%!d*>u~BFMU4EU+4O$YmXN`L%5Ot?Tt;_`y={L ziQQfj(!=|vMtBbwG`qbtq@(&nllTrocP~rA#TR+>^c3F>0AR0RK@a)c&Rs=(oeSPMl zY=62)%|GkyKf1tK88t`xw>FHd$1b6AYt`+0W$SC??cZKK~=dMsxv6Xgla6qXNP+GKCBi4d;Tpw4Z~(y=!SiBNqksW-rT*|$+Xx;!S;bP+H!Cuy8i z@VDMk?hDs$wuRU{(62FLaV`g>sYHm8=Tx(A`)?bv!yBp7O36putzJvH4f`OOE1k8P zyc0j3j1Oi_I^RPH6yJW^Q$IdQ);;y(Q@5(HAF#jv_f2+y`g;M=;Z^c1jwbW>na5L< zC-d82Uyka)Cf?}B$fuffH}Mf^Iet$(PBHQk@{YtMZBN>O zByPm)_&GSE()o0gQRtIrg%E2Vl!yDj%&Cp{%UOJxivLcl&T{7H`F{$JF*k0?$ktxxAcA)m;cu^o-Ckyn}}+tgGSauRsm-T z_68MS2?`eu#_5pKAw;O2qH_}#0nU=q`;+ynN)J?@TZ8SaIZztRVXEIT`e279qI#36 zKJBl3t|Rs~5z%xq@SjQ;@NBl3j>$)#UqA{$aa3ZJKuMHIo(T60cy^~Is(MWyfB^nK zK3C?~zX1X4Lh8_W+cbRQEnS!>*TIkvlcf2k_0e_NHNX+vtM`pFycY}ls|emfM6 zqI4R>0EkG!5-RWtoyw5Fvq$e8eV_{h`Ff6>%l|0ZLQM1Z=>14_8^r9bSg>?oHMaZQ z@?--LGa7z-;s<;l9;M-zIH`(hxH-U?A{5&ZapLpV+l?sZ?#nv=$_X?aSrjo;xXJe{ zJ_L`Pe-;3r8F*afhO7nQ^DkbF#grGZP+;}0#OpN#LkhkolHj) z_yZ@-ze0V98tv=RBE)AQ-*ZZ`GB-tFA50MzF5{+GR{spEz;DPNWaY#TM z%BX$_ONdORf+2qlP!<`SXbiTfAVwgSFx1tbg@z$6u#v(>;DSU#^AW$9e21nGtp4ir zFTjSmNdhrrfZ|d2R31&SKaUw1Y|gLq?D>!7E+x&cqxU5Ti`S0oevOUAb_G2|klN(f z@fs&GHp6#0kgvTIOf=g;N>1cy-XwNs7|{rjenfip%E;_{>~- zKeit`%r0axR^k&9@iH-y?KDB@5LBUK8tF79)9PZbn##0_5TvJ^(9V+C?bv?lVkYP6 zVh$fDkA3Lj+1wk{I=YR&vW3`VoYSxkJ?kRbS5s}E7t6znC`nJ8(9BGeDzwrmNm(yr zS`o@b9IBnfJyfn(hzp-?hhhjyHZTJG0<-{btT4a)7pYn*;#4BM3oyfnY&_40P*N6b zI6nz7x}Cq!xnysJ`&{i7f%#7<- z%S}olvJ1CS_oZ~ETta}9UqD1|PiF6=Y`H0z?w-t22YVu-Nre|3AAqod1OLn)m(b5#A#&z)7{VI^_sVc&aE9MJIu*B9cj$8M%lUK>QuPr<;ON`OuC(sOJa-H^gz zJPS5&N>kuIIw|&{wHmXC{2X*%1Pg>G7LwocMZh=}i!nSn7@X4s^sGKUP%^;8F_g+2 zkZc-!5watQ(jd{pc|DDfTi}8cEb~Y(oLW-Ab_&y;iMX>39GgTl~G~OG(;PT zb~?3iiVVrVgLs$yDm=+GX9_q7KLnQmg<7YDQWxtYK8ut2Xi21dgiXMphwVXiP z)<$|DU;e8DeKIeAU#Nj|;Sf*KhZ@iS7kCiE1#Hnw58}&zb&#|1iL3&Crs26@ctbhp z267d6EOCs|bzPA8`Z1L|ORLRv5QHvj@hy8lI|jcm zx=4&&MsZD>22C(9P$vENB3aQe@+6g`bwbWo%!~kA&7zvJso7nR{G&dW%i(d#Yo6~s z`N{5y>09w7d^^8t)9hN=-aDrTK3_IdSmYL|R9b0%KE!u9g!gR-FBQEd2^~6?i3d$3 z)|Qz$jFlAyBKr-1L>Jz;s7yTP)caeuJiR_sJO^O&(uk7b%8C`8Icf6%ruLNh2`&X3 zI|gCtII_4HjDEcN&nLRNPW*W@I_vz^t(Of(B7>K^OvNwe@vR}I9)mTJ$$&~Ck*>4jFIg3wCCF=mfL#nq~YFixb~uS6o7 zKsvkGBsPV-&Aq&B7kX&irqFCac;Hzp!-a3y0fNzaM0E ztuBwR?#{~UUL7xA-Iax0Ht{j_8(%{`T@#P5?T%#itfjJUtzZpe&tiAN^@m_tSsAQ6 zRwb*I)z6v_q1ndT$2!isnRO5AaY{!@<*-)Bsi-H!|M7a_x19gs8lP}&|Noar~KUM9+sfXA+y~{;ibD0P3>g4aH>aS|by)gMpkJ~yp zZsqvBbS|`{elzK6%N)%n-ATi;l(Lr!RS8#V@M^}$rpqb^FKgBc{3_j#e+l+E3AR-t z@_9q`IX12l_}DyWO@8s#rJc%Ql0194(+9Af@x=|^+Rdl?$dk`}_>DxmUN07EbElX5 z7gU7%tNroihnvpdi{Iq%FtCxwXxKu(4cl*l)~eI~^g(F4lfbRgG0@t73$oF{4<|u} zTss9az;YzM$NmlBicQdgGi|3&fD@gPx~2%ApVJK&Z5`=U+R4!+RKxsnSe-J-@C_gA zXgzkx5^tSE#g{sQ1ugU9$8VP@(T`~$mK|;+UqN>{J+F?@@%1ZrzPhW@l-&?mp%JKT zUYqL1tL~%XyCnXNK7&aa+A+B@kO?4J=+llOWITH+HDJKnx_hP<_U9=D1dku?zNAm> zv{)4~Tw%o06naT%B|l9o^yOF^YfBV4e_y-E=|h7fOQgG-){jxD8z;fSNu_v2*G~pTWYCvZ@p&-@kWxi9 z4G6pL?mimw@ZOFC!#N1fWe@8KPTOE3cpn1Nv8I+pC_uI`@RD^99!=sW^tP!q0+W3j zA%i7}Ln?GZvnqh_t5WGGsSHqr~6Ho54dELhTC7w8zs}eqcc7 zij2mnxOG6Ra2aJxp@oyR4hY^ z{_D`a$Y<=Ww8i58;&*~f`=7i?u)g1R6JhlE=n>=qdo6Wd4>(~CtaQ}Ss)6><%Gg6~Rv;r+QUNvUw7tQJV8^|0+2Yf{eU-*tIK;%PFGK&7{- zye?;MJlE;0o?BunDa?`>rSD@@1SzEj?b~7mlvXpE z2at@L?~}^#=?I4GVyncb0sDsgCFyuS&c)Y>RCnN7a-Ed_J;p&lC-$XN}dbFAs;;s>l4v^!<_NJ?W#FuMjk)}Jn|R_OGp37LuFtt`H>U>?5Id5ARYUw zG)nNn0mgP@E}lUC!M=;OKY-tpo3MGxb4S>Bon--V3Ok0ZX16i638)pkbA9G1b{km+ zc@h}lGm?JBNj|0inofnU2LNW5O>Q%_Uz1Uvl&-ne2-zh7BF@=G3>=^Z%ju~tt(Tj4Vc7J zcD1MVSx%+WnWfh=+raVtei%Y-AJb1I8=0c7LEb}kF1VkBEnujIY9Ygv{)Y>8wwzP? zFx5&}pWJMc<&(7@fb|h}43*&b(IVf|_rlY`knM_;3YXEAP~ zO5{>n!@*5+32+VoB3n&44PmWytjZQ-rfAHWaTDiEdOiJ4)2a#$ZVN@!cnFp9`!q)B$% zaoRy1J$4M_kk7;S8k2Cs_i!eKv+SxBQ7Juq}u!1h$m zEVdO#T!PgCG0x`;;M^Zz%ZD@js(n&dafS~EQl&IZi4Ck3u)f-4ee9{ZJ|HE54>ud+ zYN?oyrSlgO*+u2H;;t+iTX=R|C=6=>xG$sFCG}PJWe(Hx2B}Ao#9eT_7%#RLRE`og56J70D-w@VzIXuk1;q(wWbt)U@=odXQVDX1y#9(S zuDF!(AO1J_68)}$;xP(aCp(EThaJnLf5OTlfLwuc9NE?G9&diPyVNV?pr=uu%g#kl zBRso{iMTB4f#d`+|^N2#np%9YA;q=K=XOuSDXqTArneFX(ew`dN z%dh|RQs6pylA;^MbGbAx@oBCrqA);XRt_SQk|wDV$iPQWDsESh`wtvAyN`V0>{+Ib ze~~XBYZ4FB{YQyGQ7e_#Jr;>YofgKdjEI6iRd%Ddu^klHC_v4&w3Dhum0kYaipFW) z7*a|QY%B-Fywe&feGLF=Yy|laTqh_<2o4pk!5JfB1TwUIc-f(*L-fD+%zZ<9_YUo) z|ApUd$2KFkvq$ND&i3we#3`D=A&Mv*i`rjk%~!`hryI9drQhP&uH6Z=6q zWGtJnGORlS2)*3q4%_^dVeMfR#ZPB34_s5Uv_CgvYy#1R{K@DhlYuFyfra*PoH^BQ zeXe%)P`^%+&ELUxrA;O}Ua%j<+>EV6 z;s;WQev`P4)%PGb~;)oWfP9RAr_%>DfzCDTq7X=n=ZoOt{_fo%UPYbf+R`e`z|pY8apO{m?$xi_|-duq%)S>^eH0R&veYSlApmH6VGJjS+&) z_LQ_`3e6!l?lfUn7;{^~;pQCUhKx`sK=JXNSS8xR&PdwUPhKy_*D^M}l&yoyWJs&= z8sL(wafUQ-aTfLVtc@$VSFnYy^3c$5+5v86*LLi6U8Y^Bv}fvcVTV%b2!pav=bFku zT~xnhdgYqV5bVcIqkji)CZ3~lgFG7}K-RkX&nBjk@9rP?_M3is?mRI1Irud3>^T1L zZrX{p^T~I<9oWCWpFXcVGx|Alf8rVV4u9+|CtV*aG3}al3lY)ME7}szl7ISUVBh|J za?akp{oi~8>2?M?jNHa_X%b~NW)W=MQ_`M^%QAwYjE%qRgs{N;h?tE^oRto)n6Ea}*XcEBVy?5w$xTBr zse>-o7#ixuIw4=obyYID$aZoEa#P|xTHi)nwvO9!TPIxGFBXd{sm}%f)an!pomTND ztyUq|YZSm`joM|}P~79olMwNMHRh0MGb=p4Trp8e{$$fB)D!sHCx?CO7>iy*(f?DG%aT<(045EJi%KkkPbhoAlZKZ!reTm|-PTgS#)ueBGrWYg1W zzeIO2im(sT5ZIjd5Uq`>$Nmla8Y2VS4t{2f|BS?&AvVxAP1}>_x`o~%{r1kc?xp_i zb#x=62Kz3NB`5KnW+%>*(U%CLM*8(X2W~%c@QTwNdv|f3l72;gcj$^!9ea1Pv3Ku$ zDBT@)r#CISZ! zc&Gua?-Q(C<}9$EZW|kGJ8ds;%D^*52reTB*ey0?x5xo-A>cHH7&4I<98Rx&x1F{< zX`vok32eY`(GGYOtqlDCU|ItAgtDN?nWsqNu0{m}0MA3l)cTB9O)w z9C>yD1{+Ex5{zcfbL1Av^OiJ0FeX>vYPnp<7h{+jW(lNRA-J_ea*IVBD6?~kk2oS+ zo1PO^M>F&=!n5dE92TDqXnP&dwu4pzd<17Q`UURav*XsOxGM=Umc+}!Ap%CYa!IQ40M(`$9L#*o%8W|0_{Pc`#6T8&X1sBjld)VaihPr!O#M*HC_!Fwe$ zaXK#xWQ;Y)_jbnkl?C}Vk_}G$enJ`5I=|SPK!Sa*$;SU zO4c~V0ko(GCPpEIlQR)07|{KA$msB~HOA?#a|L$F$ms^!F=p+5>K{C9HyrL?E1x!|M>&45yoRvY|qE0x@9Y?>>a~P~@30_6REZ|_77!%9nO7~%lCi(1rT;2qm|MkZV z_HKrV*&_p*zZ3Zq*$sTGM869Z0f+tE@WtHk>^q>M9Ur5>MN%m!XGvxCD#%C%bOBLV zDG!Q=fUkT?l}pRRZr)6++B`@C|3WNZjJG_Ff@+GOlm6bCsSfc80L7~G7(d?dXR_HogO|{B2@_0R$On> z;~JC3;6-NDwz)FvFRwr;H#B- zy_nAzGEtO4(<_u30RuxZI!mY!=`A>qfzdG<3PF4c4&>wubUot6o~866nO#qmI7Fap zP&TgRr)Rs}+o`k3=rU)%tz><7NS!xa3H+B{;G5r(@Xaaz6&9@@ zd*(ttHhg&S%P$6JeADNXzG*t;oMPmEjpY8C^iAOl)6XtlaWwaH(lyOHcdqZyp|nJQ zRT}mTg+nV&b_Gx<)`)nfM>E-!Axq4ZO@hW!Q0Q@l3FJ`OP+|Jes(**J1)tb=WNbpQ z{_cr@zISa*|e*>;dyWC z#;Uv(eN~F+J41JEDM$aQ30ArJI)>cE)Eg`G>`fQ@=QQQdtujiPI(->i%20(1Yy91}@2K{*Z?35w zukcHyQhKcY{FQs&JYK)_8RGMsZ~b%e8ZlJIW@w!%PUGpnUO9N}M2^X660tWlkIoF6 zUbAFH91nr4GwGpyO5uOZg4jk#`o1?{SPA55j+7|7v8@qpZRiJBgMYOZTYf|&L0_@eL zt9x(%Xy2AUJ$8I?CZtl9?i|U(SbXMQk%R%kto}tSmvYEy)GcTJw14>em%?B;WrL! zmiilV;EDSP=aQROWJhW}NQ)?72Ko9TSW-0co(f2NNWsV$a@4aW2<8F0VP}(BqDO?`M}g8N~G#l=$7Z8ljL0G!s+vv7JC%X6il%e zvpw50W5@#faBybKj1|gbt7EHc8!ua2DVe;v@W@ri$~OP*nl@k8&YPZ|So7H47*A!E zBa5L&?yFhfTbXVX!WAutMzX>~hdba)i#o&d)?2+r#irpVL%Gz*lQ@fpYKnSt)hj37$Nyciq}-66-;*EhEcQ#;I9tYfyQn=Z z^ABFpSH5+uUL}qcRalx&t}DkKx#nRF57=^3Zk@BC^$}0yB9FU1*PyaE`3&;3hNdCn z1X_{6{Yy#6av>%=yYJEtQ&xr(575O@Ih$h?MT^+j z?MRgp{R2_;Dxs`wy<$8EWAmANC;&-7w!i7eu)akOtmD;$t{wxrTAW687tUa8$0M+b znF+`YqDt5lSU`>GSXPHLTcgP?ZO>l%;Lcd6Z(mdW<}AYs1tNle6yv71*#b!y<%NRLiET3_9F z*Qfi>LjDgnEAWyX!_hfvVDk!T1uB4<3Opic%CgoZ(<0-D^=t34W zBIa!8XvOEDj_>zC-w-vEN}LUaq5FAi;dk#dI5eL0bGb+I$d1`2EP5D8;faRC71`CH;~6E-hqYHNP6q z>yKsdtb@xg$ys@-Qz=*ip-b4pjJiN%s4mPNhOl84YKrAJTN^6U$FN&2^hO^)yv%I$%*F*31Tfa4(RhH?r(8; z!i5!N2C`6$jo-IdYmFlkjzBC{uzg1x5I(0YE__@AsVvMp5=ey+2t_9VaWfc%PsAwQ zVa@0c+P5f%EuwG<-MV}=vNJ7?dvzZB8L&I-G#OP*o3tl-bE0PvnrjzPsLR*Ar={!U z`bP2Ob4UyhEZW`Jer#Q{6#De?Kb~xyS5XOHLe@@3SKT=BRPV`UIoV53^~382?*7+h z^Ghhn^P-8kjUJ@%kfICJc_!inaffuSS|{#vdieOzO>6QTb!)4JZd#oWJ|pj-45eG= zYO$Nm-p(C2J+o}jD+emZe+BVx+4QTj%G*a8*2R?Udx#6a?YQ~lLw%=~=XT!m(ZRmc z%W{zkbG}z)GgjQ)zu}LMU%fON9LkqI2!;Q)qoJa#DLizj{le!1~d?25gy!gn4U-C4rE*V@mbsl~vXZ(uR zwa*@|pPK#wrwvZ4p7x@xfQKyVem(1D&H^Bj3K|DDC-svKTWeQUn$~T&I``8p_pb_j z+qXC179IqDQiT7WV>A!Dh^hM_L^arJk zIDtL*A!#S{)8~=*!TY1BGbI-uVNXkO@vM*5|9)Nn(LsOiz}B5x2XcFwibrd6YCWFJ%9N0csTJ-5__H_v$Z%N7R#BKHddEAw5x2z@!@>0Gul<&(B#N)hV4!LySN zLb4M=PdC!z7|u!O*(%mk*rH@-APM4(!gp+c^JGiu##{R{2E8u|(U2ATL;~^4c8^5E zJ=-cfZ{1dHD(noIp?}&OsPM&%5npU=lPf%U*)5L=+OK_k+lII9-C?9NcbPo5ZsQGJ z{mewq!Cqg%j%Rl_99dPxhRhz*E*3*GvhU`urBC0or^g@X2cWqa*cV^g?A%CrzF|g_ z6W~cW9xGDr?}*f`tF@MIx%1g~CR#7=G6^n$(Dh8NC2Gytv2|5zfF-l2`34?GF6P15 zA+ak}W1K4Pp6wQ#Vb$2#1grIwc{t$Bd?!4fseO0Dt&uuz#}Ix|5XJ6Y>K+0E>CV zLl9F=Y$EQ3A5=~z@{aea*y>hT}V981W%9IH7Dq)~?MbudtNnb9p zOQ5P(6Mk)f;%wGajhJ)YRwOWYx<(|?Xk9+_G9(nSVcsKc>ne4c?9RMkbD>Yj74bN9 zhK$`dHo2?!?p?K^RlnFmyo1wV4ssdr86O1iU2cmFWM^~~+Y~0dfW@Z4s9@#l)p=`f zTiku)<{AbxB=^avT+}o%{RNs8*C%K$BpRAhSUBfCO2VSi42j`Wdelv;s3IQOq6sQi z+`J^{Yh1QvcYgh@i4OBHU&iD}m{MPEO|WTArQVp=7R*}XKm0aN$#beq5(dmi)?)>M z0^;{5nlpa5spFb0eT4>1c3ajckHuz4oF;i@=c?>LO;AZfr(rM;S8)@)z>Pqsx`6y< zQnd{8eB6ti;dnd`3PchFX4n9Fo8@53; zze@3F$C@wpdz)0!9sMfVF5+Lwx?uY5gx@olwfU6YjepQ)>+)#eWWwHZboyew*>Ydg ziX8__8}|1(_=>4BwZ!Co5LN>ZR72QSL3UZ;ibk(3z?E{W5b`aL?Q0l|Y<}aeo$YS# z_+6V`o&v9(Is&hlWbN8qbMX1ixkYq$Jf>kJ?!%1O18IEnd^Cqm@fL@~MA>+xO#-K( zGj+gYH$rLm^~ik{{=(gB+9Vq9s%`tq+xK?5p(}~+iL2kV5mWDyHMqa8xb2w_cZJ#u zjIs468=#Jo<+aYjRc99cf_Rabe7%Nvfc7<2_ghWeL)9Z|(`M_D_5ZE<_*UZkJN{d( z@r9SL;6-)Ma9Y;%d6dLH5T`ZG`cl^T36U@i^rU^5bJvVdiG`?X02GXf)e;WCuKZh?}K--$aKv$`)?)cmLR^PimFL!u%%-5W6X3O-l$21~=L}`jP zdc(b?HU^EUasN_Rx}+-5P#95a3K~X>vl>GR^b?`YVH36N9In-A%e&WAEq`c7S!DP? z%jk)fje2!)(`cciI47cUYK(PmZ)I*kuFS3J&&T~jEj5>M`U7z9yaue(lC-Ju66Lwo z-TE10cMuWrCf|Tx6GAjrWYOMsUz5|y*70~|r9Nnup~&QGTv)_Kd{d)IOZ)x1`{7{y zWkcB#$*4xiQMz*UvJr_J_E5W!u z?{65pYeVsx-$L}GeW!~!m{s}s9rPLh1&vyAY|@q+KfAi`s^Op_*qAjXi90T)rCohZ z*Sve_Yf!~s*Ozuy>x>u96tt3_4aqkNI14vWezWbT_^Bih;p&=|m8P}8Q~hkqFII)T z?c3s>>OYI+zvGxp!)3%&**<(<3;fkwSG9?9Rc-32zXhQ;mH5zz8-||+zArNvpNbQ)fV$h!fa$b-^4$frn|P3X(~L?}e$;vN z2B25YL_8Y$@p$w>j+EivIoN&swrWq?rkbk7)j^pg9*y4p=JAFlPZM9UJ{*Li!6^tau9d~0_wKWs4S(Fv-T?J6p63~2ig_A7!j`&X zxr1cOIABXr*NR!TtbY>9dSHefnFD)jpr(u1fxL4iGysv)f1tBxTyr z#W{)OeH%ye1B?0==XV?&2s9k})kw0Q!E_;=U`RY?|PVgsa%@3>iYhb zoAg#amqqf;4(QFG_~x6N-zSfxM5APK8C1%I6zmZEj|At+6U~uh5AX8ondav1!5}4A z6bDOJI6PDDNMS3uji*Qxa{mRt*LXP6k!K)VBin8xx#)L6EAD{eK3^U=mjU}Z@P$e! zuWL?NDYXlOHro)A>K$33PcwRAE~&fJ7XiME)?Y-NVrVsjg4z~yUeHn6-rZj6sMzF<}X{7>*z^hmL16idl zOLjM{{mm5(`OB_u|0VHVOzzJqbLNfLIB9G?Gk&k*5o_UpVNaw55?HS@*j#*w?1G`s zb$G}qA~i!h@F!OB`2Hq+wnl>RWh$PnFhfUYo|pWykHO9!IMD5{0ltq$$kS>{YB}7V z8f7}l*^idC?;i-Vn3wQ`OjzQp&5qqM`Jb}ZBV*ZO%Kz!^UkVdEOs(pR+Z@~Uc^Vz; zH(4}4)8rgTX~RO2(Ybh$zL-X@XGa&G92q*$tYsS^t|`ybSY3n{e)GULHB~?FDjdwm zIR;*Cad{)R0fna4v>qPK${IP`2FZuoopmcpr#`}7ncCaeLv>*NW9jJVQgSZA^fYlF z@+m4x<5H*5ES7hiVWg_gG^jZSZ`)8BAyu?Qt}wSQ8VYVdoIi2o#=GiG=WpF&bsloB zxb(X2s`gCMQe{Ru3k-MNF!-~hTZS97#GkN63)LS0PHvO|&InS<=bv-p#1K>pxO={u z(xD@62d)-EbfI1I4)LJTEmE<+{)5WGeu$-12eLokG_yMvwpPeXSA*R_J|?cpV<4;A zi(}`QC2Mb9JaTF*)O5vf*K{4r&fDKoJsuUZH=NsuimXOmo(BHb6)s+LZRe)TJY~%m zsQUQ&%KSCAj&6Sc*8ZZL+`{nC!S+cl@)v7aNT-rPRDOn(tFOR53rK9m|9%cEu-SYF z3LDyzmaPd`He2i$gQ*tH9yos^gOk;_uhY@%wvroe(v*~Q*`J$|7Orns6;w04cJ_eC za1n!8xOCB#!y%DmTqOp(-cRWwd-^;Ap>fo~)F|tGw2pX0HhxbaCqh4!Uf;Vovvy;n z(^J_u*jMQ(%Ci>)9Ach?;mG~@vg)<9HcwUGa9@>&ZwOj^B|!&n5iC=A3}S29Ku!hl zb?ioa*y_rZC?p&~OIE3+q$jI#yfR=lIe}mev*5JSM2*oFcZIICZXBb-xBG_`b(?HkE=5sZdFW`k5M z6)*sMXLdMggHzfplXX-n3qv43o>|r!pWpWt3zyM3UbvZS&6tg*OHhaC> zle#PcEiKW*axZ!i$b%_0&Y84Al+%(L>4cvag{%5rC~e3Q2$|isRixNH-Uj^X|S%LJ)62&)`!sE+iBF?oKI$-%FI^C_JLf5WamA@!b=n zLZ1X;-t_+C;JM!rCy`DRB0WP2Ay~$T<~TfaVu`@$MNYv_;>4m4H8kekWdnKYB|{md z0f)@acjeu=Zt->Fp^TxEWA6*4C<>h=_9-ouuIk0n@pZTwH*|($1rt{`b{t<-$$?rW ze)5ty{St9Cf`j){RkdJQ@rjwq`r0|c%y4|91hBGUG6bPV*r;0b>FzBr{4P|WXZd|b z8+i*8_?p8-V=?QUw?&(RcumFiOw>3@G|S*8ku&KY#mmyYeYZcQrimJnG&-TKYsxY8Ewr zX8Wk}S<19Rm-t&t1N_Y=np9ksllXgRWbwMP&MU{VY7alZxqd@~J#z4?$6j_92kb_J zgo88B*egc!gm!N@ov%|0;9EnretC5Hnf{G`xp&-C(djB#-B~E&eJNCE6hhK(MW;^? z*PuG!KVZPp>&U6kc-)l=QxPx&dA*zqnnL#2%@)Vuzz8HxT5_Z(D#ISD24B zuU82X1Rl9&aUKW4-6dXmS+TpsgO|dWu<4F*43lUK8j0R!fO^C$l`U(oXl*+*Ucjsq zx8n6ftJkgeGj*2!lI-z%Z|1Tamt>7P>nCzEGPpdRiX)V})o_}lq{UTLZ!K(g*EB8G=|ogTcXfdYS-3Q9bQ?YQ~^0! zOB_cSD3m}0yC{z^n_{9IhsUqAV6yX}&)vz|^st9QV0x|HD zq4j6ekTg4S5`7fh3E64tw0g47D$(x%{4Hdz=Ro4}hv&{Cr^YgnW16g?)Zyg7^aYUD zO)j-g8CEkKPa8UtCv^+By*&gYa7~G$$c3lpEy|B}={Yhs?vaGDi#S58;=z$Q_mZM> zZ+Hw!gGS-8A%CB_+YRomA)-Pp&!Y~MI^6AL&VWy#6KZIZtoAC$qR`>R8&fYVu!8JC z184a8|9#vx5)P7aTj&{QbCI2#%Im4mHK=|0a1^6su)leEuDhwgQoj4q)xAfDLy_+F z1@_7;Jxih#-lGz5_+q6e&uA+Tn=lwbmCjrArHd;wJ7Q5)daP?zMW{9)$I^Iai<#fC zXSl|oE$duewfdL4W8r~)jf+pNY&2+!8%K*ArMVG}Lu+X?`Kt4Saz$=Mca|y_*OC77 z^vA>rV8>x@kq-d){3CT;4kGYNMC9S##{mv)#vpTTv9{l(j`_+u`;LvXZS7W{@^yq&A24!hP*sEM<_Pu)>y6e z1-2@dl&xe+Gb}NE_K|k1ki0Jw$Iusm-C>b;(^-0C2yedio=eaV0A2jq|lr(xLXp&{Ytrzm&Nr&?XC62(yVVbfh!NK_K9H%I0;a$G{_~r z&^4Y$lN8qm%dDi_+FTq37sze4u{gcx?&Z*Psc;y3R<9&4WAVFoI&l^JA{GVw1^zOY zWG>jv|IXjI`xlOTe{hl;g@p*XC9*_{$03ddlh89C~gFY4kJTrX03|P3FB0qkCC{K765WauCexixW>e- ze(oBPHM1*hsx6T}0~p?PXf&rJ$6i~ODAI}D`<`pIcLyl2Z)o}) zxTlH1`Wn;H<{nbCi_l4CU^wX7_{hXmx6SIotPW1POlENB2kiMSnIS7yRi0%C4jt_s zxH^!}mI#Cu8pJQ&J#DJ(pm1|!~OvM(38Q zrlae-RDXxMIR5&HvW5}0K`o{7vd7VMDi)A=aolizDk~v@vq>!Yb)GUIeUADVkiJ#E z)^N>uRKnm0if-wjBX6s?43kq~CwB|!OG;bL$mR8u`=sJf=Z2EL9sMg)(3e{!j}msCMSb>f z$6u5jEPhp`!n}~9mt~Rs26`$GPzIDw9y~R<3S6hoz{XQwtHi&3PNJY<5N{F3;b&<~ zu=jzPZY>f{YYv7DJ%t^qouTlv84dpKtudUUrij%NbV9vHsTC;OANF<;lC|MmnD)@^m(+BN^|+UQUbqkGE0&qh!W^ zoSXZbaT))yieb}SH8Az!MNT4-K|XiZHzZ>UC=(T@anf?Aij^51!bzAU3bKW&v`?wZ zr;ZVP7CZ?m2!xdii-XC8UnjV4A614`5(Hx75(bw}V>2+|NXN1pLkdG~bHKqBF$5OH zf0!0Id`wsGQyDYexI+syem@O8#^7RgToo=vVHlSAGu$F?f307aRqOG0)D)=>*jqip zu`uih7J{lPgP#Ov!<<|p{N%Q&Gcst4j(7%#q8TXk{q$J~c?3EXj}3uy1bzwpPCQpg zN`@YOh&UMjXzNFQXf^Z*QI0~ySlp*`Pk(_80NczZb`;_jHL$~by{Ck=PPA>$jaC-;Ko(bC_2ZV@1-y3LYudk{YCGHsT2(rV2 zd#cEs$mKj%sA*-X!Xp;II%zP>=EJp{cpm*7z$`MP?nQY`yZy2E>1#T#R0Dn zBlH}g;qxCO^bfc2RA?5=#1xG*jo{1&A0ppP(tnspD2K@$q6yiCAqI;o;R1A4Of%6F zfKCS$@zT=+3sXww5U2>Vg(?}J!M1(@$kKaT&W#dx4tV*1(A`z4bd-I7$I0#4RAtY! zD%pEiDs}woK%qrUgJl*It7SlG|ir|}a;>PEAK^jlF3cNh#_tq{G9?xLyb)^-MopwJ?Gd)@Bi_8O2z6ezLC9s$;M~S-= zi>W1fet7<3kfBe+X4RqHLc8@TiQXlbJN06*-YJ*6^b)8*tamBoPMuh+bIKJiy_j0# z-2F&h<6FO%@PDmP5}OrHok*l}D!@~~(_Hd--&3}yg1C*g0_;^=eAPb$QJ7@L0!)eX zg!Do6bD4x1;My%Ix`~Mpxvq~=>)0r9d%stZ1sFn{><@r1hW6Hy+kAk|E?vC8p)ibN zZjH6Tr=v5W6@XjKD@)}bF&}U%6lRg@pVi=5jjx$}pJYi%{8KTx`-9o-2L^)T?Knf| zs>~`%<xlCF~vT3$W(W_?j;=8vJ>-<-af@)xNwAO^~)^ zbJCWm(goFl0$@vca5V&N2E4d~+Vi13#OZ!Nr47wWEy6iE%L|X1;sv@K7@y{Tm4P%q z7u%YZq&=F;gd+Y$On^2fEmCryEz~|Y|8MsBB4hRcVxOV^)QtgCcH68eyOnMyP1*l^ zvllRMlzpQg1@fsvc=$B)}U9*Z#ZTdxwNo;zYF>@7t z@ShU1^3X1!!?Jz85hQ*k(YxizpUB;M$^R97^PZ>Jc?S)ZqBjA+ipXb6>u6f)RcEEL&WGO-OI^N`&VaLKu*iKdb6w!zm( zpwR^lArbw7l;msFl}8CY`bY1Wyg$As+AqPHmM`G1{g;*etWD(4!C>?uvGl{oa1*Z^&Aj6mF2NB5UAc)9j?SeR;z%tEr%CVoPzwYKKtlL1c5Ho1cF_?b^oW4z8RHXXXY2uCy6G zyq~1yN9yxvI#8(vy+Y+GMQQF(-0bx6#2Q z%LX?wI9a{>Ivss3sw~K?DUNa2v%%rMUDZ%M75SZ0M)>hXWg_6dcplJP2xQ1MFIJj} zF{u4lWXE@pD62K?VbO6}`-pNiYoSi~Vp5=3j7V*?9u*FK7N!%ra zxX`EVbuzgiU2hOWO&pn6q_gL^ix*c|m2yK_MXf!fI;8S+UfRJ^a79vv-O{O1kFG7> z_w3g3t8=d_4k=9{M_CZQf+xV$c){A628w&qYsU*!x=59yXjQWhf(q+2VvM(OQN}X| zxBczzp;$4MqdAUdW3QyysrjnO_*-b6u!Ac!ot6y1%~cLG+t(B+ABxK8Y<}#4l)!)4 z3P;hG57R^~WJR_XCe9ix4kklxs zSXOb_D%g-!2cV^rAsO-K&Yp_#rbljoUe^`=gXoEL(%Ld^}eF@w+|2BzGtXV-`+>+xDL>EHIQ8f z+2bpwB|u*1&wif|8SyoZXDiJZ*`}O&zWvRKjuR7kRhK=rw(-*b5KF8U!bQ;P;c#O? zhD^hT4*1&&EjyM&e{HFWuDg5r)_1P&3JqV`9WFGo7(&LO1EfMxv*^FT?0^ndT1Ao$ zz!oeikn}lOVRL-%XVn>x;4(fm(=~vfNBFj4UqOF~1%r308^hVvE*=Vns{xVy2Ra=L zfm{fei-Wlnfk&8z}&5%1@h%lMYh=7Yiej zrJ`cM(*lKnZ}t~DTN`dm5BB9j6;nWB-SqK!EF?@5%@#qoc=S+l-Abd5hRIzw!jHhZ2=hxU+ z=u752x1x5-sTyl%XS2Rupp_Zj1p#-NPtnl1M6zVja7D~l8ZhyNQnn*{$C{QMZ7$>( z!c}Us<&JbQN1!PuH>FaGR`MK?GJE~jHn+f%?`@ZAOd6#p&lD~=U0dLZ$`mrLq&re> zF9S!uASZstdVt*j3+#=Wim6Z)(y53yi8W#K=LW@<0v>BCXJ2GKD_DE$$d31KUgRwA&d`?^MJW2{#7XoU%GTBY6k9hRsF~~xn`^@1H}oBjg27T# zL6*I#I$u`K^wh7caxZdf$%;6e(&=LH*Kz80KeRf3aZ9m0kDZQ7&A#GLw6D}bla}5& zoHtl*(dV^}Z!9ibX-9YtOa1oi>xLHtpHNNRO#yc{v5=@TLx zCF$ZenG_a6%^_QJ_egf{>E(IN$KTkRJKR*Ps22s43a8tzEnZRY(&x6^#p7L%i+2+B z8oP>Hw&}KkZEv4xmzw>Wahxj_$_4bykwdM;;}ur2Z;LpAe1bx0TrwVLChJWSaME5V zGFK2tRMcd7A&D14rUxR>I<*#8=nTN`{iRZ7u3Q?+Ziy(lYKNv6CO&yl;iT_J=`fo& z#WvwD5kWMR(Pq?miXxg~ow+PFWGh_NoMFyy@;Zu(V&1h7{E1Rbc-S~wA%$KSE2pF| zDHrPLFOh$syfjW)Ib~InGbO!*2<+NnJt-Wm#=7}ydcNOMlhMz|~p0 zS|M>S@@=A)65OFL9*2c|d)qhpRX^)094%IIYQCxEc=9a`)kSy_3SYPfn(SRf4Z1oo zwPu(~=D^CC902kspg)eZ`Iw0DY|#R)>YikRsP;c8iKC74ebd5H4hLzDr;Dam&nA%; z^heXI#Bqv_JaETdpqb&n5CqQ*c-ez6{7q{rgB>oa+Sj6Vd06ynE?~qgiF1mqivWot zYBeO!v;~(e%9KcYH9~G_bvC^FhX}r^Kd~lK&d4E;?_)2g$*3wO3VlAM+z;$eKpzRu z0Bgd}9jN@QG8AdgH<&T*=d1$r*43IRiP>$u$Km@2>QcR zb|zOP9lBG-$c&|RP1LrI2Gn6QEi$%wAe&(EIAgr7jp==>7mHg0Cq;=GZ^kF<&n9#tn*^5Pm@404zB4T?>8(Puz{YcC!p(ezeX(VW)rFPb(9yGu5&QXQ z;b2t8srjmgYsxZL6h@>4|E}Q}vaFSbVQC>b*T&*lF+Q?&-IhzpttHiDsLfWjtQ6Lh zUpeYlmQgh{q#oWjmlp9)q2=~1R%b@pjX#N&3%6Ju(2I-5evBA0&wCtu8~7p7v{Vez znW<4fpg{9RH7zf@p}lv4Ns={?C*zc{85vEhD~DSXD&+OBc%@u(rX@xa`c>@=pe&AFI% ziq45-d0Kp~A6d92%iu74sl)<(=dA{;Mm+IyG|KG6tJF&RNbOD%hy03aktb(X0NJkq zw764lbw5;Cm(nm@;cE-mjOR(1oYEhtqATSw)168i*&j_RUZ`t*Ngv6Ri)!Yk9$Z~p z94{?N*yF#U&Xl@Ti5d?d@ci83L!`lncx*k;X!3U zHuVk)Aq*a8>KaW%4(q6%V;At{eh1bHL-9Hm@ATK$Vc=JY$quHAu$IV51oF@Pp@w=o z^g+RB%%b#HdhbzgPUdoSnp>!L7_hI zJPznF%*r!7^Q1ZF#N)oEaK&Jjn8p@aTf6%*5+r`P76`6YX(DT*NWslqbV)(~iPHWs zLzbj?vT#jxDJ8Mc^fYlV{1M8f=*~lMx+TT5OjtYmMgs0UlH}em$+kL#Q#}!7%RW`G z>rbqjJdZU|co=FxGx-d2T3RHbamgpq=i?_ud}{zR=-|o2L3eaXSEb6sV;S5^s+No9 zYmHD9Uqz&X-48FHRw3~k^k))%JZq$-SjsUfiBm4fDHalYz{?Wv{RQ=2Ln1a8 zhYh9h{1P~?0jkJ{ERKTKcDD%(VM~)4x=G?z)YN*0Z(L10zxD5)fI`E4M4SEUeVq*? zt}yW`^r_O!HSTJOZC(^YA!3g}0y$lAS^Xn82NZy3HUEQp&3G{PB2cXiwpJ!JxC?)v zTvKH7MjeTA&75VY`gJ)PjGmsMwD5Uql;*3kR}V(`48co6kuqKR6D^(&OI)({$Twr`>_PCOY8Tm)%hza& z>)2e>G1J<~d2EvBXg#_lDw4+AaL40(JPY2-1-`R&{uwq`2vc;Q3w*>yTPkoiYdt4Y zqS5h$N)-Go(7h#wvo^3um(joz$}!?8sfZNKTI8MnZlFGtq+ZcFX{(JpkMOjOxC*HU z?`D&pJMJgrv~geeqHePUG$fs7At!3kW`MP26yQdB1eds#HZpoX+nB5s#9Lq2vYk4y zL0E4v^H2ubv%av&%cIeZ*^NPCp$10ax7|{y%kt}_M#V=(k*%EfO zt)Sj&t;scug&YNs#8;R;5AVcsDL=$7f9qUMYu2}i3A}uS{C$IrE)+`{1dRE_+IEqTShY7!{V%WdoEc_rF(#f3+xcE zf3E^MObg@1&1;K#ImzM5wKqX0i4pRHw37wXU!&E)&g8~iY+=gk_ab>r4hx(1!D@X<6rzoTZQLZzx=GqP6zmnsx=oSetIWas@5gyQws*HA`)&UEdh!D)(RzOzz9{ zm&lW-fI?!K#jTrdEzE>nSk*k7Po+^LsXjDFMv6F>lwUZNagnYYM_^3oJ@|tG;CI zSg&WSw`|{wdp()yY`TDq3rznK*zG-W|3jaswY1Lkcn6R@&nk835(XRP>7`#Y&G>Jj z3$H09u*u)&^YsR%{wPs`-zA^({PZ-o1bppY;5ipP){l!RttF2FY{|n49hwU+n|!_K zPYjc6u|fy8(%2|l#s4kMj6V$B_GCJJfCele2Uk)crf6;q!|6qq(hkbUuF6cc$aQ8P-OpK}La=0LE?_ct%`-SgUXW*bjJ=NYBf zvF(}{p-YJk&|Y}61}A=Rh-$RC2FN8c0Qx=xXV^9%&&CwntDjSp55#!J@FLqX5@!uM z^$iD>QC0ae_%#lK3#Pt-euLAPYM;W&@)Mp*>0i6^%^hL4F#r#xkX#&9OX`d! z9zsLI+sb2$%Z;X@?##{unNmF1lymJI!k^A?1nerc2VFO_fR>5;{`<>9{tOvg$>1|| z276(nBiK=7E{;TN<}L;BcQ+7(r?7j;P6T9j+esHZwJ&3{dvtuvyXe%){K)v#1KH;) zCrc98savhWHBx6*P2|7{edX$=%5%_%s*V+V%6GqbdAZP9 z;BA$G7d&`R&RA16cZ#ZopMHA!YoscHA-+HoB^*Bo0Q6Y8q&!nFrcoq_2HrXVKAOA=b2N#R9)`+8I zZEJ=yP~~&yy3JIAslTt=+I(;%v*O6__Ya@QMBF^STrDrXp7{Q$u3arQjY%VG11uIq zcRY9bi%`J_>ncjgeypnL^H>1*PUO@N^0u3TuuOSu^HMF=`IS$BjLvP>JvzGO`GZv% zUE8mFbY$yu2dd7wnl{vo+`hiZ)x5E0uqwa%_D_!t-bjA_%$b;qs!b1(zZoL$2&(BXkdLWc5Sas?n*^GL zq(|nraL2_3y2n>!6N&9b-jLdjc9*QHvBM;Bdjs$)%nc`_MqMGPHh08s7 z)^rXeM((=p^G*^7hxnFk34y9iF0qRJ)mthH`vErD3xYxy?uFmsiHWDBGHAP9!L!Pt zFU4|VJi&vtR&*~8)Ph%qFIpEwNU@w zk0chtR9<1h#pvf_gCPW}ml3ZvtgEqd;**)Cgr0 zg<}iDh=G;D@6AOKgLaX*i96Yut;-5We|e}mo|_Qj>KQkp(yD;gPd>CT8vG-?8z%!*{g_*{Q%lR%pafB^BU_h0+~* zmDZY78>!sU8wn2`XrsV%)DTYIoH^Vg>KrU2PGA^zKd>g{X>(9@$dxP*>VcEVp_JxA zC;^3LgkPG0`r>GXbgod!-y`1v%|T~N*A&;WQCjel(!8!LoKdz&0v2{nE064VCw|Uw z*`4i{vI{AZA{0d*`~J_2S;)4oep7}!V6Pg_hqGq752v#7vqB~~O8O%C(*bN4>=O%| z?&GP|dFGk9k@5Om?1zf=QU%yzjq`v!{^#sv{1)_TTelqNr|XPUH&DPwMoW%TSyB8s z(me}7Sm(v1hVrU9r>DZN3Xfeg2s6bjrrpxXRdS0x`dF+)I{_|UWTYjz&l<@d8}wpX z{pj(?b;S`)y2w#>Hc@4(mDl%ec)!&$16LSo*Vhc^Ds+)bvgj`(A<|jH9&K3XR&!IK zloGoykHx6Il@l}!dorydC3iJv{P#uqHsgY2?g{KZy~6D8iac}lU+7(sIf4N!+fcVXDP2|T4 zf&M;)y-elhlL=0;FzdesYAHoFLVu;S@Zh;UbQVz6U#F;VaPUa?z;(d_Qh6=DsBK1h zJ!5xmCbbT&|Ne1OFXt#L8Hz0mbu6T*aau`R^CqAbpXmps&(I7!Q*dKL-{hb&;ncU# zOZb$&VSV-gA?-cjt18dO@w{i;z1O*W?>%zw%}s7{v-ci^B#a~wNC%di8At(R$oO5q-1K585pC1ajNzQrS=Y8Jy zneQ_U{2M>LksXXG5HT55VIXT{8>&}zV`t9KNhgq-o@Dr#1QN;L>AI?7`nG`1)RJev zqKOlJQtv-ei#i?flY#yOM#$SCq9R}+c@&{sNRxjhA3?vtpP;K9=f!Yb>ZzTI>G&ou zrehw@;?vTu0d{0|ylqKZ#+@U)T#yHfw^R!#-=D0oe`C#rFfZVPg5egd1j0~~e?Rm; z0m;8O!b&2uvUi`t{}XKgS})>UauvGdJ7H~yuxc)pPhE;4lRt#GzY^+r9J*^l&I81x z4O!TXOA2X?utm7kC|Zw%A2nFnCh}wx&ue%LeDo2x4nXeW^)=|ozmppcs>dH!nBZv0 z{D#&Ysb~s0J?PY}XLeu<8);z4?9vn9M<{R-o|AEg z9~#Y>D|CNAHrQR*S?b}h+}~~}LM&r@x-99qzdhsU8U+Y^$N{ z%vkyIj$q`f55Ko`DASWEGzbZ9S$uTqy2_yw0c-Ej;>e*xCHp>l__(ufVHwx#PZ$El z;8x69SmQ|*nJPwV|FL8tG@~`LmX40jhWd6-{a_-wqCbsu_FZjtTZO#l!lsCN!AQJ0 zLTukyb=6ok4%ZK|dnYQ;F!5{I8!f7YFk3!VhV0VDhsl^6{Mlb(7bmN3;@u>=k=JEe z>dFMvB^gEkl^qUcsG;y!V$scW$*WAOgsVF4r>w@_ZMtvq6>lHwZ%&W%sDSwRf&=~KBXthF zQ=H9PfH?Un?YGm=RzI~~OV;4`0U9UhPrDDjx|uw<4XjvnVrBXxL#ivWr(;j;sx~iD zwe{Dx_hO)W!(EF?7t}c?mL?Y+q{oG$p&!F>sroMYz5l3NgWLsT4z<6chB8v4ntw0( zz4`Nz6RXnQhhBqICdVXW$+K|Gerj~`KRd~<(Iz3|B=i+B;7Eu3D zo!!J zIB)Z=;iM(i8n72yC9zyMZ$*9>aG85tF}`e2?nv0PfxzfGf7&i_*DXxPduw7+StMDa zFI(Ckl3POhf$2bC`O)rreZ;PyLV+1S>jz{vxCsMvf7Sx(Mg-)=xY96h`*a)m2DG0o z`Y>fbms+4bt)QYY$Ui{qSgUkI^)}i{rdps({&4bZ1pbzZ;iC1VGBDk$fGRZgB0n`} zN0+nK$rf=iEx|V_O(C0_)$svXGi%>SlEbssSmi3VJWv-$ZkiD{Vq{{tF0MeEy}G46 z+$ZIBx!NIq_f@BrcbscA#S$NE`yggfI|W~=B9@=RJu~q5Rs-o!DZz+BLN;T79Fj;u zn^wulSzfl*fRwSh*-1J`2TfAt@KEGAXnzL|$T7|O;tv8pS75q_ZO=Xnme(HF^V8rR z@|H!noB4CeztXYAUtuyj{=}7~gZx@17kR%h8Kj6!i%zaecOCl0#)WsSDf=gNe5+Tq z`;Dm{__fW4lu=|?xAmUEE8aQY->~(bq0$Al&g96!zOvz3M`Gjv#QonP?bk50FOUAW zvhG)M;6aNyd>4U_l1pXP9_$~04_G03K!lu zzihb1uGA{U+@W!y|x4nB}prdU_OvT$2@Gvg=EnKe+&VJDua!mQqD3C(!H~!*^ zMJHAix8L;Y6^o9qC`MfecK7e<@f_Suc@)79cKrHqXW6RbLp$F(+y(X7H&$NZ>sZ&Y ziu#w{qgcUBmt%#M55(1XYqa1Bl!vK!dk8dT{r))=`E0 z;C0KJkhwCI073YV)c<(hqT|bp!@;OjDL@g?_v)Tn4$)QOb0fDmtzC76ccHB}w(<(| z#6N^o7Tm0()%6fd!y^yW_ytO}QMvZcbUB5-d3RSaaE2y7XCaU;QQpm#nbA;C^}!+W zWxQcTgu7*Bo>das~)@~ zSpTz4U02TX&$;d8r3yPppPa?U=atXOM2!N1dr$55$CtSqi>w*AfDP9Q zZr&&LMU#4G3VE0^^5-v@J5svnx~4Oe56tdrYU*-S&remZ>Z_1nwbkOX2zc<^8R40y z>PE>atL2hNVaZc!STi6u0;+C4O!3isK7=cJ>9_ zRkOpUq+87vsl;bA5)ntJbVLlsm`j5q0AXvL_sG0e5p$v6AyfDg6<%k|EJFKKDP?hg zT@j%ytm=+;Tr;oG)3B(lVQFVttq2v@`t<>~Q|Z)bqhfu)X%*{j!Ht@xLC&h<}@FS&b(PmF+j9)0wlO)uTWNhA3*_$JW0q_pS2SP6MA#?-8z z{3TsKHye`!@_OeoK2?;;X{2lC(R7TII6CLdrlNAdS~?KNDEz)L_4+4@fVQ&?1wvmRVT14jN-!t?wJd{#;ODJbh? zs^~nlSimc@mWdiaXcRPWJU)N^!8r~A{6^IN^yXz$%ba<4tj=Us-!YH+yfoWOOHnWj zi=t0ZJ12MKYPzyqc+#O_?wc&z(Z?m+zFiCE{_4evhm1(s=%Ax+w3;kO9|v1{`P}p^ zL$}`p(63NXRpD$bkBAtaqA8e#ABE#m@-1_zguA$e$9K#P7OPw_gD&DwsT>iVA?8vQ zs~j1)qIUF1?RPE!Onx)D6YId6Ev_pB)H$VX?`z)9@w*H5rVz;*2D`2q;$a?Hg2jKsU$tr zHv??kQaf5nMvT~-TU|k%o!r~CU=NWxH0Q=+DEJ&8p_HRKNh!lL$$%eZo@e! zN6z^HCqU1PY!zD-3afbHDh%j}iN9$}%vDiDBR4~U{zeoTjY&14QJ5%P{~4~Wfwq&N zjHEpmx!Za)!_rQC1%5UDIG`~GUNN(#~*0zC1M(`!4cGjt9%NXqr|hHkIEIVk$0*v zWR})0`wchR&=>Bxeo;|f*FrU-=BnfZQ?%SlWzfwfY_jK`%<71f=TJ(Xmec(7a@VR< zAaC9s^$gXE4SpYXr|*CF-3u^HOaKGY;`$wpj0nVk1|i-cdOx*)*@j%AEK2C%-@+#za)FI!D%tON({@ z^;;(UG*4rqWo8V0me+9v@4kMd$ltOg)39&X#zI0T#;5doHgm7V@I&Nta@XjG z(4s;+FFZs^2rvoRAsu`29kD;#Ut(wh7h9$0AT2xq{{6Z^g}7|p!C<#-;$7Mcl5ab( zr#)Nf$cJO(^>98kGc_L-vxP0j=vY@OlTHk5P*0#EcG;9ukh-IQS^`BV*x~@cdc~1p z6!0@QBTh+gX@C6>j{XAzI~Av+P*F0S$}&eK#&CXMg!6yL|kHKCn7qCVyAh zp0cu#-idozmQ;HjILraK)?Y)O{|*xu4`H;im=16BzMwKlB>jIIebG|e(AqUSln$Y? zh$>uIR9tFC)}o!ylAk=czJgFG4vLaXp9Q*~QF6|R-h%vIuu`*FhgbJKpDOXknT3@2%4!;?mrifi>PVD<2O*lBf*+G~d*-LWr-*WIn^p=Bn?7jU4dY&uL{iuYslg=ZGp_jOzrs5VZShI{)Q7OaIH-JfR0M@>S%0@^uhl z-rIoQ0(QgqP%7h19s_~1bIw8(yifhkhwcXyU8yeP+n`i6a4*MGHCU=IG_V9Xrj&A2 zLXVGAd=@)Zwz$EAb970aNRB7!z`N5hmca3-BD6Fr=zAn8Kub>3YRv*$sYW+`75 z6+;k|lXC~2sK@+pRTGcp;P?;pU5mF?{qrBpwuiP*COw86y)uS0HF>l!LWiebDtEs zoFKUV+?;eqP<&vXO3VKS!Tfg)%qNtB{{R&AQR54x;C7#tycv0)CnE<5pByZP6pZaht+N zfDv0&QI1<$tERDbgI*w={)Y3iWuR z@5tK9!oE#4eYeA}{hOM)hn+P;>F!}i%`iRJLUcd!B3y%%vRJa*=zo~BAm5~A_A22_ zQWot7mEWQ)_CmHKlW47=3tIfHLZixMkor2-HD(4YEV@vs)mMV?MEt820v?W|aiCNaqFLTPWkRx{33+ObCtR;vS2a{>aI|dbsyBXb z0GD6ojQkcXwiLGpO2?Z0=isqs#`*y*-z?MiXm&7)J!h+~<G0oiC;Zl8j zlhnYQe>Y)ZSFvPrg9T1uu1PoouY!JKyw20U-OM#8{wYGHuC{hbwT_#3BEc!d zd>xJ839`9nO;<43wWfyp+}J_Sy9d1m+XTn^E};fS)tf~Z|Wkt9sTg2YTvN1>g5x!n5*7M1B#2}eff}z%LWNCG3lU6I2s#rv9 zT_#u)kg*VF3!!4M6n2M4U0$Q9UN-=QuBe_bR}c;*Ht4hSMSPhc;q{n{S^{EFBv7g) zYAL5YZLTbGAcB>MP^K2i#4-g?MVH`-iT2x z(KEI%oEIIyAA#plMpbIaRZwxjWmD^?s^)yh4Oj`tt70M)H;H^oU zs*7C+joUGZ+gkiVxJF;z3TKovVoJp17UVjQpdzi(7U7eh>eD4f>R?CO>S}o=hAeI+I~5g*1!71G3*h`5IDfKW zMje%ls;H=@O|ThNm43^Y@_7=u4(fuXMWUqJLJ)*WtrBy^m|I_x49l$LF;m=a(U^)m zV(B(5?iO>o0X_FVx!7L9NSFE@5-|TqWUJsxv}p#X=FiXI01%(1xFZCsbZgpo5~1&EO*o z*I31=il56&9+f>TGr5$`2vmb56X))xWJAoMav7yDhX0Kr?;~^J`rLVOAs06-V=mYk z(M^C-LsigSY!gDe$XwK!F#0q)j)KqQ@(l*ug%cXNT^c%5F>2u8YqVBVqR~hGF4SIP z@CG%B6>lr!zI-p&5i4=o2%SYghI4Mkjw3tZ znlJUag4Z}kpFhmKpB-&pP*gO#M8m<3H`UZMWkzb9&f1X-jk7iA0b~Pq{4zdQWCJJC zJX}=N2VcCOYYKS7TtKyJAX@#XHXpQ+ zkJdS?)EAFY2ewdiRzteT(DI@HTbNNm!RsW4uzKO3Kx#)jFr8%mZXvJme|TR$0U44XX`<}M8=`c zrlI8(-3cTA+Lei7a^>IDW=Yn?wgC%YFHIywN`h;YaD7g_Qm&JWSf|+T%6X-Q^#Qp+ z?bJnM&dUCHse?F;1>~akjLs-RcREY#2C1Xe&rXljyN%&elRh4_3l!an$UvRf`YgoD zF!BYm55K>_M4t`H)sP5cOkNljtIZe{$UafBrp;wMr9%Kms&%SmY|Iu4*Z5Vy;N^4l z68uzn^`?#SfBwnX+}c=dE7jP&O(W@&4M82%Z(=b#eLSon+7lz2WR$Y4EX}>gmlfP zYj0DxW*668M;Jd$Ug34B*bRXwE4xKX4PRo!kFXr6W`AL4u_->VsY-skyl7sH%UaqQ zw&8#+WE;FCVT^hQD7~bolMMWE>=|XlyWgjG^f)U zI%ljvk9>eEhOhEubib) zY<$tfQ|lBQ1QlpC#m!O+i(kzm;wb<&a z?2B5GO7*EqrBngU>Ox;KmFUmdEM>Fekne>R(jOO4wG<}bBexjV>>$m@0`;=9%4Ir7Zcr*wf$JYHVEH;!f`W>IdjTPvhcJsXI)y!P7{|vM;1+ zqgpE9HBX+8r>DoYhC)SPhMrLnq0bgzNCd`6BJ=G*{ph8aJ_RE3-d@0>q zH=gD8w1q`D82dMfy6A{Dh-i?^ubLsI!a>o^f?%mJQ&z0;wKcbR5LA9>tNmZjXkSlH zF#fNSfRFQ_?9dkPHmZC^HWX43@^Pr*9olGZKbs)Rv)&ilTUUlAb1D)# zcSf|aQ}4H%q(L8!D0REox_D0pP`Txif%Xa_%{QqOHaZ{Or?QtcI!#`SQASu*LIhFh zu4d~K-Q|TNbbdNokxeeQhU^9jUnXS7tYTecu)RcxvQR43oC-sqHZ^$ONhYRq@>TLMI)))o|EQv>5YO--Kv~Rmu)r?47f&Raq}U7q&FMKAOUPEad45Xe zuR!X#C=Xf;^&4k}BMq|}B4t~?zh!t|zqf47-HQ!{9`#eFlGn9eUE*T#egv(j!t!}` zMXI4cVM@3N?8hBylTyfXv^Q62RNh!c|Aw~Nr><;?bd04Mwk>W^E1aI7zW$k|d~wL% z%g6@RRB!XW7}AQrj2*fm!o{vHs!X+ z2N5tD{vf;!ydGS-W%IINFn3KFycg^t*HeG#{I7G^S`0uPlL}+9T{KJf9F=4U@p zS49&e2mAZ)1-r=&c4KX0y+vu1bF`IJX@$4hPEHIh(O0kPrs@4rat*o*f1J+KrWQY) za64^w+wz06FDlLeJ_a~1)VZmPOJ(1>nauiDCQnxg1eil6avQ4Z1e`YBbZG*q$Y8ie z4es}L?O9xgx7IWXr1~L+ylC#m%rH}apa$8VSGobh`8tHN3gWM{V7hPYcU81NW)$U} zy0EjL3Dlx~f5(Q@@?(qq0|6<=9M;Z+SYJl9F7w3d3JaS;s)pG&a!{rC0@+2S$sRKn zDqc}sv#@LLNRd=Dnh*4k2c%NSVf4`oXCl+2Fo>vzvPi)wv@4cC{Zv5v3$pql(>8V{ zkH}V7CV*XNG}wYRt<)^Vv?;&4BBZgFG<%~JYKhP^S~+T9W5o((&tOSNAQ@2`ZJC~E z-P#Vn(`?lvVm;%d2qFonSFjjaLuJpfl6j0gKmNuy-Pm)=k{vIS@FcrAVxd4vn>YZN zs=X$^UPOc%q5=tS&}M|9SgEsqNp-r*jInXAT>Tlebp-r53wcsb$|Ey+)V54mU#<{f z+|rnSw4r<@ZSx=ni_q(lC9HKhoiQ8oLjfhfxCSN>q?)WdnUaDTs*)ho&sc2GA+?${ z9In$EPB}lZyFINdYr}0RldEb@yv2_jj4L!8p;RPS!u^QMcFfmt1Y%4evX{pU_NG)g z3O)#|ZS31O6f>sUWAVWTU(l8!G6{)+!-kt;DdJc(g$a>9>pQMP4}dS>{-vhu!Wmlp zMe&wQebVVWS=TO0f2pq~sNu>jYQ4=}-sX}8BT;1$F6D~la;?g2)LDx}$$A~3G^k`e zzL5}54;xzsS zb=^z2X^(;1DE-s=zy5XoJrLHl=nY^sTsyRXvndK$&Ye7c%7=+mQ5K?g_!QQ#o`>OQ z$lG=Ls7xn=nsC~dlX;*4KRtC1!@aZOI23~t>UZN1?)7kNK8@EbkPw;UVeJWRND$JU z(1oz&@4Pejz4s{p+$4$o1$+;#lULxRPPTkH@00>9n|2B{`>CW;A}Nom@(=uGfr2ZN zN)+O4r=tP~U(QVuS{@oq*&_x%imKs}AY{lr&IsjAkr`=Rp=p^(q!bCo$Q*LvP?f|g zwTW0#mWi;8te_f2X zZsZNHfpvgBbC=fTp)SF|2FSYtm43pjR&tblj+iSIVd#pvr`s^uUQ1=6nJ1`L@Nuo) zfc$&ns@z^Y4A0%v9TIq0LcUUQER1QcLd4|Std9s?0ckN=kYBG)1@-64RlLl)ie~tX z(%Mq5FUB|b1$vtWRsbl^QPMzpjv$bHzTSwlEZn5VhIvnWaJ5cs5@lUT>ok^-Gw2!{ zB0uC)UL?MtK`z7{o)F;HJ8a}*pw(*>3CLXt@J-nd$$0)gn5LkM<<(R=tq&TK4PGJ3p6|S4 z<>0dbHcsgH0**k6BIgBsYe{Q&Wc=GuguqWvoD+!8$!wyR5eZlFwZb8Nk@mqafwFuVEmwu~ zzAC8AvoQjUos3S$BGdW$oQ_Z-?}sk}r!$ZcY>Rakn**&&%3_@*@as6XdQB$Pn@FV+ zf3&1$#p~B}_~6$>{pt=M5fGE% zR2l^3OZjR(pTIDEl<*guA-4%}loF9#p(6~0!5i}$^vSNG#B2ih^0-_+S0R_kBywZO z;cG}3ae+b45)la@&s-5O~}cgBYy>7vvx8yD$#8E zKSKzFDoKajpveT0Uu+8~S;ly4oG0fgtWq6E#lr+_Hcti(478AKh_@z{a+^aBe-2rj z&WNMW1>1^klqQbwxb+GF3O^tkM}Pol3i~RZP*umIjdDKfr(B~2n~>MRA6RKR4unQw z$z|9m%S!VKDo6*V9-!K3W)PlGz~j}+F-;IMSC2+XL%-t5_|O&vNxwu|!N=89a=8W)&d*i~YxPZNH*laH9y zPYHQK9U<~LLTRIdD|}L|LAee^hzNvzO^eYRAV=`lt}UTr;Q~_ZTeDZJ`i4sy(H>Wc+C3Z z*`*347XZG3Ugs!!7+J&UO#q#4fJQqQW5}BGhd1q&s!$b+gUAidER6&|GjR@)NQG~j zON^=VH-%E_z65y&0d%Wzi5Gc`cs;aC?o+0s*9O%0WH==OJ8jq3^?@V zDyZ~Vr)|NwMtbXZN=EF0bi1E*6{K4UedoebWRpV}12cxsR4{=ZIBi2Zj?)}Vi(W_$ zuL*UotcbK1nL=Hwuy^@tVMoI&2Rj-E`$6i~8&=-GF70YwS-Abwm!&v9n-iK5yP=G1Qi)rpWa{i@($^z*rcOu$tvM zwt{2k=b%06BY?7_=;m8MxSRj%Zx4+ zDH0oyy%cQl9n46-L(F{3@?9e!s_Zvb)y(1Y1_lLl(9>Wm%RuuTItZTb9WMq!B#{JF z8i~v<6FZfBOwrQRr?-aj_qjep@!CaQYQ9SlEU-thJ|}FtzP`Ph}RigX^1xlg3SrK7r-y!`_C}%Q+8T{3A?03@bBGW z9Cx~f-ujpt$Gv5(UhLN~r#G_3m}m|L8si3f{-+=Bs!3}H*p`UhpeW~%sNZQz7b^-Jlpbi2RF=zfxM_ zF=YR&LW%s56^-0S@ek+&r#ZP8`qsJ)N%wCyPlf$bICsPd*7Y zfyc-<5R!a@xhI`efbWA?0g7fO*POqGu0#JR7Ddgh_o2*x>YIBDY2&U==m>I~UjR3%6W*puVOARn!NE=J&T{ z6k(E#$`MO()9hd!zFn<}?fBij_x^52Ort(&ZQJo2NuD9Mf+Kf*`}DRJ3$xzlf_ z@&UTSgoO#W@BylGhXthr!2gi|;4Hu(!!ZmA}$gTCQ^_ zxf2iJr(TC=bRJxT5P!5l&QuwgSzDidQS*2d(qYe@!9ri_vZ~(Q^P`^TWpn1{=*dOeU8V;yikLMAsP2`sd$30RPm_c;tIpqdDRhpA8GN64>2ZbXF^h1?VW%;AEi zhVN$Ul;q-rFKR}RWs_875lj8(g-w`%L+&R6Cfw+hklz9f+j#!b_oReO!adKIviTY@ zSRhcy)l&S_w*%;VhH4vGp|Myr;K%k_!v#Bj3gt?LWFJ%{MFt5tMFp%=u*`vY6yx8c z>xVk%WJgM4V>$C9n%H!_3}pyI@NgG^Z~`0HlNt_s7nP2`y3iYz)im9F_;~NZ-`><{ zZoPWZ3AKSEl3543EBTg=7`by6vPPhrIEW5>YW7QYhImqe7`6s$L+b9Mf800xvtR#t zv&!aCxVIep;kcpL@VAG-`pN{km&R2Oc@p~pi%aJ=XLpxiF2G#O<-d#CYgxih--YEM zM%}|_HrJ#U>}qOVkW`kHKFm`qg?v+SaP<3o+E>2<6er4BLTb*K1geeR`L|eF zwzz-ItvWKT0M8U|+7eGIOlVdd-@0x$$FL!ide5tV4X@C$MxcaW*c~y2w z`*l*h$T#^p_B;G>h@*FD9C0Q;!@`)1$^nCxd|p%wJbP4hJlxeFn2JM!KcPqf3pWo& zdCH(MDMJz!B}3&J-Kp}#mb*SZJx2Xdsw`S??2osGd$fqBfa$|_j`bjV0qXg6wAUKKkaveO9nfi`)yV0- z87|9o_8rwYgY}>Y^V#-_q*WX5Sy<9n;S&%gE%Q<>n>u~z(60oDL~B!`JT|HcIUTJP z9+hxHBe!bBDtk!dEb;3(#!pS?g%u`W@!Hs~5AGS#N2^_~>ZrbQ{mH@QuM8~|88woL z=h6!s+^%_dtgqS~w{;G#tZW<0=-dqp)8Bl<RJeRtqXE6wpIkEVQkv@$VknGfZ~91zu+^$a^*6h zDNPiuIJI;pNZbE-dayWp`sB#SN$RYI$Vc%($d{3VztMida}cKakd9oJ^c$dniscD0 zD#*W2(sJe5%~e}dI&RQl=#AD6q)a^4%c-`AO6RUdxEinN+2+p>aMe$CRY~QLZbjj~ z9UURLtHfPYqOmGC6Nll%|8^A3skG0! z>BSX25CJut?w;rQ?BTi%$9lJ}tKD#H_SSW$6%C87YQOr!dj?a>?_9k8mv=3blV|C5 zzDGWUK1lbQD*!WP8Ge$IWs-?Q;122&c>!5MJ`{3;^C$?pNgaHbBp<;Z!RQ>vX<0@a z3@TPmluhf0XbgK~+uIE+t%N+M3R%o<(K86jTJ!dqkELpvn6sHD;qbMRCj@eZT1qGQ z&JAxYB=6Lk%~~+Oa6|Y)7v6z#C8Bduy+~-3eJYYrQjEUmgn0W36Ht*8@{8mcxLA(i zNy-D`g0_Nd^Ur#7&KGI2Or6tS}`UGa%7 z@D(l5_5@` zJV?P8C7(gB#~Ns_6fMKRlnisaavPgSPM>oT0z9_b(c1pjblD?(wL<7gG+r~3uHXC0 zj)o34ExA0+ORM@eH(S8D>b~-@)-_(;dJ7a>F0Wr2 ztG%6@C|Y}*ycPW%|23qwn*ZHTIU9t+c)^*7GpdYt%sSgkRmH4js$zO_{gf-_tk_;% zzs9TK2C8Po_ph8{Rbiz1S47F?-G-4`Y>(R?49cbLlnX|BxvJBYiM0$KSfL+0#h%pA?Dg z+HjD=A`<;&I(c2SAx=z8T$d9uawuX_^U8Jd`f5`Vfne8Vh0<-t%*HuIa;oC2u(>8I zi}oLU?RsmmGGE*%;&X5Q)d5>tg?OkRjutB@9e?s$@FcR~GWV=cyc0tOM23S}!b!EK z*d|~h8^{5Jv4XG?0&`J=m*(@$$ycg4I-nPIukwRGa4Jc|esN;zrJ zEC#4pA{1MzmZPk~?$uS*OB*aKM6bRE#|gjH7Bb6laOYd({#%!^EM69H}NOXhwg|i&m`yD zFWf6K5F-5ah3(O0rHQ#Vv=O}VCoGI&y&iC-WuH8rL-Jh}BA^4xQa#foi8t*GjnpYG~jTW`@t zYki~%KLz2Ke40GNL7|-q&%YzvTP3d~)pS{CnjN}wtr$u`wptZ!uIGwbanNEcX1~K% zlxmc}DlZD`Yx}BgPoUCBK5ytPdJr7<^v2yWg8cebS4RA*JmFm3^i|VZN2w8H)b-BS z$Z<<$AY7+??5Cv9;st$SFL>MMn79(T(%~b$-Y~K#T_=;K14zVWBg1|@GCXli?+0(# zTobPc(o$Jnn#}g8q|S6FT$2N?DR%LqASN$?99#NuF&?!a^_JQF(l=$%;7zUM#G?Rh zy26n%fNmmX{{uNoU*k&F>a)PPoZw@RapFq+Gz7v4ers|~Jnf8#q;(m_Hp36Yy=D4M zx z;<}27qb=ZLy9u2H1rUH!6UTvt{3~wIgLlnNdi`lQ{{^^y=hXaQ#`-C>oym94;Q{Mp zRtLBr=V4$6`H~uxPy}%;ah+}&7c?MnsS`(YXn<7l(o4_3$6$hnVF|QPJ0J|!?}QC z;bwr}mfcq5iiuqiqX&_d=dDvd2lmk{jkBi*vdGy-A(7oiUYIcwq^a|^=|LDeXI~57 z5B{I&ocfFXsX0sOx4%7u(&tc=9<(>qW+0`Xzm10AQLGgCN#l1Cd!)uk8nEA=x6xW@ z*W@|;1pWln4XG$V4Q|Z^ct_Fx0|Q5YAh+Q z8quY$&ZMs_J#fd4*ABKU{W-8dX^O|91|2R_>%?M%EnphH_li17ftA~&{#bnU@NnCz zdaEVfQ%JZZ(Mr9+gOm?n?Qi<$eoIB6InaOY#8#=yXsw!m@85Sn1>%3&hC};tNMYAW zF&yi<<1Ysm9$Q|FB9)J=-Szsx=Hi9dG|#^Cz?K+}io7oROp<4?6Yxw@^;^)`)aii4 zfSlj{1jW0KdSAYUT%*MdI_#I{|HYgM?3Zu7m5sN7bX5kiNF{SI?4BZ}{Pr{qQ$aoj zGBx>WkempTpQ?e3LvH)PY85;t)o~C@*MW`CSEFu=hRiri4TdrY zcwXVW@EgdNAAslB&(O~d9!B$Hn}rK1Ls>VkK7~m5aa|B zB%l7LR?Yc6E?|Q~wGD_#MfRlYrAU=jJn?&t0>zONVi_soDfr+g_K79TS|P4jb7s&H zz1l1Zu;wt>I{)>p}_qX9#+B}*R0jews z9LWf^Y4{a;8;%GU@U!}ruiSr4uT@kG@Djd#)lY8i$|KJPgMnK(dU6eTkF?KPS;%)G zchiIl3PzzUeg@7#_cO52bz*Hv7Im*~nW}pNl5*^s$H)uyu4cRWtYN|NQJBZuRbp1DodpWXcW?{`Rd`P4|mZl0-dXe@QxV}JjXKO zXQ4jbRFKU}!RfpdTFIvZauQjJq!IuycFz4Xm98=s{*J|lPH$`HAN<{&Q zwKA2}D!%d;fP3rOM>m$4JNNyDeDi0r$8PP|GSq1DNUAGtICM+xnwJjE6X1zOtznjk zkYRsnyzcq+9CIL5)8=JmK!9dv8>$;HQ3-$nlC`y)b;v(>58ij!*}-!gw= zwT96LpfG%w7Q87`kxKYP^Mq&@K?VEDxpyNhlS^-k#Wh>^AbQ(BR0DRU6AG zFMR_Mi5C@@mX({)-rIgkDdA9qJx8u0|Nig-n?`+7=x*Bf6ab*(-Sbuk2Z!-dI1hEx zj9#u_YEEwAqj!l~wm!5hI#|e&aVWVKau#-!IJxE1f^?__lHoh69^Y1#U7$!;HqwN! zX2{hu_#rr-cxqkKLjDl7oJ%A;wT4UO`#AXs_AJAjs5lj-#>Pe5348Xj=i#o|k5=9n zzJxnb41@fS#f=bP=cU{!r;oCJ19`bG2kUou>w$`xvZ+|Vd5b)-bq&U6lVWMqWHSYL z3$()?_+$d1P6EE69UU(oq1T5#q)nSIysU?R&|*_sbD# zC$wlW<+7*kr3$DA81bhIc+CA=&eEH5^zb&!P*I@%8m4n26?|JV?XMA|y zgRiXE^WN>9@dbMydG?SZy!Q74nOeE-5cM1`j#cB;RimV zKaHod`-mlI8*_&Kzy|-=@g%KR`d)pMHucVb#K#Al?gWt?I=lmIi|5LMg=`U3K?kQmYn}z`< zp#_b1L-;K8oqirPR07RRfGlkEGzk1-#{A$d^4Dt6O#bd7ARt#&BYP&+Pfw2Qc@CMI zH~U@BF?m@~es|G(shh5$Nf++S715+BXP&KEJNw!>A$_VhjkG^XHf(uxb+YT^xucsi z&m*Q#&-&VEXR!r)|J#9*u^VQseepm$g2J(h$*-V}eG1~fg4VI=5Ij0Id+I``1TcCD zlj@kJQq@sS4R@xkB};CYwf?335V{MJhLJMes!cM7 zMaKyjj)i;H)kM3~7I*uGHo7*{Vn}aGpnXtJL$1$xlj1@2qKXeQy`oS7Qsh=s=!{c! z7{?&^>Cqc{TQ<)MAVhLr{SE2|w(lDsEnm=_lq(2cWbU80j@-GT*jhfnG~N;=0H3fB zl~p(u;TrcNYv?sBzi(Y>Xyo{c#^GZ1FISH>4VauJxngrodvx{{4e4d`nzhR6;a%PF zdY^o1Q8dpTfwY>2>j>xRoQaEa=4UK|65L{dr76YscF&tZo;W%y^Q`863gn6fO$h}A zIo$J?oe<=b6)S>u0VzkDRZGE^)+H5s8a%VhtWa#OZ;SR_(YWrpq^e@p(u#LzISlo? zE$~bf(L4+&a(=eU$zxU?CY^~GYZG-6ipOpm=-k$35-j;nIeiU_rL+>6Mylo!QshTg zt8yre4BxyE9sUma{Y1RVEnc-r3bDrx$0$BG`8n$}q)j({i!yZvsHSW=8Jh(WiUtb6 zyJ-MNvjCd%1UZzv3{>R}7=je}khN3W8d-4j!bvEOPfr{`R-8Y}0AZ_>QX2>gIwwEJ z2O-~&(p9*zspfApdc{#qm@-s*2^zl61mx&1FQ0vI?SP|OQEW66*Y=hyed4P6qS0IC z9eq(neyrA@GQ=lREIsx1wi92R>_k>={@v4u#)?dddiPSjP$731WxdD$xO?>O)uj*I zrB~jx^!Uejv<%+&&#X-}`8jPr+8JNK6b@X@L`goP;HD%#85h0nkZ+Wi)svk1z=F^GrS8TY}-{PvDBn*Gp)WTyED&GHEhO<%R=Ktua& z8ykGhOUk0PK6%T*SFdc?GSX$OQ`$rdU**D<%6V!1s%5_?zHAt;vzjvVGNt`hQ6-up8{@HebiA?*|*_1_SMBtIp{Y zbNCWQ|2$0JhXtqWb^L(<*;sSlSrp!#TzrS-$9U{K) zFoZib`8j$DBMRu7ZwG6p>uBbsOH!VVrDxl~I=mzuY%8&FR1SlywcO9LWe!)zXJ>5A z>cO>F*WI>PQnpXISMY`4X2qd@yArXsp%CG-$b(IDgFsu`Vym22T(M~heE!fb1i5#3 z_+E+@{F7gx8cbZ!NJno{cTrR}HoBLS>ZIbNT}k}nYO>(3iIL7CKBN#- z>nhYAl#_pS)x?dNw5K{1Qt-tru2QAoy5}q$ja4o0Eab9KR)6{33J`JD#Eh{*dqpB3 z<*B*xn#VCQ5vmPJEi!XaVOS--$w!2uah*9t=rsrcD6TQvgszlJZj3kjjh5;)KIM&m zRUjB5v|fc;$y1D^DycfF#aGG&F!8iRdyzq{tsg|IkxQP5Y+WzRHNQh!O{F07X z)>%D^2@%d_W!BxZB;6TR3WNf{6)ho;z_Z_ix?0w@9^V_^cHl^d9kJ~F<@I$o&muyc z|GY@R5smAd1Rp-z(s8IJzWw0QPD?gk&jo24$57f9rwl1N)tq)fo4}MG4W36d2yC?B zg;Fs|$TC+lS(8|-!8KO5VwJJjpJ`V2J-mYBHrzbKHV3R~?n*(4qc8sH)=%Tba=l8< zM~jm!VdZw6lq=OA@r8MUs?7Ujnb{5c_zI%}SR5fK*@PivhY;fm<#Zmci_$qEY(Y9Y zBnKBU1&|B1B^j8gD3IJ`cUKOml)tQnIDS0?4L@wM95mJ!LVyzWh8uKJooL)pSlXPx z&@4>e2n7>4&VXZ%pya>4<&oVOAZt0F{Fbef-&5EWrP3?uo?OikuJ9#rIj8V6#ZK5s z>flg-HEU_WR?^ra?z}#ekwYZeSH(Y>d%N<8;1dDlD#}iXEE#`|D_K;N2U?gsI` zYJfljfrJ1XNJ4tD*$t_?DWq-+NjAHw&u(@DNuHG5U|;{{-YdyA5cYXK@AG;80PCKa zJMGS#b7tn8?>Q4o4%Ja&V2O6Qi90>mF8i;H7uhhv-#*f$duM#W@K{k_t`GmK1mT9h z-YEIKBMqXyUwEv@Plr}K68?5ngQ&TcKw&vgyIatQ;2W?6it9h0j2}(Dy!x^mbh$70 zpQm^__#>VSM}7=!8Gn!#nhW&hAuMqU&6z9*YBTg6e4zjGR3Qq;PtdCI2g60Ycb=N( z2k3j@`_u0ar!yt*Oy)&ZaojtcQP7{S%YZy7vBeZe@FcC!Q|YI;R|CPl@T2{gS3^Gc zcW=f_#uR2<87cT1M0*IlX@sy>!xAw8+@F)@dm+z%$m0pT+%R+@@5v&#^;DZ?MYB~3g(`E=sev`0+}+0JQg^(N7iVL!gdRGzkBGz#oca}k(+L9~ zFi}P}F(LMM{jog8m~1M_4v4dUsNlq>m`k$#;_UBNt~T4~1;?A(hog%g=*#ZPlyH(m zvxNZFNhqC{Kk*6i%UZdxVB&8WYO*dI=v%dP)lvdT2RBgsE){_8ct}haVP}ry|b{ z!d~gu6$=o>1@SYI%i_nxk40TqJRZ+HbN~Hk@~^F7oWz8iydSP3CWeqV_0z64BCY{w zX!}q3r3f)5wXl}T)lo<3Y~~j+ak5L`;5UDjOQLo#xY3VFw1349JscW4Wh@xrh*|h^ z0u^EfA8-Zu8ys28xE@cyx4`~6@Kbc6Zo{;?r&K)RhC@G1&7(8t5mk3pH#5qg?9T4Z zQE-y+ze6*utyBah$~sJc~+6d*#Vy1{w__$l;r zSg&Tr9mow7%g?Dv^J-Gop_aVPbWybXXLpo6U7wfk5m>@U$fsd}jRg@gm|^oqhaA?Teeeoj&(YlLH5LA)SRlgXPfW-w)lEEsYX z2j`V`!JP{cG+b3$B^?yw?@7!2pph1~fk1DC^+{rvp2>b zEM96h|GaWl6VgAso)|5B2<-1^+P58l9Yg9#{ag)s%0d#Ot1NtHaASgfcss(4R?|Lf14!D|n4gc8wzaPUj*;>a1)bfZ}>J zp=c>7Q4Mv6K1$hGD09Z`*i*FPM2jiMEXLGOr+)f_cT&nc3OYjQTL7<_CbL7*U2l)! z-Meq&r6cvx>?I;uG-a=N3hH8DIv)^Hcw&*51%$U3Vck?aACByS?q~a;1j=#?<7<1y zij!@qK!oD;A*$Glo9HYlkcSc-n{7FP&9J3h_!fBPNFpdQE0{E=SZwUnilTO z4?#T$K^`XWF;>HGEg&M8BA-VS_ZW7V{u$IG*fcSTBO3CfB~E%nR+BpPT670BXr1M$ z%k%O?vs&FXd5L`R%*m$PhSKZzzckXce<%a~1y3=#%ynbdlHTn zGgcsBr}Rac)%ypnHP*7RI!D>a#*wn{j$FzjcjTJ%mUMq>Sx#yokfPJN`Z3_zip!sPk@Fw5zl?TkT9R zi(w%uKg zrwEJWL^~qC`dDIBvYNQ6h*vVns|q;ZEt8kA6_9u2Oh0cog|A#9cGcJ2xeyT&$j+Do zuqzmOO_1KdyYaS@Kw!yBsus<47AGnSifs7-3r`?sTXP=js9D`$6S*r>tLlNxkz0yk z81UJU1yXOKojiH|&D{j7=n;v@r*)=@WFn5F)t_U|ZT9Gj^HO8wO9zTmN0!;Mx#70k zpiIbzZBP7<_bk)liFp9cpHH`H_IF)Kz+z0foUz7- zUg#|;k70#nQij%R5FV)vIx{5-NsPEv<1 z9()IGpb1R0v{z04_)tDieoyZt@fxSMH3+6;bhvrcB_X|Idh@u`jv8t?RAZ3q+A

HN5>yBVM6d@Cl!mAxKePl2Mt)8&098eP^r}y{s*_kNQ(UWq^hRZNC;G>ZlrSda zb~t;2rjOpU_tDdD)6Q%FmB*eJE{D!#o@p6!iE(8brUvCc!}LiEVTBFTzXnKYn0_5kal-NN{&EF)Eu8dH1I<@sP&2PVc{wYfH{6f-mN+te#fvQR+68#FQ z#BUdXs#M~)P&HfVC8tuUM9qA9{^Q!e%+{^TSBdmqs>FTtBvhh!TDD4zW0H=(%;o6E zz3koOUFC}S8v7z_E}d%-k1h(GPOs$vu80O8o|ZBIq*aRmm>1sH^Nvt5^G%*l*^*t@ z$xF*LzMWruosU$#u<8wwzI%SYM%NJI3S1|JOTp^p>_TnR021LYv*EI`xtb40;UAp_ zB=@$GX_@Rc%wf(Nc&sn@gS;Dcf;O>_rJwr0w_|fQzs1P9ckl&sfOPKtUPv&&$Dd}vLB-9 zFsX*@HZlXmJl#%DG(qf*glkG>;p&vl;2)aZL3X8#?6O~=DhWxn`Wt#o$t%1-#vFBY zF_~9bQ&vfoRCr-_eVJ6KTf{R8|5tUdSu)NsNxM&?ze?3(oR}vy8ohH=PFgXlDZgzS zH7f46%@ntHuZM>KaQ&IJ$$CnQzpy#uriZ9O!OtY)nvgstn zmxb(lR?9B(OI3(DqGBw>oFrnlfoi$9FB>pSs;XREVzoh{Nag!&DF9WuxLQwBG~%FWq+CvKO?1&&0;sg7)VP<=_7e#{T@SDOqSGbv$Y34?d^bgVT%`2%NkQpTZ5<>2(-IPiEK2z4biQqP4}KIbmgXw(+S}B~F~|KG zA(?w7#MmlessU&LZpL3AolkBfmVlZJIlhdZM9fq?EhXeAHOg|+?q+p**5D09P4ZHd zbT=UVT{oE4eZ-@VL#f0w`+y}PkXFRUbf+RdQGrcfg^60SL zNee{1A)-Q>3e5;a-Hb+gp1sx%6o|U9K;5)Jl$jp(I>J$Cl~Wdo;@kVDA|9_GnWB>I z461!`sf&U7ipx}X6i}rYy&q4u812ut+u1h|Ya3Hj7V~r|5jkrcGZDP{h^^4O9e1i$ zzvn>M?z)sbS5tun@ykUo=!6H_&fJ_IHty+r+X~v@fmdFB#U-h4rowuM-d-GgtMmE< zXjE=d67;u_*FsI$hC*mWN0lFmune8l~wbDo<5FK=a#Uy8y-8U(UtcNMLrc> zd7K&*kFLCExqeR%H8>TE`8XP-#A2w})}JXZ%QABPo=HH@=VBF$`AdOmcGXi5iy@&Z zatV@NQAEX9EG9|Bv~<6eI!jCUO9G19uc?w@l6`alO-Yxjzz?m0f`OmM3P4qXAHDFk zJj=&gnd(|2r8g?GZ=?UbbU%78?es0{wVf`WmTjjOLSOF&WuboyT$!B226`>ApNy~< zPfNjGCpJI?EH#bcmDk`jIy!5pgX5rvNM+cUpUPlEjXM^_(;0TzKoSmxi7mZIDGgU( z_G}TGkZkEG4VR)3=4#*%POr}go*pBSz_WQ+TkjOxnTa~!z10#$v}arUM<+3@;Y|?< z(mbU6v<5>yb_aoxp)up+ZjO&dI=b;fV-$J=5Xnn#NJr$Pd6jR?MK!~#ycdm%dX+~C z)J^j$Q|WNZyh_G^cBUI?aO-m;_o3YixsjeqZy;2p5BV{AqOUr=fu42jO|vaz!G07M z^$?eq-tZ@?2dy$==4iq6hR+j>tn`L2Bsz!->8hE+iYdeps9)8Ya<~0 zBqf>NAm&M=H;B2*N^e-bavD5DGd#$=R4ESMqPc>=M5~X}V@ircPRau9Im}rWOO)oI z&QD8Ai;!s!cB^=*!}k;#nmyy(lWKeKS;cBIPS}&`kpFBb$|;BZ1!`2>Az#6Chw%-P z--=DNahKi=@75csRD!3A#Ay9QX(!b9<!UxA(xwdGH)#;9LJA|3uaX@RUuB1)vG*o;8dG#cea z2DJ8|^oV^0>ZS#<%oMS`grm?pr!0`gcc*e}_IX4G-M-k?4xqo{@|L|3P^Eai8&65` zY8H(C)%O{x1F}*jG?g)DyNKWgQzZ^0;tCkVuQ%7;| zTX6Kir59ZkWiTugijfMQLS4)IxKzjpVf+fn0L+SOX62;DGVU9SgesPCFEuJ2%Xra} z3*I%<;8f(}chD#$@rN_Q(L5T45Gi1qH(_M+-nzVHUmcwM@&$S|t}~8J^y# z%)WsB^O6hbz1*Jv2|Wp`S3E7->Mex6-iygX|5EZP)X(c(SKL){;84(X_31}1dfvfH zHpZoILg=OE9qdA*B6$br=L1g@dT0D>>18C>tB<3ExIwC`w z`;nh}U`WVj35<+O8832M|9IrKY5xmjKi)V1p}ZV~bcBrSrZ#XA3rZ&Onsa4yYLz{6 z&g{0T5GMwhP6qCOVMbTU9bJaEcPAQQ&FtsfqjTwlmON6_zQ|%EIy)3krpq9=OFk0x zA4=b#CX-C{3oYe0#eJjJ#U<-V6zLJmFQ&@}^1H;fUh@v_$Et|)DC6DZqN{F;@~bPI z2JURSryJ0{rgSVGd#jDr;6+Zp@9k(Z$WKo5eN!3fl=;5wAkdC)?$h|yZvhN$eU9!X zv|AxZS0`~0D$>jS1U=DLoy0-UI%25TKWL89qOR-GayUM%deD|h%<3ehK+Bbwzwmb}X2_zuk% zln+`xO^+#g95c5DtrA^TTu&T{3n5O|gO(^>;Y(DGLLJdgZ~vC)xd~YLoT&mEFBN!YSG7ggkSQJPJixY(S`;!&02tN!n!F2Bbz+?#9@F@laLuiv?njz-i_+ze!G`k zujc*veLa%wYp^RLQOFioI$lAp%$o&KvLy@EO><=o3$uG^0H=5xk4|vTVAr_mOOjD} zI0ofD52uPDtdNHzd>MHV-!p(Jot(eJ6YmdCa3g8-b{-w#oIWsXOHWfA^XC%rv$ph> zbcnNkQK*uCc9F3|zN5O$ret;E6SGov7mGQ(3LGk zY*o;f`o{uLl`ZvkRJCU`9~HGhqgSL}7V)8$*;$}u-Ubc5ms=dy(UaJq5l>6m;*g%} za?_Gtzu<sI_`C&aDrc&H6dQc4OlV;EjP+~&u0ItKAQk;qNgq|ZA_dT$c9 zj4mK{NebG>pPinCjEwwby*85bE=+7TU*+45cSLRZCsykQLk21JzJswOhq^SvjGP@N zBAjBAqi-KAYm}J=h#5ei0dgw_wDJbXZvv_`Kpw_ZngNoSg|E_ipsR!BN(=sS%mLW$Z27b zFWhBJ@KB`q#gq1OhZ9~Z`G89_eTsco5(s7tj>e}orOOvrZ%&YS!cS zU@~B@EKj{&wQ$OBq%2P@Zqpl;*)M@=p5;mJrR90f7HxTor)687h0sT!!#0ZIZOZHl z7~?saLG)T8e_@2Ycv=ebCNs!j!FN^dM4zcfQ0vxRY%`yGSC3{f@xBzjKOgVQcZq94 z$Gu5!tsJCxAqsj@X;^`oqF#e zE{W20+#0@iNgt2!iE6jq#x=?n1?v#stV_h+`yswTU8>yaArT;`c0<43nVxTpTbXM} zjJ{3Y?x;8EaWH*1Y<0ulA#dUkACGP!?cqz!!LEAfG+OwwsT~BNx*e{^M`n6_lSH9{ zeh;IvhQcaQm?V(5h3jwv0jxpUnGz?(Sgw41nS6*X`}W&l((Ra3Mf5(cH&I}1aq(? z_=JROaL}#y#9t&D^KCQ+@LmTA;H^5w)Z<&~PIIB_EV!U}4d2(e%^u&`cB?_VR;jry zw^>6szM%A&TsA}zzor?&8{-pBHw@rK>LR|z2fJ;lbsMcp#F8MaD1c^h+fAoVQ@2%= z2xh0*H$|?@-v=m%YMS_Um@o{l3!K&cYKW7e!a1oa4^-{sI z+l;|J=AV26|4k=c@_uRARuNufb#SI>fSv-S)KahV!Bi z2!t6gY}C=&c<9Vw71ctocW?tg8$8*lM2j;TKm}JufkRI4ZJott=p3tf{(@J>fAH_R zdO)ndS)|}pR1VH@#IsFGPNg1HojS+>(w<%Q9N>fLlj{vrDM*Oghr2CwF#+sCKg8ro zF>nIh6IA`?Ja|CKg&ia)I^DTMHNQc;TMrz$7}p7r1eR&cxizfdMPT5$Ziqg1S5fP5 z#ceo#z2ekrBzJ+{alV}((~NiA`n;5BC-_>od8Bu!JI6OjX@cboPQ=e5e5{SI5;|>! z4#eQL11WG;2yqJ-$Xp_6&UeI0n@$5=p%~ESqc3Cl;@5=m_pX9!xy$ix!XMx1^7T|n zzGIh>7Q7fA9X?LQbSED*5-(14yb_d$cn@87749>;3IFf#?q@I1QT{)t54vw#+{ex6 zfB8AiXNVVj`fMSdis za66-LJR`rCkzd^9TWn?$!`@Q$!IDHD3|W?t%+U2D9qkfX53B>`Ys>}ph(ATuU5Ub| z_IM29xb9Un+7W{f@!t-6Sj@YVu+$r9VMw%U&?Tt@l~)bwb;&2tY3r|5<&R<>9_-zM z)hVvbtzeovU`XoFgPiUxcCeOpsg;W-E$xKkJb5cE0r*8oG@@g0$}(vwP4U1ooU`g$u;ov5)FD=%JzM2jn5hs8^id$=S;NaB=jUgrnroM8!i;c5m~}TEy5ZNzP*L`(rwKHo zse<4679H$OMFu;K@Uhax>Oh?Q;qREp=MQW6TTykW;j_(XVFuqx8NACkMJyn6!Y032 Xt#@mrgBD2FZLE>)q|6K%GMoN?WRN+@ literal 0 HcmV?d00001 diff --git a/api-doc/_build/doctrees/modules/amqp.doctree b/api-doc/_build/doctrees/modules/amqp.doctree new file mode 100644 index 0000000000000000000000000000000000000000..fc642b79eaa8ea4fd1c7445539863a56c6be4d4a GIT binary patch literal 3459 zcmbtX&u<&Y6_zZK5+#wAlqd)st00UvachulfgA!SEgA$!n;K@_z->;+Vz@ixjJdnB znVGezgMs!Czyju$>A%+&X!{owz4v=NyGx3Ob14A=J8#~;c|X4I&D%eB{<`Y#R6jRJ zR9sq_nsKfYZoE4rLB@0IzxO}=i+}0wyPjq*j4E}^z1x9CEM%H!p8K!8*l`Dj$5yJm z)fXMn6$fAY``GMQX;Z$jS&-Gbpb>&2<- zMXi5g&vk3Jrfxr#Irr0Y#@rFJR?Asw5e~V(Cldo#-9el(V<5zHCudoBI!wx9y_mr- z&F7?3x&zA=wB^M>+!4p(J+UY5x~G#r8m`U6Se6U^EWet3rSx+0xzY>%OpQKE`E#zV zkY>WNZ$~U)h2?rwTv?&=2`l6X0ZcNLlqs)Nim^5b?efvBa^`NELdbkIW=T@lqa*W# zuQoCmk}H0M(8LhgyNCae@qZux`xGWJrDYY|eYamQsgc%j-p50@RCsqBmZNGVx>M^} zDSjqK>nNw<61hZWx|SiXH5i)WuFwC3z2-tk8l2!?kiTV+zCZEDr&H`jt2Q~Ew6J&{`O#KFO*t52vuRN!Pg>f z04N@~x2uXC+(%k#v$?w?p%qTnrIyQ;KBY5i0TrmnZ(IoHf8?XgH0Xkl4aU~#OK zvT&8p<;uI=34jq?h;Z%_3P<&_)G1bdtKx_VLc4IKLqNOo?tBh2xw3p?^OfsUTgb~S zTFsTt{3|!0q7_lBGU_e{2Hy)3p7Kf(y^vN!4M}lc{X)&!sXNiUP})YsFr@RAI}$8y zmmPP;SHK9Ov!!X2I*DLLO z^wG#jJm0;!8F8(Zjs(k-l!ISgay7Qz-42=Gu+pilcz3zAvt>fObc0}Y?LhPD-J2U* zZ@N`AHFwcm0&*ixLeM=}xe|g=X#E(mYl=i4tA_HaLcw#ME_TmCq3)(jk)u z4WjD?th6dxi`*>N(OINk_zcm`n9Mqyi8QI$_P!Td{rpJ z!Rz+~hiJ(orXyxxuyY1k~KKx!`!8lHf2CkV!X85QYZv|p=5bBXRsjs6{a!Xaqc z6)|~E*3g@Pe)a-&3d={k?u^I=*yIbKFqN6K{_*JtZcy+d0!26|8dnKBA<2xvcjAS6 zS6Ew^hm#4!2K|Zp{1}%3=yXAvl>^X>EYDCLi*g)7KKjYeKSVwUdLD0?C&}9U`;B=p zml0lC*s$o z>u(mUGSQDE%1%DOY>*Hy8@=G`rX=VA`6zHUQ)!EVO7-n6VXNJ{VX@boTD^3B!#?_} zwjPAJ*tS*g;F?3%h*e3<#+?$YG(~n111^n&&uaPi$iR30OE3V#9k_&X%%JFWAjXb? zxia8OBW#?|SmtqBCe*(cbOjwHbnn(z6oIOojsFLQ??{XQ literal 0 HcmV?d00001 diff --git a/api-doc/_build/doctrees/modules/amqp.model.doctree b/api-doc/_build/doctrees/modules/amqp.model.doctree new file mode 100644 index 0000000000000000000000000000000000000000..b5663ac81f338a4110d7599ed571418aa42b9178 GIT binary patch literal 275457 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 literal 0 HcmV?d00001 diff --git a/api-doc/_build/doctrees/modules/amqp.rabbitmq.doctree b/api-doc/_build/doctrees/modules/amqp.rabbitmq.doctree new file mode 100644 index 0000000000000000000000000000000000000000..25753adff03ac7f9e27fba3c54b9db7181808ac4 GIT binary patch literal 96782 zcmeHw3%p!ad2ddVlgG)6BpeGo#G6A>Qz=(HdIzrUQk(7+34-tc0=1~wYRl9#d^hY z>vP*~YP9xmyR^}oaoon%i)+pSr`4%c+uMq>w{0z!i_MPH+S;7!R2ubd#b$LYDzI&q zaezf>PP7y)95{Iz z{-2KjXX1aJ>I;^&s;riIZ*j9&ZS}lyUhvCupiLFr^N!`=TZ6%sC6k?Av0HgjWvgPq zWaT8VxiY~;L^gRkGAi4>Gb1SwJSfcGRw&h~)Yje^Q6z=q4V^{^Rkc0?@$@c`0(&td zDVJvgl&jW*+zZjPx#tBL8HzCx%(-W)!~$$XCnTCa8rg^A|ecF1%a!d9QjHKv2yA%Px|(gV49OeJPkZmURYc}uR%%bG0**5ZKEBRb!Nv~Lh* zvP zdf_2LK~Eg0I=7eL#lwe|uZ3d0RB5y{2}tr6m&1AqPs7_(;NBPaP?gO$ttLEa;bA-p zhC9>n1AHgb@NP*1x*IY0P<7!7USr(NMe<_dvO^$y-WYYI#*_=o+6(k@ZwaTa=bdcV zL?BOCnkC+{>29sYdSm5DZ>-R1l&Bp#?Vfu+5%uJodl+0$sE9*+zoW8|s}Iop3nV?7 zUPO25=z}HcmC@j5IkoUitJth){P#|LWf8-V?YZr6m>5~xZ{@YSRrKF+Z>fl)43zsy zqK*wcgy+4*TiJB#WfGBtV7Xqxx|pnKuvV)=ofK5bi{P{0Tio47xxt=_ z5d|yUTiBe#z_2;Dl`}ffPSoPpQ8pXgtMSLynSAMS&q7QLJV};ji`9D1-A4gS5zv`y zLc&FhdMgkD$EsE>RjCV6gxia)I$oE9zd}G*+Y))4;XO3HF6Oeomr=kLq#}tBc#BKg|7hFQiv4!2ONfZt^a_ZuhQBckR9S^1{W}-Y~g0m$&yl z!>!2qqjC(7c4SIA5iB@3TJmdF*(mzQoU{lMjJQ(NEdUa9Pq~^qI=vR-OuU5NYG!3b=3a(|W&gxcY`6hH=m8Zl7Z#=Ll8ykP3?QyWRKu z)s1rVE58x4$8fyeUqvFOf{$fh61gqSZoSm$hK4gE7jpMt+{2q{px?2U>Wwr*j*9zH zO5zutSg${^mSC?Jh&@LmmTIeO{`fvGOt4=M)b3scb3Nwn zz^jz91mA{q;>#$d%0PBe#To8;FnhM#S5~IuA&t_%A~$a-j3zTm?!VDb=I`sj>y51( zw1au7H{|PT8N8JMx;YrEmExoPy%sTqd(rkIt*JL;n2bj`QF(2r(}6qCyPp_#kcrF& zt{0_F>{sW%@{+5sFYMfX*`7hP{fo0{ds*ZFdj5Dr&#NpA4Zke#1%8kUP)cL{LN0Ss zWU^@WHGW#}{fDhqS4=SV`KhnlbZ~3gDVDd^AY;I>or9%Hu|DH$0w{FJ)vwwF2#c{a zQ7@k9Ga`e&KMjexQ|`yKo=*B)_^biVex5ad_YaYUX;P$W=cQB3C`5Zlmu9kO7 z>^;9Zt6~PKRB4pqgJ;yrvcv(jvN0lkU$GXuh7%2c6fQD5U>KlcMZ%Ocf!B&_DX4~cAGfOKa8{kiX9 zaR*2L+)wsH>EoFx4JsHDn|4oRT44j864-N<)VU85jjUPSlMqF=Y=U5W+!_IBtj%!M?!JAidL zH=EB-r43+N%=Tu)*BXtcocmM=g?*m0*q*DGGR$+nMRrkdlqHpxN&He~>G(z5k&z-2 zG)t9tnZ7B_X}ar?2yjQDV|s=?^JpxEXC4$)Q(ckcLYTrDzX0!758F`;mmzKxmD8}8 z2Xo|(|4^;6-LF@a^~ziEI>i(BrId|njTe*rad}X-R|`}oR|_1+LMBS4NW9KUV)VR~ zdo>cJHL#bbh#O_LBJ2M=nyvMQj%V#0YqAuzyrq@gyJKL$uuawhBDeVQ&;oC4y6V)*d|FY>$;wXNlB%?5x_Tq&yFzn!VxAK~@> z5dPSDs6GS6=h!0VyExWJKy1JTd||QLC^W14ixb7E(nJiG*!)==tCp(M)e=^U>62zm zX7x!kYA`lGw!wWQfpCh-rk^&rA4n1PVa^T`gQQ8VxALg>rO5ToJnEb1k2ZB`7+pgm z1wbsjm=t5BDVQ_oej1r#0-6n@qntVV&Yihu=#4pZ?CsDwa~G9rPO;u?4&cw7pUs~W z1rFfSonYuhzY45>=PSy>V_h$+o%Fr@->Qp_F187R-Oi8rX}yOJTi?fLf$4=TgdJgO zJ8qe<9BX5ViL0vWuBTc*-y_lEqT9R|YtSDR+o983*R`A( zERk|rSZh4h=+?^xw)U$%fF|3OO_RkC5Ubg|j~%v3BDN}QLBD0$#4C(`8Iw_-wM}8R z*lc1pa!amMtkq~k#bGlDpMqFh{DJ5}_-m0U%^f6#SHczKqA{vLRxr2)8E13YH0d0*-1^xjSrX^_hTx0AM1zSk7lOV-an$iiOA-C z9>Iw-(`n3j&qh@s6|Ay_^dQRh#cMGQgTd|l^z&E@vt=_@X)AkrG&!!zsEPZ<-w^QVV9H<Q1HG&XrmYh}z7u;Hl`7 z%xp_;3Tuhz<1EU-&ajHp%5`bi8ikEPu{sC0)~fq?y(t*$WU&vWjZHzhnd$+jPJ7s> z0<2yWV>_qeVIe?NYY#T8R7(!=i5TG2DGMZ}dD?b&mVQmQ8nZfi#QAC+Jf)A=S=lbm zIBmHP|IfMmXW(%J~neo&t#OwM;!q8bhjdJ_cLh5``rJ5r%SfXeG+e#Cp84q z=het&3#;ON4h`X4kx&_mDiBVRx0DFyvn*;nizrutaLO*`OER`*+bI`Vfi$`C3G?nn zsGSYzr0*OrsL~t53)tHLc!B7U{qHcp$-BWHS(J;NBKG7qYjXwZybb^yT-hgZ5J5#O zdcd8%ie)VR(l|#eqL_TES@LTxb=4uC3V$<%MOR9Ophu6w--twMM&Uhs=Fy{Yo_Tz~ zks~OY3cu4Y!27+!AL)q@3bu0{tW-nsjkXRWb-z85G72B^`ICK6u6XM{O4*o$@|C(g zbHda>JmRAohev!I_kw|{3V&>^Ld+=qzavrFQTQiP#Elx&M)K!*9MztcLHEQDZB;Eo zL)$qpX4pg9Zy`@UwEaHb!b4lTV9W9C)(lnG2Dws6=h%d^LUgTFlyEC9z=e~lnF`WTz)tqtyv_NJ2wZQQDx*M$|#u)qENR-yt zPo{_)W$YvC|2!J|oMG|85)eBruSgGB_%-0hur2)SktetCcjGN=;Uh#;n)TC?Dyi9W zDTT1*>rhUtEf3(;-pzZQPOjTzaH}kg0OmSBJ8x`zi!HF*p2ML`IPneBrqxakGpIOn z3^*{`YX`8o0d$oPoC7L*pxCMwr)oIYO(040Sc2-wo~W^OK8!(|v6M<+fomxd#{%#7 zIc85Od>zSPz!N-^5U!Ez?|cwNa)0O7>5ch2>}>#lM^V$~0eClgyV^LsqaZNy0o^=IG4W!A=mI(Vayuysd1d(fbO`>iw?kJok%XIf5-ZKv6OpRVmbfgp*9 z4>@DG{DDTbyqVJDl+M{IJ7z;qC1uE;o5w-`_-*jza@?;26*&19ejV%5dCbr~bQtqa zn-4n&@}{Ho*qX719qFtNIn^gQmr1ru^|?fxl%h1z%ZwcDj^Ilv_6C>8fSJP~p{zYE z1iIT1Rn9ScOL)smYH<8;pGuN4+G01Octh4F&o^sCsdPqg;*Xz(w4Mz zL2LlKGexdqd4%j>ezyz32s&`9&9z8>C_Z7{{WR#XEsvn@9Dn#ey)pcOy$ymtaGf*A z@`%e?4we+QaacK>4nD|Eij1c?2Fs1bAh=&`TLN*4^t#00KA15aT+%A}${}CqFt#kH zc8vZWJ+5DZL}|wLC)hKO9@q2CgNa>Qh(MY=6 z8PxywUB`F%X}u2~wwS!m2vgau)R`zOvYMxr=m7Ko6`mOg#-ZdP4B;W4Em7(@2F-i` ziEM*2Y4z9!DHd1TAjOdbgHA0FGs*_G@K`@Iel#Ujt7JIL$Q{J{xHByy zfPnlEw@Uo0C|g>fpi0t(hz3If33!GQ`De65zyJ(2!tDx9C;H?Wb|nIBB`V+!f>{kV zjM`=)6o~zU56(^2bTR3FEsM9GhaXj zIYw7})B&IZ_YCB%0|H-1Lx%wYpEChKz+_CkIwDCDC&DaEs0>9NB`$4n7qY1C68w>{ zQIxcdvE6psUYww;SQYgiDk=5xFhWkQWpssh+EB2b*C29IG4hIUeBzgo6Nk|iA61tV z_X0$YxjGp4k$Mi|ZSw;tR{=+n%1a4H zeV0W|*3p4evxM#ngee8~2+^BbFol->041_%=>Wp+EyE_+-Gl%!-z-X8e+wI@WY;sI zL;O{GMfayN(ftwHn6<(EBof(LWdOnTP7Gn8eyx+``SAq8NL++odn`p%Az9Q+nIy|D z+HxNlgfP9th(%V?5s}V7u%tZK5|;B~NQ>~{=(F_3hNJ9l;NfVH64PRH^7(~KVcPSR zD=Rx3?ch~$VNmdn3wE;i;xSo)QF>z)U~m0Y02jov+ZHMvoQZ#cE@i#4QloL!tc#I;Qcm9$=`n$+}s zMwee!47syxB)rDX%sfsT;EhxuuV9N@^{@peE0n9$c*PnHWtwhWIN7K>5+zZX`<2%F zME%VBI%{{ipIibkT8J`77ozzrN--LLe<`(jiZgewvS%KRzw^xFwVOmDXrtlzegWQ} z4G#gDN7+m4og5RFuq@Ltq66V#)2^G@TeBA0YGzvS)SDvW+X~0Iv#=u>oT4T5c z%7$0P#{}KeDUi=CB&j?lpY;TSY`29e>Cg#McLC5vE$O>&2%lRWOwPNR!s#MEk9%gY zs_L7pRgJ;z-hf0l&rmiH;dZZMaW&k|Us7N|cfs(;C6f>JL+k^C5PNKtP8E%!xW2}S zC6!+&T=D&}eyZ|O&dV*{TK|@{MiX~Ob^_Ol#$CkoX={<*NF#j3+7pyygDc9#qlAmnT_nteIv8y$6VfOSC#%%u1uN50+yT$ zmau!~7-bxuU9JkE~!PWSF|nz zF}kA>7)^WQ+NG>Ue(v?!G1cxm%7z<}<$grXfE{ZT69jwm?rZ2E=#=-d9)rAWx;5DT zfid{WNSft7R<{niT-IO>dZU(dn?$QtOBzgz8(5DXZwK;6qLDP*7t0CHrsjoXfmEaP z%B41N1kuZUvB=?;=r%2l#=%=otJP?=<(XdO*5}laD<{TWzW+2(9!lrFM35*4;6Y(D zhwQwHN0B2NY@~Tzy?J#eP75^f3QA-}14n?_NLQRA>-j{q{a8opLpCUkpQAB7L7~>n zU?om7nJOu;_!1ID%-K+ItU4Bx2!Z9EmN}c(8+qBqTww8YjIQ{ox;o8xxW9WR^476S zrdR2VE2dX{HM+s|nG=BHP2R-&DwLIgH*Za-4@DKzHv3rAL_u2RFBMj&s0C+kQuyf~ zL0Nh`$1|J=6f*NDBQP|7L&17p0TZ54W}YzevePAG=8qU%@lkb|aeoDoGtA$78qrh9 zjL)2a%$U4MB{PpC)F->ln7|XZ6;(@}TOdGNay#pD`ve9R6r<4CNNA!^xKc&`2Fi6& zh;I{3te#=j4T%*6>v<)L)nclXKh9x46lJ3;gSpu$6N0r6iL9R9@|H6#7TVYa%Ugu| zj(bcHJH-~x9qoB5fDK|#$OI!am56ah1((~8+#+j?H&xwJ`l+tSKYag7utVWvPl=wyDIkPeu}+uc--BHtaR>r zV?u<9%)YrivQJhQZ>qAbek#j(3{?_P!W61&l2l6gyG$$D)kMH>+jAB3=&w$ZtC;O1 zH#BMZBer#1nj%**+bM@fa_rIP^x92cL0t@K-lJ;=OA@ed+MLR7+1;B3>`2JfzcANW z^%`P_W!C3L8Xl_Ap*bPv7t!DJj}M4@>S|tLa8-cn9-p#y5BmbyKk(CfpF0|+M|{r9 zO$>)Emj9H``KWo67%cy~{tscHXf3#jAoAz)1vCrAd`l?x0GEC1&h__#10kg-A zg6WmcasMaD)nEZZUpO(|7*{9zWVJ|QgsKVEG*XeF-7Kmq7|RoPRCek{638 z8zR?UZ%)YrZ6&sBIUsnC3*``b>P5s#?Bqp$`T_OA@aaLy^zE~D024kHpx&z~(Gdjd z9n4fo0nl`iC<4@@VBP;s97$V7c)w)iWoT04Ff%cZehZ^3KB^ATWCitp8F}kt59$tV zA+`zX`OFE74NTs|Yc@hG1gLjgLVYxVrp}^1KcL>HP?p}#@eJ3{mp@N!^3kXTW0Cb6=DddFp=ObFI`B(k~F83Zc?h{R%gv091qDFCp!r;=^uli2}K zZ(Bdr6$K0c>b;_$Vs{LW%P(g0-9TCea_a6x-l@881arMuQ17OGs+pF%@t|I%pJJWi zaW^ExaiCr%5$cODHf{)jT(-KQ;a4lGl3*;WRM!t3!_zaH$ZpL&>E85k|@CJf4P3SQq}>z>H5 z8b8AYcgxj^ZMKFb3t+mr=Utv9el)L0oxbItCnzAQ8vZ`dG7_5ULvQ?tZ|gcZcHH4 zwroC{Oa--{5Z7TDjd=}|UKNPRtDu%@M}5V;zri%BO6OXu6a%SGAdzhhAUg^zOnwoI ztC7FlS4E;`igxRD30L+*>7}gnR3P-Ltod6(Xi-Xf5PI5PRv#cVCm~sPsV1?hB(;l0mR{>NSb|#IBO@iM4Yu9TOuy2NKz%%haV-D9s)<= zkTg&bi^HFwhUJUH-$kzxi^F@um6o?)lf{i#2+j}ZrR%S|^=b*n^|o`31BfY)!E z>miZLNevH9=wTyNN!5=sRaZ=a{Sb*FCcr2-)^@qZ~VDg#cd1XpWB>a86D`l0r`MTg0l)FQv#;;J?xaNfX>R&^Wd0 zRTp2rbMmrXg~^@Q>>9?xPT^S;IS^!!EpBl?>CKlGUwx%4s`Q2l+TF5Hh{Os?|3 zP%7h*3$@|nlh*v*KSUOxC4e90V|`vqC9w)$wiZ#bRRK0BHA9uK5@EXGidTjbFe7AH ziK+Vu%7C@3O6oq0!1=*17*fHuyL%aWG)FrA160|eR?q0vVj-RTEK5ID;8=ebS?K4YcFDIYw21!wY7}i*ePA?t)Hnau2IDlUH=wl@3mL$ znk?+uwfn{^ERJ63-X@jnv-NKyYr#%`hOprrj zUPW1$b(=bb%4`*Y%hm(uq&6n!`FzS?OwL9k;G=1b$t$h-Ta5`XCE1ufqA#ze;vY3o_`f0t-ANhllAlJ+>$=Xc>;P+!NKH_sJgTZ(diBcMj zPg?W08Vp`avcdR_wTKvlAu=ELB3P&7k78xF7fSNn-=GXkd+{~|&bz%x-$S{%_$LsR zU@n5aR9cH~BcZewvbwMqZ>O3MVl89_vhN3NwYXTvKFW9&G;nM2BYI=jg1sF&YcX}% z?rU$jZl2A>@NldEwFB4->!{Z##4s4E!k=lB5e!vbcI~=gm(5}_R{3dawjn{&z1hZjuRcSX0NGa`xtT61x7}b3cyCE|ez-}}^1GgJZdSiBj zy&XEcQQEs}a_8jUc{Ut34Q-qeBzFMI@gmzu!z{%x9jhb0!*-a#s^{J>gip#&7UOY` zpVs^9BY(VMa?Tuatlz{}3H4(>-s^KJgZX$j5~VaBziG|iYCd==$>!tttwqF`50Uw} z7s)&&g%mHl{ZR7fK0q0m_Tw%D&b$4{(p$L!`8$x6U_i|NDlN#DkW^X_S!Gy|H&X2f zu^=)7sRjBNd3+l*a0~JsdSe!Zy&XCWGIQOo-Pc^PXU`Sa&i5q8Ekm;+VUh>1B({x0 z6Hz4@)?{5w99Wd7PpUtUtPl3*ELP|Gt;=cF{H@l7my&E<&bAg|tpbEGmVrtliID6TM#-YPhB7cM%#R?e^KN0X_F`^j zCP8n4m5J)Z($ZXu9O!SaeQE&JJxQ24A?DW+q)`Fo2~gfHZDtZlyP7Y1rGL zvow|6yY^gn?c|7_N2m4`KI5g!H__s9$eutr}34cr=inckQ+VsD4e8og$? z=fR3)!~S8g*ALACNje8GJ1@6^WitQ70}L{r`1%7OcT#M!*qiVBX}u?pe0w7~96s*# z5bZ%mGDbO8PzM zJM3lku?L-#kZc)Mli1@%?Lk*v(fv8~N@h_H)gE;3^fa0*{uESI8SaKDcDUa`<>uQn za7z#YZtVBtEy37_k3c;$P3^VwPi2FlM}ALe)W|WZvEhB;Z=1@RO!<0kYtPVqJ@_|rNAA&P7|=*f!3Q+byl&0CFB8AT*4%q2(a^W% zo*&rb8L>4tw{>d{J3oV4c=;xp;Po%Y&fKK^x*yEM1F>Q9*N`Y;zb*yqW0k;J4@29p z`};;IhSiQf%J%md#qm+~?UK*ueqGXk{McJ#zpl^Xz~)Jl!+<+RbKkh@9r})`h&XG* zlB2Ya8DAL#+OHC+bvC%~P2eXfD6t{)K^8S}5AX$Xdw@yu*^Xd#mRPRSpyL>F`3AdA zy;#e>NB9RINEg$1si0a2k^erc1^B%%m)EwBQLvs@qR2<=1QuO1;)`meCF8+z>@=_yoq9~2ULcGr&`EY?=&66hKZdf*gTbFaIj4&o3Wt*?4 z-DLJdD2wg6da1udC|Odu<#?3;QYz?xU7trELfK;aJQAst?;d3zRh{lCNZe!<6W!ro? z&^B6ThYYB&4%Ic@22WNaze^mbr+5>BDk|XB(4mTVesOLA`^PRNR6En%PoXr9S^PQP z5--f0Fu(MTt=X0WR(w(q7S>kv&mlC0;fH_Yp z=JbOXtk~^zx~+N+w<0>SlLx{SrC-lPsXz>#rbHWEK`?wc_x-rMSRPCv#>Ih4&(%dz z5#tFs!~DA<>pxPHrMvuD$GN;z{pcU+36Z1M|AP;a=_09o^*JT&gwN&ipvSlS6Za8Ikcm@LwMJKCq}^lKcBY8z3&4@^JBd zFNd7#h>4->qdnhCkO<O+)u`P3QKPQ3!W#AHZ9J zb1MWw`n9Q)k928eqoXTbNbR4}r9Js#lE^r3)^|~pqA3~vHBopbmvaXt;x6ZV74h@z zaz2)cQsHubj1p~h1;O*-a(*T?S;KWXNj@W8&OgJ4lrHBJDWVFOlNg!g4vKRhe=9|< z!sV3G<2O-Sms9qc_=I`)??8vm<)rW2<@_nVF_)9Q4dQZgNgKrFytP!U)e7QJr}^=a2`%jKDm>nK+ToG&p^b1DFg$RrQG2&CcC$%nCiZavN65A z4e??vhAUr{16XgVh|Aqlb$3fJd|bs-RoHE2hC@2#zai7t<#>3gAB!rElzq(mNTYsa7Pu&6>Y;MWQGr z{ffl**~{u&z4%z6(if#w=O)S)}Dij(7twamW`ylAgQ3xLd zeGYF4gP@?glw%?525+4U+Ui898KFm33qee?I`OQF;UDCR!Xd~JrXROL(H|dWN~8Mv z7X?`{mfcu!C2k5i3Qm>N8;mVlM-zQPHBorrmv_AovY&Tod9i&Rj0&rMXUvf_2m}VqPV1nX|VDRh71ny{nelVB}>Wmy)N2;rS%LJ|^Q3Lcj5&KP;cOC&K<2ydCu6(3a>UUwTJr(a0uRuMgw@cPUN2(QVT zDB+EWvp%YwRTno?q>|3761bFIIyaLCp37fSEp={zKH8GQedPO?0v6=sdv})ZXo-?h ztN;E!5Ua~neB%{o`zdw;@=)ZuS%GH*iSXnau>Z(3h^R(SH+H=80-=8f~jfQg-B$x zZiC41n2=#2vtKT|9ZiJyX|+AMpW1RJLze{9Ifd$~Bubq}#5pFU4^>;3(NpR22NEPb zq|5EOiq+mfO5wkVi3jrJQ%*d5le;>JLyx6=os&QA@P8{_y(&{nib2N>l*l^h2rO<| zwOg()D;GOO*@28uMN%~rNn%maG!ogm5;dP-G*LffMlac2thTY1Mr`bmKUJOHoT*NN z&2OSa>Djz9a&BSQ!IHx^&d@0CifJ~ZDo1xMwhXR~HGny%)oSqJPd>_+uOC(G*SwSM z1xYR>MN`~)UncGd*W@AAjPZIlz4G)HVKrngV4EIB=Bc#i1B{9&rA1#1#db;({}oHj z)OKwnIzcaiC0ZvS*&1>u2&|wKJs}XLYWI}EoA_2Fl0|p;8%mVEJFE^m(M&2MW&5{u zw8rYFK9h;;k04**N8e?fj;~>QIdzBNsD6u4Lq=G4Nhws9)d&@UBnB$7d_yqNP^xHp ziM-HMUD2;v&>>7wH#Z;x%(D~nYj}C5rLHo`tq_1ykjQ451`&YFUY^gS5#66Nd6Y`q zd?P`yHEly(HPT4X;GpqZ8#hm?6QQh@097?BI(jZbiHD#T4vq zfW;JI-9W!FesU2W3#W|6Fh&WU(SW2F8=CIiec86V$ zM6aBfV|pZcN$gwgnMbdj;F-twAUXL>OJciz0Y}5h-a$c;M-{2H6RXV#eD#DGtel&N zefDHuKcQIb{u*UtuAdlXa?Cw!wNgS4RkQheC{7LFDHWNITgi-BBk{XPWV2;bOlX?> zw^PK8n&yt=!6BRGwodRGq7ggMt*R87=x%~b^FGo24=99Bbbk|X2@~C>WXq}UEg979 z<{qp++tMb*7y{8k+2m!Wnd~0FQP{LxF?Z!ndoeSE8zB8@?U=7hxStV4Nh=@ko069z zCa{l!YYGg36l<5is~A7OQ`jRfNIN7Twu^Dy&xpG8^PS#(H_5!d) zf<8Ph6YT)DYFzQ&*XEn-GAf8Ow*losa;;K~%|13P4mQk5Z}k_b1d# zQ}5JuGie(;0Rp0uo|p7P?TG|LCH>^+M0wr=Ef5v;P!3U@vJr1=zYlvmbP!b;Crh;E z3SG=R6{hA2)$;s+R5uT8r@2Y*05H}0wsDhLPM)!-T0U%`svQs^UGEx7A{wf?0EyCU z^10HUc{EhTGmq~{5`!S9>O8*y?+Zu%;Q*$vgu$v~!cjO}75<c+Hn8ZR? zs!}27Y8&`8@6gplD1<{-AH-V%bQP9z30_&RNiw;i?bVP%4P9~$%1;YlopwFhJ36=d|l0}0R-mqfu?zGjr*L0D6MF%!)K()t@Dih#5zSoZ@WmI$PVw7zHLWfx)r zX?>f~6(4mFNb4EotwUO*Y9b*mpE&_Y%j8WIq!kfoscc=NscGI^9rx!;;l zFHPG}*UhAD>;wo1OL|z+9VY;XX6Xkgiv_M$YLpg-?G%Cd*EcSNjAgq~M zwcTL|R=ZHG7iO>%wmCm2*6=Rzj39XcAnT=MV&g9Hj3_G4cm%NTumQ7v0%6j{(oh%C zVAiv&TP3f%T7I%M^Jp-OXCCYx`VAa9nDy^I^+&^Hq!9uW#jfrY4lag)1TE+*3YZ)KLJr$rxKF>;W46=1L64~5QDM7R(YfFl_QOH&# zKMonP#em!ldMN%BMpds6xb-jSZ1WCoy&CPo!L2F0C4gIz@-Fc$>sr`|PNYFxQoBcTr`FGLD9_j)Gg5BU(eAH8LYu0{+i0 zn)QZEyca{m*HfbOL&FVHNh&z&GIE+?@GPYe1)!w@l+5%p(Jc_Iw;@pkqD8^F{0)L= zeaOhma4Za27Kqk=V|2ww)yJ$^7ioPMdFzN4>6b`E%V$mi(K2}xg=j^@S>`veYBDog zystw;8G*6mQMoEX6*$>q;n==tF5REgD$mZDT>cRaZG)^Co7Nawjo;ZzBV?tUKs&|7Z9U9nNXWd_U zg^`bNfcs1yQQwi9E`6a$WerbBsH|oUN#kWw(slv_1}Oc~OcL6_#df_pxm`%PSiy zi@4UVoCR!Sq1DPPX*as95-x{0%R9EyD%RUIwnV(pY&B+Zaa6l^M=wvi%R0qc@2Umf zn2h6;@v{rjtc-Z8OWjrrr&bk2UXwU{ScKH7b*DG!EyLYZbg*E%=dCR_N;qV&)}EMd zHR>IwUd8|(+kv_`VB;M1Zm)JK1tv47 z49XJ;NQhX#%9hh?v^s^FbHD*R7kXorV$J_K>aBGSR>8$ivD0nKNTc3p*_rCjAiveO z7h8335iwd$aTX!V(Htd*s3!WVb?~g<)Ju&rV&TY(ZfAPy1zX!yyl)JCEU*(n3b-V! zTyt7z0U{M=czJ6$=e1l$SuQ>AB;$*bg}XS19FqQ>WA&sqiu|^rLVIfS|sr6M*v+Z=tjl#iM5~yRG zgH7CHfe8bZl1WLaQ#ep9yLxe83Bk{=s2@z zo(`I08N#=oarSxO=jzsU$;h5URQ6}e?CFFc650JuYoh9Ordb(K2-_;1*%}I4-YHI@ z7nM7e-c`%IlOU6`1;2Cp6)3cuBq8^E$KX28PVr!&Qk|*P@E`KKxYi)iU)i25qNCl` zMXzpyQR~@n{S++T2Ji`818 zST2*^WmK=FoT`aq3_tphM>0nG2jNGREA4^E3mYMRe?0{+6SFBu#Kh>gp{Mdp8`+Dvs{3&+5 zrIdn4biYJ~@F_gn-f{}2>-Q)J_Tm0^B?n8wzQf$@sQg0ZO8mdM@&@-FoE+!Ag&t!I z@mNETH`3!?dW_+i6?Y9ieoBv##dz$c$E)cvhl7jUJL$1z2_ED0_&7a2Nss52;<0cU z9 z+YP1CEViJYAf0XWBPuXofqiMuwV{J#uP&^pUWA>?+U~7m0vOE`TYkqRz!yVG62ezecoovVWQ9HO$K!yD;!i zA`VH>IH4GJ+<_w7Q}NV^=_2=aRG$qlQAh}iZA{^f`tHhNcBQ7b^roG=C$E^ijI=HJ zcW`8s8%d*;3dm@V072+-Pb}$WwqVMp>HHNMimR(38)}W4~qhK zd@*?Kt@Aw#DalO0lQ_hghLPs>%b{FJqW9;xzR#V;hXPvzTVzhlRogi@wmIK)mM6qH zk7)c)pxQQB(Kz(+v>Y0d99n$EJ!t8Bu!mAJ; zd;PzVzW#rewf^pBk-`^`N_&vn-<-1cY=!V_u?}@f!x4G+QYv0Nlb#pf9gG+5IWV~q l>~Opley3nA&5CNhRO^<>g_9 literal 0 HcmV?d00001 diff --git a/api-doc/_build/doctrees/modules/amqp.router.doctree b/api-doc/_build/doctrees/modules/amqp.router.doctree new file mode 100644 index 0000000000000000000000000000000000000000..e3e79f290c7e4afdced0b03d8e431a63085dbe1d GIT binary patch literal 153515 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 literal 0 HcmV?d00001 diff --git a/api-doc/_build/doctrees/modules/amqp.service.doctree b/api-doc/_build/doctrees/modules/amqp.service.doctree new file mode 100644 index 0000000000000000000000000000000000000000..13a13f44c0c29be387c1d9d3ddba9f6230f2ceee GIT binary patch literal 231970 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 + + + + + amqp.adapter.amq_route_factory — AMQ Adapter Python 1.0 documentation + + + + + + + + + + + + + + + +