diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/.gitignore b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/.gitignore new file mode 100644 index 000000000..77ea523d3 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/.gitignore @@ -0,0 +1,3 @@ +__pycache__/ +*.pyc +.ipynb_checkpoints/ diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile new file mode 100644 index 000000000..7c975b98b --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile @@ -0,0 +1,25 @@ +FROM python:3.11-slim + +ENV DEBIAN_FRONTEND=noninteractive + +RUN apt-get update && apt-get install -y \ + default-jdk \ + curl \ + vim \ + && rm -rf /var/lib/apt/lists/* + +ENV JAVA_HOME=/usr/lib/jvm/default-java +ENV PATH="${JAVA_HOME}/bin:${PATH}" + +RUN pip install --upgrade pip +RUN pip install jupyterlab jupyterlab_vim + +COPY requirements.txt /install/requirements.txt +RUN pip install --no-cache-dir -r /install/requirements.txt + +WORKDIR /app +COPY . /app + +EXPOSE 8888 + +CMD ["jupyter", "lab", "--ip=0.0.0.0", "--port=8888", "--no-browser", "--allow-root", "--NotebookApp.token=''", "--NotebookApp.password=''"] diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile.python_slim b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile.python_slim new file mode 100644 index 000000000..cc8f18f2f --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile.python_slim @@ -0,0 +1,28 @@ +# Use Python 3.12 slim (already has Python and pip). +FROM python:3.12-slim + +# Avoid interactive prompts during apt operations. +ENV DEBIAN_FRONTEND=noninteractive + +# Install CA certificates (needed for HTTPS). +RUN apt-get update && apt-get install -y \ + ca-certificates \ + && rm -rf /var/lib/apt/lists/* + +# Install project specific packages. +RUN mkdir -p /install +COPY requirements.txt /install/requirements.txt +RUN pip install --upgrade pip && \ + pip install --no-cache-dir jupyterlab jupyterlab_vim jupytext -r /install/requirements.txt + +# Config. +COPY etc_sudoers /install/ +COPY etc_sudoers /etc/sudoers +COPY bashrc /root/.bashrc + +# Report package versions. +COPY version.sh /install/ +RUN /install/version.sh 2>&1 | tee version.log + +# Jupyter. +EXPOSE 8888 diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile.ubuntu b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile.ubuntu new file mode 100644 index 000000000..705105d91 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile.ubuntu @@ -0,0 +1,40 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND noninteractive + +# Install system utilities and Python in a single layer. +RUN apt-get update && \ + apt-get upgrade -y && \ + apt-get install -y --no-install-recommends \ + sudo \ + curl \ + git \ + build-essential \ + python3 \ + python3-pip \ + python3-dev \ + python3-venv \ + && rm -rf /var/lib/apt/lists/* + +# Create virtual environment. +RUN python3 -m venv /opt/venv + +# Make the venv the default Python. +ENV PATH="/opt/venv/bin:$PATH" + +# Install project specific packages. +RUN mkdir /install +COPY requirements.txt /install/requirements.txt +RUN pip install --upgrade pip && \ + pip install --no-cache-dir jupyterlab jupyterlab_vim jupytext -r /install/requirements.txt + +# Config. +COPY etc_sudoers /install/ +COPY etc_sudoers /etc/sudoers +COPY bashrc /root/.bashrc + +# Report package versions. +COPY version.sh /install/ +RUN /install/version.sh 2>&1 | tee version.log + +# Jupyter. +EXPOSE 8888 diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile.uv b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile.uv new file mode 100644 index 000000000..d3b2a0abc --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/Dockerfile.uv @@ -0,0 +1,49 @@ +FROM ubuntu:24.04 +ENV DEBIAN_FRONTEND noninteractive + +# Install system utilities and Python in a single layer. +RUN apt-get update && \ + apt-get upgrade -y && \ + apt-get install -y --no-install-recommends \ + sudo \ + curl \ + git \ + build-essential \ + python3 \ + python3-pip \ + python3-dev \ + python3-venv \ + libgomp1 \ + g++ \ + && rm -rf /var/lib/apt/lists/* + +# Install uv for package management. +RUN curl -LsSf https://astral.sh/uv/install.sh | sh +ENV PATH="/root/.local/bin:$PATH" + +# Install project specific packages using uv. +COPY pyproject.toml uv.lock /app/ +WORKDIR /app +RUN uv sync +ENV PATH="/app/.venv/bin:$PATH" + +# Install Jupyter. +RUN pip install --upgrade pip && \ + pip install --no-cache-dir jupyterlab jupyterlab_vim jupytext + +# Copy project files. +COPY . /app + +RUN mkdir /install + +# Config. +COPY etc_sudoers /install/ +COPY etc_sudoers /etc/sudoers +COPY bashrc /root/.bashrc + +# Report package versions. +COPY version.sh /install/ +RUN /install/version.sh 2>&1 | tee version.log + +# Jupyter. +EXPOSE 8888 diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/README.md b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/README.md new file mode 100644 index 000000000..d6c4916ab --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/README.md @@ -0,0 +1,218 @@ +# Real-Time Stock Market Pipeline using Apache Kafka and Spark Structured Streaming + +## Author +- **Name**: Aashish Vinod +- **Course**: DATA605 Spring 2026 +- **GitHub Issue**: [#461](https://github.com/gpsaggese/gpsaggese.github.io/issues/461) +- **PR**: [#478](https://github.com/gpsaggese/gpsaggese.github.io/pull/478) + +--- + +## Project Overview + +This project builds a **real-time stock market data pipeline** that demonstrates how +Apache Kafka and Apache Spark Structured Streaming can be used together to ingest, +process, and analyze streaming financial data. + +A Kafka producer simulates live stock price events for 5 major stocks (AAPL, GOOGL, +MSFT, AMZN, TSLA) and publishes them to a Kafka topic. A Spark Structured Streaming +consumer reads from the topic, computes windowed aggregations such as moving averages, +and generates price alerts when stocks move beyond a threshold. Everything runs +fully locally inside Docker containers. + +--- + +## Architecture + +``` +Stock Price Simulator (Python) + | + v + Kafka Producer + (kafka-python) + | + v + Kafka Topic: stock-prices + (3 partitions, replication factor 1) + | + v +Spark Structured Streaming Consumer +(PySpark 3.5.1 + spark-sql-kafka connector) + | + v + Windowed Aggregations + - Moving Average (MA5, MA10) + - Price Alerts (threshold: 1.0%) + - Throughput Analysis + | + v + Results + Visualizations + (matplotlib, seaborn) +``` + +--- + +## Project Structure + +``` +UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/ +├── Dockerfile # Docker image: Python 3.11 + Java + PySpark + Jupyter +├── docker-compose.yml # Multi-container: Zookeeper + Kafka + Jupyter +├── requirements.txt # Python dependencies with pinned versions +├── kafka_spark_utils.py # Core utility functions for the pipeline +├── kafka_spark.API.ipynb # API reference notebook (how each component works) +├── kafka_spark.example.ipynb # Full end-to-end pipeline demo notebook +└── README.md # This file +``` + +--- + +## Key Concepts + +### Apache Kafka +Apache Kafka is a distributed event streaming platform. In this project: +- **Producer**: Simulates stock price events and publishes to the `stock-prices` topic +- **Topic**: `stock-prices` with 3 partitions for parallel processing +- **Consumer**: Reads events from the topic for downstream processing +- **Broker**: Runs inside Docker via `confluentinc/cp-kafka:7.4.0` +- **Zookeeper**: Manages Kafka broker metadata + +### Apache Spark Structured Streaming +Spark Structured Streaming is a scalable, fault-tolerant stream processing engine. In this project: +- **Streaming DataFrame**: Continuously reads new events from Kafka +- **Schema**: Parses JSON events into typed columns (symbol, price, volume, timestamp) +- **Windowed Aggregations**: Groups events into 30-second windows with 10-second slides +- **Watermarking**: Handles late-arriving data with a 10-second watermark + +### Moving Averages +Moving averages smooth out price fluctuations to reveal trends: +- **MA5**: Average of the last 5 price events per stock +- **MA10**: Average of the last 10 price events per stock +- When price crosses above MA5/MA10: potential uptrend signal +- When price crosses below MA5/MA10: potential downtrend signal + +### Price Alerts +Alerts are triggered when a stock price moves beyond 1.0% from its base price: +- **UP alert**: price rose more than 1% above base +- **DOWN alert**: price fell more than 1% below base + +--- + +## Prerequisites +- Docker Desktop installed and running (minimum 8GB RAM allocated) +- Docker Compose v2+ +- Git Bash (Windows) or Terminal (Mac/Linux) + +--- + +## How to Run + +### Step 1: Clone and navigate to project folder +```bash +git clone https://github.com/aashishvinod/gpsaggese.github.io.git +cd class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark +``` + +### Step 2: Build Docker image +```bash +docker-compose build +``` +Expected output: `Image ...jupyter Built` + +### Step 3: Start all services +```bash +docker-compose up -d +``` +Expected output: 3 containers started (zookeeper, kafka, jupyter) + +### Step 4: Verify containers are running +```bash +docker-compose ps +``` +All 3 services should show `Up` status. + +### Step 5: Open Jupyter Lab +Open your browser and navigate to: +``` +http://localhost:8888 +``` + +### Step 6: Run the notebooks +1. Open `kafka_spark.API.ipynb` — run all cells to understand each API component +2. Open `kafka_spark.example.ipynb` — run all cells for the full pipeline demo + +### Step 7: Stop all services +```bash +docker-compose down +``` + +--- + +## Results + +### Pipeline Performance +| Metric | Value | +|--------|-------| +| Events produced | 200 | +| Events consumed | 205 | +| Producer throughput | ~7,650 events/sec | +| Consumer latency | ~8 seconds for 205 events | +| Price alerts triggered | 88 (42.9% alert rate) | + +### Moving Average Results (sample run) +| Stock | Last Price | MA5 | MA10 | +|-------|-----------|-----|------| +| AAPL | $174.08 | $173.21 | $174.27 | +| GOOGL | $142.21 | $140.61 | $140.41 | +| MSFT | $374.33 | $375.77 | $378.52 | +| AMZN | $185.55 | $183.97 | $185.27 | +| TSLA | $253.96 | $250.64 | $249.40 | + +### Price Alerts by Symbol (sample run) +| Stock | Alerts | +|-------|--------| +| AAPL | 20 | +| MSFT | 20 | +| AMZN | 18 | +| TSLA | 18 | +| GOOGL | 12 | + +--- + +## Dependencies +| Package | Version | Purpose | +|---------|---------|---------| +| kafka-python | 2.0.2 | Kafka producer/consumer client | +| pyspark | 3.5.1 | Spark Structured Streaming engine | +| pandas | 2.1.0 | DataFrame operations and analysis | +| numpy | 1.26.0 | Numerical computing | +| matplotlib | 3.7.0 | Plotting and visualization | +| seaborn | 0.13.0 | Statistical visualization | +| yfinance | 0.2.28 | Real stock data (optional extension) | +| findspark | 2.0.1 | Spark session initialization helper | + +--- + +## Design Decisions + +### Why Kafka over direct streaming? +Kafka provides **fault tolerance** and **replay capability**. If the consumer crashes, +it can resume from its last committed offset. Direct streaming has no such guarantee. + +### Why windowed aggregations over simple aggregations? +Windowed aggregations (30s window, 10s slide) give a **continuously updated view** +of recent price trends, which is more useful for real-time trading signals than +a static average over all historical data. + +### Why Docker? +Docker ensures the pipeline runs identically on any machine regardless of OS or +installed software. The `docker-compose.yml` spins up Zookeeper, Kafka, and Jupyter +in a single command with all networking configured automatically. + +### Trade-offs +- **Simplicity vs Realism**: Stock prices are simulated with ±2% random walks. Real + production systems would use websocket feeds from brokers like Alpaca or Polygon. +- **Local vs Distributed**: Everything runs on one machine. In production, Kafka would + have multiple brokers and Spark would run on a cluster (YARN/Kubernetes). +- **Python Kafka vs Spark Kafka source**: We use both kafka-python (for producer/consumer + demos) and the Spark-Kafka connector (for structured streaming). Each has its use case. diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/bashrc b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/bashrc new file mode 100644 index 000000000..4b7ff4c49 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/bashrc @@ -0,0 +1 @@ +set -o vi diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/copy_docker_files.py b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/copy_docker_files.py new file mode 100644 index 000000000..0e97c194c --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/copy_docker_files.py @@ -0,0 +1,140 @@ +#!/usr/bin/env python + +""" +Copy Docker-related files from the source directory to a destination directory. + +This script copies all Docker configuration and utility files from +class_project/project_template/ to a specified destination directory. + +Usage examples: + # Copy all files to a target directory. + > ./copy_docker_files.py --dst_dir /path/to/destination + + # Copy with verbose logging. + > ./copy_docker_files.py --dst_dir /path/to/destination -v DEBUG + +Import as: + +import class_project.project_template.copy_docker_files as cpdccodo +""" + +import argparse +import logging +import os +from typing import List + +import helpers.hdbg as hdbg +import helpers.hio as hio +import helpers.hparser as hparser +import helpers.hsystem as hsystem + +_LOG = logging.getLogger(__name__) + +# ############################################################################# +# Constants +# ############################################################################# + +# List of files to copy from the source directory. +_FILES_TO_COPY = [ + "bashrc", + "docker_bash.sh", + "docker_build.sh", + "docker_clean.sh", + "docker_cmd.sh", + "docker_exec.sh", + "docker_jupyter.sh", + "docker_name.sh", + "docker_push.sh", + "etc_sudoers", + "install_jupyter_extensions.sh", + "run_jupyter.sh" + "version.sh", +] + + +# ############################################################################# +# Helper functions +# ############################################################################# + + +def _get_source_dir() -> str: + """ + Get the absolute path to the source directory containing Docker files. + + :return: absolute path to class_project/project_template/ + """ + # Get the directory where this script is located. + script_dir = os.path.dirname(os.path.abspath(__file__)) + _LOG.debug("Script directory='%s'", script_dir) + return script_dir + + +def _copy_files( + *, + src_dir: str, + dst_dir: str, + files: List[str], +) -> None: + """ + Copy specified files from source directory to destination directory. + + :param src_dir: source directory path + :param dst_dir: destination directory path + :param files: list of filenames to copy + """ + # Verify source directory exists. + hdbg.dassert_dir_exists(src_dir, "Source directory does not exist:", src_dir) + # Create destination directory if it doesn't exist. + hio.create_dir(dst_dir, incremental=True) + _LOG.info("Copying %d files from '%s' to '%s'", len(files), src_dir, dst_dir) + # Copy each file. + copied_count = 0 + for filename in files: + src_path = os.path.join(src_dir, filename) + dst_path = os.path.join(dst_dir, filename) + # Verify source file exists. + hdbg.dassert_path_exists( + src_path, "Source file does not exist:", src_path + ) + # Copy the file using cp -a to preserve all permissions and attributes. + _LOG.debug("Copying '%s' -> '%s'", src_path, dst_path) + cmd = f"cp -a {src_path} {dst_path}" + hsystem.system(cmd) + copied_count += 1 + # + _LOG.info("Successfully copied %d files", copied_count) + + +# ############################################################################# + + +def _parse() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser( + description=__doc__, + formatter_class=argparse.RawDescriptionHelpFormatter, + ) + parser.add_argument( + "--dst_dir", + action="store", + required=True, + help="Destination directory where files will be copied", + ) + hparser.add_verbosity_arg(parser) + return parser + + +def _main(parser: argparse.ArgumentParser) -> None: + args = parser.parse_args() + hdbg.init_logger(verbosity=args.log_level, use_exec_path=True) + # Get source directory. + src_dir = _get_source_dir() + # Copy files to destination. + _copy_files( + src_dir=src_dir, + dst_dir=args.dst_dir, + files=_FILES_TO_COPY, + ) + + +if __name__ == "__main__": + _main(_parse()) diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker-compose.yml b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker-compose.yml new file mode 100644 index 000000000..920525e31 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker-compose.yml @@ -0,0 +1,32 @@ +version: '3.8' +services: + zookeeper: + image: confluentinc/cp-zookeeper:7.4.0 + environment: + ZOOKEEPER_CLIENT_PORT: 2181 + ZOOKEEPER_TICK_TIME: 2000 + + kafka: + image: confluentinc/cp-kafka:7.4.0 + depends_on: + - zookeeper + ports: + - "9092:9092" + environment: + KAFKA_BROKER_ID: 1 + KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181 + KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:29092,PLAINTEXT_HOST://localhost:9092 + KAFKA_LISTENER_SECURITY_PROTOCOL_MAP: PLAINTEXT:PLAINTEXT,PLAINTEXT_HOST:PLAINTEXT + KAFKA_INTER_BROKER_LISTENER_NAME: PLAINTEXT + KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1 + + jupyter: + build: . + ports: + - "8888:8888" + volumes: + - .:/app + depends_on: + - kafka + environment: + - KAFKA_BROKER=kafka:29092 diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_bash.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_bash.sh new file mode 100644 index 000000000..0025e81f4 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_bash.sh @@ -0,0 +1,34 @@ +#!/bin/bash +# """ +# This script launches a Docker container with an interactive bash shell for +# development. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions from the project template. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# List the available Docker images matching the expected image name. +run "docker image ls $FULL_IMAGE_NAME" + +# Configure and run the Docker container with interactive bash shell. +# - Container is removed automatically on exit (--rm) +# - Interactive mode with TTY allocation (-ti) +# - Port forwarding for Jupyter or other services +# - Git root mounted to /git_root inside container +CONTAINER_NAME=${IMAGE_NAME}_bash +PORT= +DOCKER_CMD=$(get_docker_bash_command) +DOCKER_CMD_OPTS=$(get_docker_bash_options $CONTAINER_NAME $PORT) +run "$DOCKER_CMD $DOCKER_CMD_OPTS $FULL_IMAGE_NAME" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_build.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_build.sh new file mode 100644 index 000000000..5b0957a99 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_build.sh @@ -0,0 +1,40 @@ +#!/bin/bash +# """ +# Build a Docker container image for the project. +# +# This script sets up the build environment with error handling and command +# tracing, loads Docker configuration from docker_name.sh, and builds the +# Docker image using the build_container_image utility function. It supports +# both single-architecture and multi-architecture builds via the +# DOCKER_BUILD_MULTI_ARCH environment variable. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +# Shift processed option flags so remaining args are passed to the build. +parse_default_args "$@" +shift $((OPTIND-1)) + +# Load Docker configuration variables (REPO_NAME, IMAGE_NAME, FULL_IMAGE_NAME). +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Configure Docker build settings. +# Enable BuildKit for improved build performance and features. +export DOCKER_BUILDKIT=1 +#export DOCKER_BUILDKIT=0 + +# Configure single-architecture build (set to 1 for multi-arch build). +#export DOCKER_BUILD_MULTI_ARCH=1 +export DOCKER_BUILD_MULTI_ARCH=0 + +# Build the container image. +# Pass extra arguments (e.g., --no-cache) via command line after -v. +build_container_image "$@" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_build.version.log b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_build.version.log new file mode 100644 index 000000000..8315eefe2 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_build.version.log @@ -0,0 +1 @@ +the input device is not a TTY diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_clean.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_clean.sh new file mode 100644 index 000000000..7e40839ae --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_clean.sh @@ -0,0 +1,26 @@ +#!/bin/bash +# """ +# Remove Docker container image for the project. +# +# This script cleans up Docker images by removing the container image +# matching the project configuration. Useful for freeing disk space or +# ensuring a fresh build. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Remove the container image. +remove_container_image diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_cmd.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_cmd.sh new file mode 100644 index 000000000..906d7a77b --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_cmd.sh @@ -0,0 +1,41 @@ +#!/bin/bash +# """ +# Execute a command in a Docker container. +# +# This script runs a specified command inside a new Docker container instance. +# The container is removed automatically after the command completes. The +# git root is mounted to /git_root inside the container. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +# Shift processed option flags so remaining args form the command. +parse_default_args "$@" +shift $((OPTIND-1)) + +# Capture the command to execute from remaining arguments. +CMD="$@" +echo "Executing: '$CMD'" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# List available Docker images matching the expected image name. +run "docker image ls $FULL_IMAGE_NAME" +#(docker manifest inspect $FULL_IMAGE_NAME | grep arch) || true + +# Configure and run the Docker container with the specified command. +CONTAINER_NAME=$IMAGE_NAME +DOCKER_CMD=$(get_docker_cmd_command) +PORT="" +DOCKER_RUN_OPTS="" +DOCKER_CMD_OPTS=$(get_docker_bash_options $CONTAINER_NAME $PORT $DOCKER_RUN_OPTS) +run "$DOCKER_CMD $DOCKER_CMD_OPTS $FULL_IMAGE_NAME bash -c '$CMD'" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_exec.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_exec.sh new file mode 100644 index 000000000..24f8e401a --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_exec.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# """ +# Execute a bash shell in a running Docker container. +# +# This script connects to an already running Docker container and opens an +# interactive bash session for debugging or inspection purposes. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Execute bash shell in the running container. +exec_container diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_jupyter.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_jupyter.sh new file mode 100644 index 000000000..1a60dfd3a --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_jupyter.sh @@ -0,0 +1,39 @@ +#!/bin/bash +# """ +# Execute Jupyter Lab in a Docker container. +# +# This script launches a Docker container running Jupyter Lab with +# configurable port, directory mounting, and vim bindings. It passes +# command-line options to the run_jupyter.sh script inside the container. +# +# Usage: +# > docker_jupyter.sh [options] +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse command-line options and set Jupyter configuration variables. +parse_docker_jupyter_args "$@" + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# List available Docker images and inspect architecture. +list_and_inspect_docker_image + +# Run the Docker container with Jupyter Lab. +CMD=$(get_run_jupyter_cmd "${BASH_SOURCE[0]}" "$OLD_CMD_OPTS") +CONTAINER_NAME=$IMAGE_NAME +# Kill existing container if -f flag is set. +kill_existing_container_if_forced + +DOCKER_CMD=$(get_docker_jupyter_command) +DOCKER_CMD_OPTS=$(get_docker_jupyter_options $CONTAINER_NAME $JUPYTER_HOST_PORT $JUPYTER_USE_VIM) +run "$DOCKER_CMD $DOCKER_CMD_OPTS $FULL_IMAGE_NAME $CMD" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_name.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_name.sh new file mode 100644 index 000000000..32a546cf3 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_name.sh @@ -0,0 +1,12 @@ +#!/bin/bash +# """ +# Docker image naming configuration. +# +# This file defines the repository name, image name, and full image name +# variables used by all docker_*.sh scripts in the project template. +# """ + +REPO_NAME=gpsaggese +# The file should be all lower case. +IMAGE_NAME=umd_project_template +FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_push.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_push.sh new file mode 100644 index 000000000..27d752dd9 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/docker_push.sh @@ -0,0 +1,25 @@ +#!/bin/bash +# """ +# Push Docker container image to Docker Hub or registry. +# +# This script authenticates with the Docker registry using credentials from +# ~/.docker/passwd.$REPO_NAME.txt and pushes the locally built container +# image to the remote repository. +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Import the utility functions. +GIT_ROOT=$(git rev-parse --show-toplevel) +source $GIT_ROOT/class_project/project_template/utils.sh + +# Parse default args (-h, -v) and enable set -x if -v is passed. +parse_default_args "$@" + +# Load Docker image naming configuration. +SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +source $SCRIPT_DIR/docker_name.sh + +# Push the container image to the registry. +push_container_image diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/etc_sudoers b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/etc_sudoers new file mode 100644 index 000000000..ee0816a15 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/etc_sudoers @@ -0,0 +1,31 @@ +# +# This file MUST be edited with the 'visudo' command as root. +# +# Please consider adding local content in /etc/sudoers.d/ instead of +# directly modifying this file. +# +# See the man page for details on how to write a sudoers file. +# +Defaults env_reset +Defaults mail_badpass +Defaults secure_path="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin" + +# Host alias specification + +# User alias specification + +# Cmnd alias specification + +# User privilege specification +root ALL=(ALL:ALL) ALL + +# Members of the admin group may gain root privileges +%admin ALL=(ALL) ALL + +# Allow members of group sudo to execute any command +%sudo ALL=(ALL:ALL) ALL + +# See sudoers(5) for more information on "#include" directives: +postgres ALL=(ALL) NOPASSWD:ALL + +#includedir /etc/sudoers.d diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/kafka_spark.API.ipynb b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/kafka_spark.API.ipynb new file mode 100644 index 000000000..68e93edbe --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/kafka_spark.API.ipynb @@ -0,0 +1,537 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# kafka_spark.API.ipynb\n", + "## API Reference: Apache Kafka and Spark Structured Streaming\n", + "**Author**: Aashish Vinod \n", + "**Course**: DATA605 Spring 2026 \n", + "\n", + "## Why I built this\n", + "\n", + "As a grad student I have used Kafka and Spark in coursework before, but always with pre-configured environments. For this project I wanted to wire everything together from scratch inside Docker \u2014 producer, broker, consumer, and Spark all talking to each other.\n", + "\n", + "The trickiest part was Docker networking. When Kafka runs inside a container, you cannot reach it at `localhost:9092` from another container. You have to use the service name defined in `docker-compose.yml`, which is `kafka:29092`. This caused a `NoBrokersAvailable` error that took me a while to track down.\n", + "\n", + "This notebook is my API reference \u2014 I document each component individually so anyone reading it can understand what each piece does before seeing the full pipeline in `kafka_spark.example.ipynb`.\n", + "\n", + "## Notebook structure\n", + "1. Kafka Producer API\n", + "2. Kafka Consumer API\n", + "3. Utility Functions API\n", + "4. Spark Structured Streaming API\n", + "5. Windowed Aggregations API" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "All imports successful!\n", + "Stocks: ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'TSLA']\n", + "Base prices: {'AAPL': 175.0, 'GOOGL': 140.0, 'MSFT': 380.0, 'AMZN': 185.0, 'TSLA': 250.0}\n" + ] + } + ], + "source": [ + "# Standard imports - I'm using kafka-python for the Kafka client\n", + "# and findspark to initialize PySpark from inside Jupyter\n", + "import json\n", + "import random\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from kafka import KafkaProducer, KafkaConsumer\n", + "from kafka.admin import KafkaAdminClient, NewTopic\n", + "from kafka_spark_utils import (\n", + " generate_stock_event, generate_stock_stream,\n", + " serialize_event, deserialize_event,\n", + " compute_moving_average, check_price_alert,\n", + " format_kafka_summary, STOCK_SYMBOLS, BASE_PRICES,\n", + ")\n", + "print('All imports successful!')\n", + "print(f'Stocks: {STOCK_SYMBOLS}')\n", + "print(f'Base prices: {BASE_PRICES}')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Kafka Producer API\n", + "KafkaProducer sends messages to a Kafka topic." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Producer created successfully\n", + "Bootstrap servers: localhost:9092\n" + ] + } + ], + "source": [ + "# Note: I'm connecting to kafka:29092 NOT localhost:9092\n", + "# This is because both Jupyter and Kafka run inside Docker containers\n", + "# and Docker uses the service name 'kafka' as the hostname internally.\n", + "# This was the main networking issue I had to debug.\n", + "producer = KafkaProducer(\n", + " bootstrap_servers='kafka:29092',\n", + " value_serializer=lambda v: json.dumps(v).encode('utf-8'),\n", + " key_serializer=lambda k: k.encode('utf-8') if k else None,\n", + ")\n", + "print(f'Producer connected to Kafka successfully')\n", + "print(f'Bootstrap servers: kafka:29092')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Event to send:\n", + "{\n", + " \"symbol\": \"AAPL\",\n", + " \"price\": 178.09,\n", + " \"volume\": 349,\n", + " \"timestamp\": \"2026-05-05T19:05:14.493077\",\n", + " \"change_pct\": 1.7675\n", + "}\n", + "Message sent successfully!\n" + ] + } + ], + "source": [ + "# Send a single event\n", + "event = generate_stock_event('AAPL')\n", + "print(f'Event to send:')\n", + "print(json.dumps(event, indent=2))\n", + "future = producer.send('stock-prices', key='AAPL', value=event)\n", + "producer.flush()\n", + "print('Message sent successfully!')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Kafka Consumer API\n", + "KafkaConsumer reads messages from a Kafka topic." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total messages received: 1\n", + "Sample message: {\n", + " \"symbol\": \"AAPL\",\n", + " \"price\": 178.09,\n", + " \"volume\": 349,\n", + " \"timestamp\": \"2026-05-05T19:05:14.493077\",\n", + " \"change_pct\": 1.7675\n", + "}\n" + ] + } + ], + "source": [ + "# Initialize KafkaConsumer\n", + "consumer = KafkaConsumer(\n", + " 'stock-prices',\n", + " bootstrap_servers='kafka:29092',\n", + " auto_offset_reset='earliest',\n", + " enable_auto_commit=True,\n", + " group_id='api-demo-group',\n", + " value_deserializer=lambda x: json.loads(x.decode('utf-8')),\n", + " consumer_timeout_ms=3000,\n", + ")\n", + "messages = []\n", + "for msg in consumer:\n", + " messages.append(msg.value)\n", + "consumer.close()\n", + "print(f'Total messages received: {len(messages)}')\n", + "if messages:\n", + " print(f'Sample message: {json.dumps(messages[0], indent=2)}')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Utility Functions API" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "generate_stock_event(\"MSFT\"):\n", + "{\n", + " \"symbol\": \"MSFT\",\n", + " \"price\": 380.8,\n", + " \"volume\": 7075,\n", + " \"timestamp\": \"2026-05-05T19:05:20.753507\",\n", + " \"change_pct\": 0.2096\n", + "}\n" + ] + } + ], + "source": [ + "# generate_stock_event(symbol)\n", + "event = generate_stock_event('MSFT')\n", + "print('generate_stock_event(\"MSFT\"):')\n", + "print(json.dumps(event, indent=2))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Prices: [100, 102, 101, 103, 105, 104, 106, 108, 107, 109]\n", + "MA5 (window=5): [None, None, None, None, 102.2, 103.0, 103.8, 105.2, 106.0, 106.8]\n" + ] + } + ], + "source": [ + "# compute_moving_average(prices, window)\n", + "prices = [100, 102, 101, 103, 105, 104, 106, 108, 107, 109]\n", + "ma5 = compute_moving_average(prices, window=5)\n", + "print(f'Prices: {prices}')\n", + "print(f'MA5 (window=5): {ma5}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Alert for AAPL at $180.0 (base=$175.0):\n", + "{\n", + " \"symbol\": \"AAPL\",\n", + " \"alert\": \"Price moved UP by 2.86%\",\n", + " \"current_price\": 180.0,\n", + " \"base_price\": 175.0,\n", + " \"change_pct\": 2.8571,\n", + " \"timestamp\": \"2026-05-05T19:05:20.777588\"\n", + "}\n", + "\n", + "Alert for AAPL at $175.5 (base=$175.0):\n", + "No alert triggered\n" + ] + } + ], + "source": [ + "# check_price_alert(price, symbol, threshold_pct)\n", + "alert1 = check_price_alert(180.0, 'AAPL', threshold_pct=1.5)\n", + "alert2 = check_price_alert(175.5, 'AAPL', threshold_pct=1.5)\n", + "print('Alert for AAPL at $180.0 (base=$175.0):')\n", + "print(json.dumps(alert1, indent=2) if alert1 else 'No alert triggered')\n", + "print('\\nAlert for AAPL at $175.5 (base=$175.0):')\n", + "print(json.dumps(alert2, indent=2) if alert2 else 'No alert triggered')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original: {'symbol': 'TSLA', 'price': 248.75, 'volume': 6269, 'timestamp': '2026-05-05T19:05:20.791181', 'change_pct': -0.4987}\n", + "Serialized: b'{\"symbol\": \"TSLA\", \"price\": 248.75, \"volume\": 6269, \"timesta'...\n", + "Deserialized: {'symbol': 'TSLA', 'price': 248.75, 'volume': 6269, 'timestamp': '2026-05-05T19:05:20.791181', 'change_pct': -0.4987}\n", + "Match: True\n" + ] + } + ], + "source": [ + "# serialize_event / deserialize_event\n", + "event = generate_stock_event('TSLA')\n", + "serialized = serialize_event(event)\n", + "deserialized = deserialize_event(serialized)\n", + "print(f'Original: {event}')\n", + "print(f'Serialized: {serialized[:60]}...')\n", + "print(f'Deserialized: {deserialized}')\n", + "print(f'Match: {event == deserialized}')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Spark Structured Streaming API" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ":: loading settings :: url = jar:file:/usr/local/lib/python3.11/site-packages/pyspark/jars/ivy-2.5.1.jar!/org/apache/ivy/core/settings/ivysettings.xml\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Ivy Default Cache set to: /root/.ivy2/cache\n", + "The jars for the packages stored in: /root/.ivy2/jars\n", + "org.apache.spark#spark-sql-kafka-0-10_2.12 added as a dependency\n", + ":: resolving dependencies :: org.apache.spark#spark-submit-parent-80dd7457-6044-4d08-9aaa-ab9d2e846912;1.0\n", + "\tconfs: [default]\n", + "\tfound org.apache.spark#spark-sql-kafka-0-10_2.12;3.5.1 in central\n", + "\tfound org.apache.spark#spark-token-provider-kafka-0-10_2.12;3.5.1 in central\n", + "\tfound org.apache.kafka#kafka-clients;3.4.1 in central\n", + "\tfound org.lz4#lz4-java;1.8.0 in central\n", + "\tfound org.xerial.snappy#snappy-java;1.1.10.3 in central\n", + "\tfound org.slf4j#slf4j-api;2.0.7 in central\n", + "\tfound org.apache.hadoop#hadoop-client-runtime;3.3.4 in central\n", + "\tfound org.apache.hadoop#hadoop-client-api;3.3.4 in central\n", + "\tfound commons-logging#commons-logging;1.1.3 in central\n", + "\tfound com.google.code.findbugs#jsr305;3.0.0 in central\n", + "\tfound org.apache.commons#commons-pool2;2.11.1 in central\n", + ":: resolution report :: resolve 551ms :: artifacts dl 22ms\n", + "\t:: modules in use:\n", + "\tcom.google.code.findbugs#jsr305;3.0.0 from central in [default]\n", + "\tcommons-logging#commons-logging;1.1.3 from central in [default]\n", + "\torg.apache.commons#commons-pool2;2.11.1 from central in [default]\n", + "\torg.apache.hadoop#hadoop-client-api;3.3.4 from central in [default]\n", + "\torg.apache.hadoop#hadoop-client-runtime;3.3.4 from central in [default]\n", + "\torg.apache.kafka#kafka-clients;3.4.1 from central in [default]\n", + "\torg.apache.spark#spark-sql-kafka-0-10_2.12;3.5.1 from central in [default]\n", + "\torg.apache.spark#spark-token-provider-kafka-0-10_2.12;3.5.1 from central in [default]\n", + "\torg.lz4#lz4-java;1.8.0 from central in [default]\n", + "\torg.slf4j#slf4j-api;2.0.7 from central in [default]\n", + "\torg.xerial.snappy#snappy-java;1.1.10.3 from central in [default]\n", + "\t---------------------------------------------------------------------\n", + "\t| | modules || artifacts |\n", + "\t| conf | number| search|dwnlded|evicted|| number|dwnlded|\n", + "\t---------------------------------------------------------------------\n", + "\t| default | 11 | 0 | 0 | 0 || 11 | 0 |\n", + "\t---------------------------------------------------------------------\n", + ":: retrieving :: org.apache.spark#spark-submit-parent-80dd7457-6044-4d08-9aaa-ab9d2e846912\n", + "\tconfs: [default]\n", + "\t0 artifacts copied, 11 already retrieved (0kB/12ms)\n", + "26/05/05 19:05:23 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n", + "Setting default log level to \"WARN\".\n", + "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spark version: 3.5.1\n" + ] + } + ], + "source": [ + "import findspark\n", + "findspark.init()\n", + "from pyspark.sql import SparkSession\n", + "from pyspark.sql import functions as F\n", + "from pyspark.sql.types import StructType, StructField, StringType, DoubleType, IntegerType\n", + "\n", + "spark = SparkSession.builder \\\n", + " .appName('StockMarketAPI') \\\n", + " .config('spark.jars.packages', 'org.apache.spark:spark-sql-kafka-0-10_2.12:3.5.1') \\\n", + " .getOrCreate()\n", + "spark.sparkContext.setLogLevel('WARN')\n", + "print(f'Spark version: {spark.version}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Stock event schema:\n", + "struct\n" + ] + } + ], + "source": [ + "# Define schema for stock events\n", + "stock_schema = StructType([\n", + " StructField('symbol', StringType(), True),\n", + " StructField('price', DoubleType(), True),\n", + " StructField('volume', IntegerType(), True),\n", + " StructField('timestamp', StringType(), True),\n", + " StructField('change_pct', DoubleType(), True),\n", + "])\n", + "print('Stock event schema:')\n", + "print(stock_schema.simpleString())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kafka streaming DataFrame schema:\n", + "root\n", + " |-- key: binary (nullable = true)\n", + " |-- value: binary (nullable = true)\n", + " |-- topic: string (nullable = true)\n", + " |-- partition: integer (nullable = true)\n", + " |-- offset: long (nullable = true)\n", + " |-- timestamp: timestamp (nullable = true)\n", + " |-- timestampType: integer (nullable = true)\n", + "\n" + ] + } + ], + "source": [ + "# Read from Kafka as streaming DataFrame\n", + "kafka_df = spark.readStream \\\n", + " .format('kafka') \\\n", + " .option('kafka.bootstrap.servers', 'kafka:29092') \\\n", + " .option('subscribe', 'stock-prices') \\\n", + " .option('startingOffsets', 'earliest') \\\n", + " .load()\n", + "print('Kafka streaming DataFrame schema:')\n", + "kafka_df.printSchema()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Windowed aggregation schema:\n", + "root\n", + " |-- window: struct (nullable = true)\n", + " | |-- start: timestamp (nullable = true)\n", + " | |-- end: timestamp (nullable = true)\n", + " |-- symbol: string (nullable = true)\n", + " |-- avg_price: double (nullable = true)\n", + " |-- max_price: double (nullable = true)\n", + " |-- min_price: double (nullable = true)\n", + " |-- event_count: long (nullable = false)\n", + "\n" + ] + } + ], + "source": [ + "# Parse JSON values and apply windowed aggregation\n", + "parsed_df = kafka_df \\\n", + " .select(F.from_json(F.col('value').cast('string'), stock_schema).alias('data')) \\\n", + " .select('data.*') \\\n", + " .withColumn('event_time', F.to_timestamp('timestamp'))\n", + "\n", + "windowed = parsed_df \\\n", + " .withWatermark('event_time', '10 seconds') \\\n", + " .groupBy(F.window('event_time', '30 seconds', '10 seconds'), 'symbol') \\\n", + " .agg(\n", + " F.avg('price').alias('avg_price'),\n", + " F.max('price').alias('max_price'),\n", + " F.min('price').alias('min_price'),\n", + " F.count('price').alias('event_count'),\n", + " )\n", + "print('Windowed aggregation schema:')\n", + "windowed.printSchema()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spark session stopped.\n" + ] + } + ], + "source": [ + "spark.stop()\n", + "print('Spark session stopped.')\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/kafka_spark.example.ipynb b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/kafka_spark.example.ipynb new file mode 100644 index 000000000..30cd03130 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/kafka_spark.example.ipynb @@ -0,0 +1,1254 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# kafka_spark.example.ipynb\n", + "## Full Pipeline Demo: Real-Time Stock Market Pipeline\n", + "**Author**: Aashish Vinod \n", + "**Course**: DATA605 Spring 2026\n", + "\n", + "## Why I picked this project\n", + "\n", + "I chose this project because of the real-world application. Stock market systems are one of the most demanding real-time data pipelines in existence \u2014 exchanges like NYSE process millions of trades per second. I wanted to understand the core architecture behind that, even at a small scale.\n", + "\n", + "I had used Kafka and Spark separately in previous courses but never integrated them together from scratch. The challenge I was most worried about was Docker \u2014 getting three containers (Zookeeper, Kafka, Jupyter) to network correctly. And yes, that ended up being the hardest part.\n", + "\n", + "## The most interesting result\n", + "\n", + "Out of everything this pipeline produces, the price alerts surprised me the most. I set the alert threshold at 1% price movement, and in a typical run about 42-52% of all events trigger an alert. That seems high, but it makes sense \u2014 our simulator uses a \u00b12% random walk per event, so crossing the 1% threshold happens frequently. In a real trading system you would tune this threshold much more carefully based on the stock's historical volatility.\n", + "\n", + "## Pipeline Steps\n", + "1. Setup\n", + "2. Simulate and explore stock data\n", + "3. Publish events to Kafka\n", + "4. Consume events from Kafka\n", + "5. Compute moving averages\n", + "6. Generate price alerts\n", + "7. Visualize results\n", + "8. Performance analysis\n", + "9. Spark batch processing with SQL and window functions" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 1: Setup" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Setup complete!\n", + "Kafka Broker : kafka:29092\n", + "Topic : stock-prices\n", + "Stocks : ['AAPL', 'GOOGL', 'MSFT', 'AMZN', 'TSLA']\n" + ] + } + ], + "source": [ + "import json\n", + "import time\n", + "import random\n", + "import pandas as pd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "from kafka import KafkaProducer, KafkaConsumer\n", + "from kafka.admin import KafkaAdminClient, NewTopic\n", + "from kafka.errors import TopicAlreadyExistsError\n", + "from kafka_spark_utils import (\n", + " generate_stock_event, compute_moving_average,\n", + " check_price_alert, format_kafka_summary,\n", + " serialize_event, deserialize_event,\n", + " STOCK_SYMBOLS, BASE_PRICES,\n", + ")\n", + "\n", + "KAFKA_BROKER = 'kafka:29092'\n", + "TOPIC_NAME = 'stock-prices'\n", + "N_EVENTS = 200\n", + "sns.set_style('darkgrid')\n", + "plt.rcParams['figure.figsize'] = (12, 5)\n", + "print('Setup complete!')\n", + "print(f'Kafka Broker : {KAFKA_BROKER}')\n", + "print(f'Topic : {TOPIC_NAME}')\n", + "print(f'Stocks : {STOCK_SYMBOLS}')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 2: Explore Simulated Stock Data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Generated 200 sample events\n", + " symbol price volume timestamp change_pct\n", + "0 AAPL 173.84 7694 2026-05-05 19:19:38.724884 -0.6641\n", + "1 AAPL 176.17 4514 2026-05-05 19:19:38.724896 0.6675\n", + "2 AAPL 172.41 9525 2026-05-05 19:19:38.724901 -1.4798\n", + "3 AAPL 173.47 3955 2026-05-05 19:19:38.724905 -0.8756\n", + "4 AAPL 172.72 8870 2026-05-05 19:19:38.724909 -1.3029\n", + "5 AAPL 172.93 6177 2026-05-05 19:19:38.724912 -1.1838\n", + "6 AAPL 176.28 8326 2026-05-05 19:19:38.724916 0.7311\n", + "7 AAPL 177.37 8015 2026-05-05 19:19:38.724925 1.3533\n", + "8 AAPL 176.89 6880 2026-05-05 19:19:38.724929 1.0782\n", + "9 AAPL 177.96 2137 2026-05-05 19:19:38.724933 1.6936\n" + ] + } + ], + "source": [ + "# Generate sample events for exploration (no Kafka needed)\n", + "sample_events = []\n", + "for symbol in STOCK_SYMBOLS:\n", + " for _ in range(40):\n", + " sample_events.append(generate_stock_event(symbol))\n", + "\n", + "df_sample = pd.DataFrame(sample_events)\n", + "df_sample['timestamp'] = pd.to_datetime(df_sample['timestamp'])\n", + "print(f'Generated {len(df_sample)} sample events')\n", + "print(df_sample.head(10))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Summary Statistics by Stock Symbol:\n", + " count avg_price min_price max_price avg_volume\n", + "symbol \n", + "AAPL 40 175.03 171.51 178.46 4602.42\n", + "AMZN 40 184.57 181.40 188.29 5032.92\n", + "GOOGL 40 139.49 137.22 142.06 5039.05\n", + "MSFT 40 379.64 372.42 386.82 5060.32\n", + "TSLA 40 250.39 245.56 254.94 5397.58\n" + ] + } + ], + "source": [ + "# Summary statistics\n", + "summary = df_sample.groupby('symbol').agg(\n", + " count=('price', 'count'),\n", + " avg_price=('price', 'mean'),\n", + " min_price=('price', 'min'),\n", + " max_price=('price', 'max'),\n", + " avg_volume=('volume', 'mean'),\n", + ").round(2)\n", + "print('Summary Statistics by Stock Symbol:')\n", + "print(summary)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plot saved as stock_distributions.png\n" + ] + } + ], + "source": [ + "# Visualize simulated price distributions\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + "for symbol in STOCK_SYMBOLS:\n", + " prices = df_sample[df_sample['symbol'] == symbol]['price']\n", + " axes[0].hist(prices, alpha=0.6, label=symbol, bins=12)\n", + "axes[0].set_title('Simulated Stock Price Distributions')\n", + "axes[0].set_xlabel('Price ($)')\n", + "axes[0].set_ylabel('Frequency')\n", + "axes[0].legend()\n", + "df_sample.groupby('symbol')['volume'].mean().plot(kind='bar', ax=axes[1], color='steelblue')\n", + "axes[1].set_title('Average Volume by Stock Symbol')\n", + "axes[1].set_xlabel('Symbol')\n", + "axes[1].set_ylabel('Average Volume')\n", + "axes[1].tick_params(axis='x', rotation=0)\n", + "plt.tight_layout()\n", + "plt.savefig('stock_distributions.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Plot saved as stock_distributions.png')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 3: Publish Events to Kafka" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Topic \"stock-prices\" already exists.\n" + ] + } + ], + "source": [ + "# Create Kafka topic\n", + "admin_client = KafkaAdminClient(bootstrap_servers=KAFKA_BROKER)\n", + "try:\n", + " topic = NewTopic(name=TOPIC_NAME, num_partitions=3, replication_factor=1)\n", + " admin_client.create_topics([topic])\n", + " print(f'Topic \"{TOPIC_NAME}\" created!')\n", + "except TopicAlreadyExistsError:\n", + " print(f'Topic \"{TOPIC_NAME}\" already exists.')\n", + "finally:\n", + " admin_client.close()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Publishing 200 events to Kafka...\n", + " Published 50/200 events...\n", + " Published 100/200 events...\n", + " Published 150/200 events...\n", + " Published 200/200 events...\n", + "Done! 200 events in 0.02s (8212.7 events/sec)\n" + ] + } + ], + "source": [ + "# Publish stock events to Kafka\n", + "producer = KafkaProducer(\n", + " bootstrap_servers=KAFKA_BROKER,\n", + " value_serializer=lambda v: json.dumps(v).encode('utf-8'),\n", + " key_serializer=lambda k: k.encode('utf-8'),\n", + ")\n", + "produced_events = []\n", + "start_time = time.time()\n", + "print(f'Publishing {N_EVENTS} events to Kafka...')\n", + "for i in range(N_EVENTS):\n", + " symbol = random.choice(STOCK_SYMBOLS)\n", + " event = generate_stock_event(symbol)\n", + " producer.send(TOPIC_NAME, key=symbol, value=event)\n", + " produced_events.append(event)\n", + " if (i + 1) % 50 == 0:\n", + " print(f' Published {i + 1}/{N_EVENTS} events...')\n", + "producer.flush()\n", + "producer.close()\n", + "elapsed = time.time() - start_time\n", + "print(f'Done! {N_EVENTS} events in {elapsed:.2f}s ({N_EVENTS/elapsed:.1f} events/sec)')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 4: Consume Events from Kafka" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Consumed 1050 events in 8.14s\n", + "\n", + "Total events: 1050\n", + "AAPL: 203 events | avg: $175.12 | min: $171.58 | max: $178.37\n", + "AMZN: 232 events | avg: $184.91 | min: $181.34 | max: $188.63\n", + "GOOGL: 206 events | avg: $139.95 | min: $137.25 | max: $142.78\n", + "MSFT: 198 events | avg: $380.36 | min: $372.48 | max: $387.58\n", + "TSLA: 211 events | avg: $250.00 | min: $245.09 | max: $254.98\n" + ] + } + ], + "source": [ + "# Consume all events\n", + "consumer = KafkaConsumer(\n", + " TOPIC_NAME,\n", + " bootstrap_servers=KAFKA_BROKER,\n", + " auto_offset_reset='earliest',\n", + " enable_auto_commit=True,\n", + " group_id='stock-analysis-group',\n", + " value_deserializer=lambda x: json.loads(x.decode('utf-8')),\n", + " consumer_timeout_ms=5000,\n", + ")\n", + "consumed_events = []\n", + "start_time = time.time()\n", + "for msg in consumer:\n", + " consumed_events.append(msg.value)\n", + "consumer.close()\n", + "elapsed = time.time() - start_time\n", + "print(f'Consumed {len(consumed_events)} events in {elapsed:.2f}s')\n", + "print()\n", + "print(format_kafka_summary(consumed_events))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 5: Moving Averages (Spark-style Aggregation)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "DataFrame shape: (1050, 5)\n", + " symbol price volume timestamp change_pct\n", + "0 AAPL 176.31 8242 2026-05-05 19:18:51.416887 0.7472\n", + "1 MSFT 387.58 4790 2026-05-05 19:18:51.419198 1.9949\n", + "2 AMZN 186.40 3390 2026-05-05 19:18:51.419252 0.7571\n", + "3 MSFT 386.57 7725 2026-05-05 19:18:51.419286 1.7292\n", + "4 TSLA 245.66 4243 2026-05-05 19:18:51.419317 -1.7356\n" + ] + } + ], + "source": [ + "# Build DataFrame from consumed events\n", + "df = pd.DataFrame(consumed_events)\n", + "df['timestamp'] = pd.to_datetime(df['timestamp'])\n", + "df = df.sort_values('timestamp').reset_index(drop=True)\n", + "print(f'DataFrame shape: {df.shape}')\n", + "print(df.head())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AAPL: 203 events | last price: $178.19 | MA5: $176.62\n", + "GOOGL: 206 events | last price: $142.42 | MA5: $141.02\n", + "MSFT: 198 events | last price: $376.72 | MA5: $377.15\n", + "AMZN: 232 events | last price: $187.08 | MA5: $184.59\n", + "TSLA: 211 events | last price: $254.98 | MA5: $249.59\n" + ] + } + ], + "source": [ + "# Compute moving averages per symbol\n", + "results = {}\n", + "for symbol in STOCK_SYMBOLS:\n", + " df_sym = df[df['symbol'] == symbol].copy().reset_index(drop=True)\n", + " prices = df_sym['price'].tolist()\n", + " df_sym['MA5'] = compute_moving_average(prices, window=5)\n", + " df_sym['MA10'] = compute_moving_average(prices, window=10)\n", + " results[symbol] = df_sym\n", + " last_ma5 = df_sym['MA5'].dropna().iloc[-1] if df_sym['MA5'].dropna().any() else 'N/A'\n", + " print(f'{symbol}: {len(prices)} events | last price: ${prices[-1]:.2f} | MA5: ${last_ma5}')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plot saved as moving_averages.png\n" + ] + } + ], + "source": [ + "# Plot moving averages\n", + "fig, axes = plt.subplots(len(STOCK_SYMBOLS), 1, figsize=(14, 4 * len(STOCK_SYMBOLS)))\n", + "for idx, symbol in enumerate(STOCK_SYMBOLS):\n", + " df_sym = results[symbol]\n", + " ax = axes[idx]\n", + " ax.plot(df_sym.index, df_sym['price'], label='Price', alpha=0.5, linewidth=1)\n", + " ax.plot(df_sym.index, df_sym['MA5'], label='MA5', linewidth=2, color='orange')\n", + " ax.plot(df_sym.index, df_sym['MA10'], label='MA10', linewidth=2, color='red')\n", + " ax.axhline(y=BASE_PRICES[symbol], color='gray', linestyle='--', alpha=0.5, label='Base')\n", + " ax.set_title(f'{symbol} - Price with Moving Averages')\n", + " ax.set_xlabel('Event Index')\n", + " ax.set_ylabel('Price ($)')\n", + " ax.legend()\n", + "plt.tight_layout()\n", + "plt.savefig('moving_averages.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Plot saved as moving_averages.png')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 6: Price Alert Generation" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total alerts : 547 out of 1050 events\n", + "Alert rate : 52.1%\n", + "\n", + "Alerts by symbol:\n", + " symbol alert_count\n", + "0 AAPL 106\n", + "1 AMZN 115\n", + "2 GOOGL 118\n", + "3 MSFT 103\n", + "4 TSLA 105\n", + "\n", + "Sample alerts:\n", + " symbol alert current_price base_price change_pct timestamp\n", + "0 MSFT Price moved UP by 1.99% 387.58 380.0 1.9947 2026-05-05T19:19:51.681111\n", + "1 MSFT Price moved UP by 1.73% 386.57 380.0 1.7289 2026-05-05T19:19:51.681123\n", + "2 TSLA Price moved DOWN by 1.74% 245.66 250.0 1.7360 2026-05-05T19:19:51.681126\n", + "3 AMZN Price moved DOWN by 1.24% 182.71 185.0 1.2378 2026-05-05T19:19:51.681133\n", + "4 AAPL Price moved UP by 1.34% 177.34 175.0 1.3371 2026-05-05T19:19:51.681137\n" + ] + } + ], + "source": [ + "# Generate price alerts\n", + "all_alerts = []\n", + "for event in consumed_events:\n", + " alert = check_price_alert(event['price'], event['symbol'], threshold_pct=1.0)\n", + " if alert:\n", + " all_alerts.append(alert)\n", + "\n", + "print(f'Total alerts : {len(all_alerts)} out of {len(consumed_events)} events')\n", + "print(f'Alert rate : {len(all_alerts)/len(consumed_events)*100:.1f}%')\n", + "if all_alerts:\n", + " df_alerts = pd.DataFrame(all_alerts)\n", + " print('\\nAlerts by symbol:')\n", + " print(df_alerts.groupby('symbol').size().reset_index(name='alert_count'))\n", + " print('\\nSample alerts:')\n", + " print(df_alerts.head(5).to_string())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABW0AAAHqCAYAAAB/bWzAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAACLjUlEQVR4nOzdfXzN9f/H8efZzMUu2WyuyUUbNRdzmZlkiaLkIiSRkqJEolxURK4qkpAkkSmKsQy5CqVSJEJpuQgblW2udoHN9vn94bfzdWxjh+2cs53H/XZzuzmfz+d83q/PeZ+d8z7P8znvj8kwDEMAAAAAAAAAAIfgYu8CAAAAAAAAAAD/Q2gLAAAAAAAAAA6E0BYAAAAAAAAAHAihLQAAAAAAAAA4EEJbAAAAAAAAAHAghLYAAAAAAAAA4EAIbQEAAAAAAADAgRDaAgAAAAAAAIADIbQFAAAAAAAAAAdCaAsg340cOVLh4eH2LuO6goKCNHPmTHuXcUPh4eF69tln7V2GzQUFBWn8+PH2LiNfrFixQkFBQdq3b1++7bMw/I0BAJzHzJkzFRQUZJO2evfurd69e5tv//zzzwoKCtK6dets0n5heA9OSUnRq6++qhYtWigoKEgTJ04ssLbi4uIUFBSkFStWFFgbtyrr+Xn69Gl7l1KoZI1h4+Li7NJ+YfhbAwpaMXsXAMCxrFixQqNGjTLfLl68uCpWrKgWLVroueeeU9myZe1YXd589tlnGj9+vOrVq6dly5bZrN1Dhw7p66+/VufOnVW5cmWbtZsfTp8+rQ8++EDff/+9Tp48KQ8PD1WqVEnNmjXTc889Jw8PD0lSdHS0EhMT1bdvX/sWfB1paWlasmSJVq5cqePHj8vFxUXlypVTw4YN1bdvX9WsWdPeJQIA4LByGgv6+PgoKChIrVq1UpcuXeTp6XnL7fz333/68ssv1aZNG9WpU+eW95efHLm2vJg7d65Wrlyp5557TlWqVLnu2Cc8PFwnTpww3/b19VX16tX15JNP6r777rNFuTctIyNDUVFRioqKUkxMjFJTUxUQEKBmzZrpscceU926de1dos2cP39e48aN03fffSdvb28NGDBA3bp1s9hm3759evzxx7V69WpVqVLFTpVecf78ebVo0UJpaWlau3atTcfnH374oWrVqqU2bdrYrE3gZhHaAsjR4MGDVblyZaWlpWnXrl1asmSJvv32W61evVqlSpW67n3ffPNNGYZho0qzi46OVqVKlbR3714dO3ZM1apVs0m7hw4d0qxZs9S0adNCFdqePXtWXbt2VXJysrp27aoaNWro7NmziomJ0ZIlS9SzZ09zaLt69WodPHjQoUPbwYMH67vvvlOHDh3UrVs3Xb58WUeOHNHWrVsVEhJCaAsAQB5kjQUvX76shIQE7dixQ5MmTdLChQv1wQcfqHbt2uZtBw4cqGeeecaq/Z86dUqzZs1SpUqVrApG58+fb1U7N+N6tdl7nJsXP/30k+rXr69Bgwblafs6deroySeflHTl2L/44gsNGjRIb7zxhnr27Hnd+2aNuYsVs220cPHiRQ0aNEjbtm1TkyZN9Oyzz8rHx0cnTpzQ119/rZUrV2rr1q0qX768Teuyl7feeks7duzQCy+8oOPHj+v1119XzZo11bBhQ0mSYRiaOHGinnjiiTwHtg8//LA6dOig4sWL53u969atk8lkkr+/v1atWqWhQ4fmexu5mTt3rtq1a0doi0KB0BZAju6++27zt9PdunVT6dKltWDBAn3zzTd68MEHc7xPamqq3N3d5ebmZstSLcTGxmr37t2aNWuWxowZo+jo6DwPWG/WpUuX7HrMt2r58uU6efKklixZYh7YZUlOTi5Ux7Z3715t2bJFQ4cO1YABAyzWZWRk6Pz583aqDACAwuXqsaAkPfvss9q+fbsGDBig5557TmvXrlXJkiUlScWKFSvw0O7ChQsqVapUgQRI1igM46LExETVqlUrz9uXK1dODz/8sPl2p06d1LZtWy1cuDDX0Pby5cvKzMxU8eLFVaJEiVuu2Vpvv/22tm3bplGjRmU7mWDQoEFauHChzWuyp61bt+rll19Wp06dJEkxMTHasmWLeWy/atUqnThxwqpp11xdXeXq6loQ5WrVqlVq1aqVKlasqNWrVxd4aGsYhi5dumR+zQIKC+a0BZAnd911lySZ5zQaOXKkQkJCdPz4cfXv318hISEaPny4ed218w9lZmbq008/1UMPPaS6devqrrvuUr9+/bLN8/nVV1+pS5cuqlevnpo2baqhQ4fqn3/+yXOd0dHR8vHxUatWrdSuXTtFR0fn+b7//fefRo0apdDQUAUHB6tDhw5avny5xTZZ86atWbNG06dPV8uWLVW/fn0tWrRIQ4YMkST16dNHQUFBCgoK0s8//yzpys+R+vXrp2bNmqlevXoKDw+3+OnhjXz//fd6+OGHVbduXbVv314bNmwwr4uNjVVQUFCOg9Nff/1VQUFBWr16da77Pn78uFxdXdWgQYNs6zw9Pc0D8d69e2vr1q06ceKE+fiu7ufExESNHj1aoaGhqlu3rjp27KiVK1dm22denwvXyjqrJyIiItdtYmNjJSlb+CxdGXiWKVNG0pUzUIKCgrRx48Zs20VHRysoKEi7d++W9L/n+smTJ/Xss88qJCRELVu21GeffSbpyqC4T58+atCggVq3bp3rc+7ixYsaM2aMmjVrpoYNG+qVV17RuXPnsm332WefqUOHDgoODlZYWJjGjRtH2AwAcAjNmzfXc889pxMnTmjVqlXm5TnNafvDDz+oZ8+eaty4sUJCQtSuXTu9++67kq6Mpx555BFJ0qhRo8zjiqx5UXv37q0HH3xQ+/fvV69evVS/fn3zfa+d0zZLZmam3n33XbVo0UINGjTQgAEDso0hw8PDNXLkyGz3vXqfN6otp3FuamqqpkyZolatWik4OFjt2rXT/Pnzs52RmzVn/6ZNm/Tggw+ax5vffffd9R52sxuNtbLGqXFxcdq6dau5dmvnJPX391eNGjXM0yZkzVs7f/58LVy4UG3atFHdunV1+PDhXOe0PXz4sIYMGaK77rpL9erVU7t27TR9+nSLbfIy9s7Jv//+qy+++EItWrTI8ddfrq6u6tevX7azbJOSkjRy5Eg1btxYjRo10qhRo3ThwgWLbSIjI9WnTx81b95cwcHBat++vT7//PNsbWRdd+KXX37RI488orp16+ree+9VVFRUtm3//PNPPf7446pXr57uvvtuffDBB4qMjMyxb7799ls99thjatCggUJCQvTMM8/o4MGDN3xMLl68KG9vb/NtHx8f87GlpqZq2rRpGjZsmPnXc3mR05y21hx3bk6ePKlffvlF7du3V4cOHRQXF6dff/01T/fNzMzUwoUL1aFDB9WtW1ehoaEaM2ZMtjF1Vp3btm0zf7ZcunSpgoKClJqaqpUrV5r/PrJeE5KTkzVx4kSFh4crODhYzZs315NPPqnff/89z8cG5DfOtAWQJ8ePH5cklS5d2rzs8uXL6tevnxo1aqQRI0Zc95vLV199VStWrNDdd9+tRx55RBkZGfrll1/022+/mc/imDNnjmbMmKEHHnhAjzzyiE6fPq3FixerV69eioqKshiI5CY6Olr33XefihcvrgcffFBLlizR3r17Va9eveveLyEhQd27d5fJZFKvXr3k6+ur7777Tq+++qqSk5OzDQg/+OADubm5qV+/fkpLS1NYWJh69+6tiIgIDRgwQDVq1JAk1axZU4mJierXr5/KlCmjZ555Rt7e3oqLi8sxMMzJ0aNHNXToUD366KPq3LmzIiMjNWTIEH388cdq0aKFqlSpooYNG2rVqlXZ6oyOjpaHh4fuvffeXPdfqVIlZWRk6KuvvlLnzp1z3W7AgAFKSkrSv//+aw6cswZ+Fy9eVO/evXX8+HH16tVLlStX1rp16zRy5EidP39eTzzxhHk/eXkuXGv69OmaO3euxo8fr+7du+daY8WKFc3H3bBhw1zP+mnWrJkqVKhgfr5cLTo6WlWrVlVISIh5WUZGhvr376/GjRtr+PDhio6O1vjx41WqVClNnz5dDz30kNq2baulS5dqxIgRatCgQbafno0fP17e3t4aNGiQ/v77by1ZskQnT55URESETCaTpCsfemfNmqXQ0FD17NnTvN2+ffu0ZMmSQnF2DwCgaHv44Yf17rvv6vvvv8/1PfngwYN69tlnFRQUpMGDB6t48eI6duyYOZipWbOmBg8erPfff189evRQo0aNJFl+6Xr27Fn1799fHTp0UMeOHeXn53fduubMmSOTyaT+/fsrMTFRn376qfr27auvvvrKqrPr8lLb1QzD0MCBA81hb506dbRt2za9/fbb+u+//zR69GiL7Xft2qUNGzbosccek4eHhyIiIjR48GBt2bLF/OVyTvIy1qpZs6befvttTZ48WeXLlzdPeeDr65vn45ek9PR0/fvvvxbjfulKiHfp0iV1797dPNdxZmZmtvv/+eef6tWrl4oVK6YePXqoUqVKOn78uDZv3mw+o9LasffVvvvuO12+fFkdO3a06rhefPFFVa5cWS+99JL++OMPLVu2TL6+vnr55ZfN2yxZskS33367wsPDVaxYMW3ZskXjxo2TYRjq1auXxf6OHTumIUOG6JFHHjGP0UeOHKk777xTt99+u6QrwXTWOPiZZ56Ru7u7li1bluMZ41FRURo5cqTCwsI0fPhwXbhwQUuWLNFjjz2mlStXXnf6tbp162rBggWqUaOGYmNjtW3bNr355puSrkwHcO3Z1LciL8d9PVnT7bVu3VolS5ZU1apVzWP3GxkzZoxWrlypLl26qHfv3oqLi9Nnn32mP/74I9tY+e+//9awYcPUo0cPde/eXdWrV9fbb7+t1157TfXq1TO/flWtWlWSNHbsWK1fv16PP/64atasqbNnz2rXrl06fPiw7rzzzpt8tIBbZADAVSIjI43AwEDjxx9/NBITE41//vnHWLNmjdG0aVOjXr16xr///msYhmGMGDHCCAwMNKZOnZptHyNGjDBat25tvr19+3YjMDDQePPNN7Ntm5mZaRiGYcTFxRl16tQx5syZY7E+JibGuOOOO7Itz8m+ffuMwMBA44cffjDv++677zYmTJiQbdvAwEDj/fffN98ePXq00aJFC+P06dMW2w0dOtRo1KiRceHCBcMwDOOnn34yAgMDjXvvvde8LMvXX39tBAYGGj/99JPF8o0bNxqBgYHG3r17b3gM12rdurURGBhorF+/3rwsKSnJaNGihdGpUyfzsqVLlxqBgYHGoUOHzMvS0tKMZs2aGSNGjLhuG/Hx8cZdd91lBAYGGvfff78xZswYIzo62jh//ny2bZ955hmLvs2ycOFCIzAw0Pjqq68s2u/Ro4fRoEEDIykpyTCMvD0XDONK/4wbN84wDMOYMmWKUbt2bWPFihXXPY6sfTz++ONGYGCgERoaarz00kvG4sWLjRMnTmTbdtq0aUZwcLDFcSYmJhp33HGHxXMj67n+4YcfmpedO3fOqFevnhEUFGSsWbPGvPzw4cPZnltZf1OdO3c20tLSzMvnzZtnBAYGGps2bTK3feeddxpPPfWUkZGRYd5u8eLFRmBgoLF8+XKLmnLqBwAAblXW+9b1xi2NGjWyGIe8//77RmBgoPn2ggULjMDAQCMxMTHXfezdu9cIDAw0IiMjs63Lei9fsmRJjusef/xx8+2ssVnLli3N4w3DMIy1a9cagYGBxqeffmpe1rp16xzHRdfu83q1XfsenDXO++CDDyy2e+GFF4ygoCDj2LFj5mWBgYHGnXfeabHswIEDRmBgoBEREZGtravldayVdZzPPPPMdfd39bZPPfWUkZiYaCQmJhoHDhwwhg4dajFei42NNQIDA42GDRtm69OsdVc/Vr169TJCQkKyjb+uHuvldeydk0mTJhmBgYHGH3/8kadjzHp+jho1ymL5888/bzRt2tRiWU7tPvXUU8a9995rsSxrjL5z507zssTERCM4ONiYMmWKedmbb75pBAUFWdR65swZo2nTpkZgYKARGxtrGIZhJCcnG40bNzZee+01i3bi4+ONRo0aZVt+rT///NO4++67jcDAQCMwMNB44YUXjIyMDOP48eNGvXr1jN27d1/3/jnJei3IqtGa476eBx980Bg2bJj59rvvvms0a9bMSE9Pt9ju2r+1nTt3GoGBgcaqVasstvvuu++yLc+q87vvvsvWfoMGDXJ8HWjUqJH58wfgKJgeAUCO+vbtq+bNm6tVq1YaOnSoPDw8NGvWLJUrV85iuxtdnECSNmzYIJPJlOPcsllnGG7cuFGZmZl64IEHdPr0afO/smXLqlq1auZpBq4nOjpaZcuWVbNmzcz7bt++vdauXauMjIxc72cYhjZs2KDw8HAZhmHRflhYmJKSkrL9LKZTp055PmvDy8tL0pW5ptLT0/N0n6sFBARYnA3q6empTp066Y8//lB8fLwk6YEHHlCJEiUsfpr//fff68yZMzc8C6Fs2bL66quv9Oijj+r8+fNaunSphg0bpubNm2v27Nl5utjGd999J39/f4v5jt3c3NS7d2+lpqZq586dkvL2XMhiGIbGjx+vRYsW6Z133rnuWcBX72P+/Pl68cUX5e3trdWrV2v8+PFq3bq1XnzxRYtpBh5++GGlpaVp3bp15mVr167N9cyNq6/A6+3trerVq6tUqVJ64IEHzMtr1Kghb29v8zQNV+vRo4fFt/89e/ZUsWLF9O2330qSfvzxR6Wnp6tPnz5ycfnf23O3bt3k6elp3g4AAHtzd3dXSkpKruuzfh31zTff5HgmZl4UL15cXbp0yfP2nTp1kqenp/n2/fffL39//wJ///zuu+/k6uqabcqGp556SoZhZJv6IDQ01HxmnyTVrl1bnp6eOY4drm0nL2Otm/H999+refPmat68uR5++GGtW7dODz/8sHnqsyxt27a94Vm7p0+f1s6dO9W1a1fzL6CyZI31bmbsfbXk5GRJsuqn/pL06KOPWtxu3Lixzp49a96fJIvxfVJSkk6fPq2mTZsqNjZWSUlJFvevVauWGjdubL7t6+ur6tWrW/Tltm3b1KBBA4sL2pUuXVoPPfSQxb5+/PFHnT9/Xh06dLB4PFxcXFS/fv0bfhYKCgrShg0btHz5cm3YsEHvv/++XFxc9NZbb6lt27Zq0KCBNmzYoI4dOyo8PFyzZs266Qvq5eW4c/Pnn3/qr7/+snged+jQQWfOnNH3339/3fuuW7dOXl5eatGihcVjdOedd8rd3T3bY1S5cmW1bNkyz8fl7e2t3377Tf/991+e7wMUNKZHAJCjMWPGqHr16nJ1dVXZsmVVvXp1iyBJunLRibxckfX48eMKCAjI9hOrqx09elSGYaht27Y5rr/RxS0yMjK0Zs0aNWvWzGLepXr16umTTz7R9u3bFRYWluN9T58+rfPnz+uLL77QF198kes2V7vez5Ou1bRpU7Vr106zZs3SwoUL1bRpU7Vp00YPPfRQni6mUa1atWyB5m233SZJOnHihPz9/eXt7a3WrVtr9erVevHFFyVdCbHLlStnno/4egICAjRu3Di98cYbOnr0qL7//nvNmzdP77//vgICAiwCy5ycOHFC1apVy/YcqVmzpqQrc1dJeXsuZImKilJqaqreeOONXC9+l5PixYtr4MCBGjhwoE6dOqWdO3dq0aJF+vrrr1WsWDFNnTrVXFvdunUVHR1tPr7o6Gg1aNBA1apVs9hniRIlsn1I8fLyUvny5bP1jZeXV45z0F67Tw8PD/n7+5vni8t6jLKm1rj6eKpUqWLeDgAAe0tNTb3udAXt27fXsmXL9Nprr2natGlq3ry57rvvPt1///3Zxgq5KVeunFUXHbv2fdZkMqlatWoF/v554sQJBQQEWATG0v/GQNe2X6FChWz78PHxueH89Xkda92M+vXr68UXX5TJZFLJkiVVs2bNHKcly8v4Nyu4CwwMzHWbmxl7Xy3rsb7eFwc5uTZEzjrGc+fOmfe5a9cuzZw5U3v27Mk2321SUpL5ZAwp9768en7VEydO5HjdiKuDe+nKZyFJFlOKXe3a51dOSpQoYTHV2Pbt2/XDDz9o3bp1OnLkiF566SWNGzdOlSpV0rBhw1ShQgV17dr1hvu9Vl6OOzerVq2Su7u7qlSpomPHjpnrrlSpkqKjo3XPPffket9jx44pKSlJzZs3z3F9YmKixW1rPq9J0vDhwzVy5Ejdc889uvPOO9WqVSt16tQp25RngC0R2gLIUb169XKdXzRL8eLF8zzwvpHMzEyZTCbNmzcvx6uUuru7X/f+P/30k+Lj47VmzRqtWbMm2/ro6OhcQ9usM0A6duyY69mc115cw5q50Uwmk95//33t2bNHW7Zs0bZt2zR69GgtWLBAX3zxhdVnCeSmU6dOWrdunX799VcFBgZq8+bN6tmzp1V9ZDKZVL16dVWvXl333HOP2rZtq1WrVt0wtC0IDRs21J9//qnPPvtMDzzwQJ6C3msFBASoQ4cOatu2rR588EGtW7dOU6ZMMX8J0KlTJ02cOFH//vuv0tLStGfPHo0ZMybbfnK7cm5uy2/2zAUAABzdv//+q6SkpGyh09VKliypzz77TD///LO2bt2qbdu2ae3atfriiy/0ySef5OmK9La8yntGRkaeasoPjjh2KFOmjEJDQ2+4XX71yc2Mva+W9QV3TEyMxRmsN5LbmDjrsT9+/Lj69u2rGjVqaOTIkapQoYLc3Nz07bffauHChdnOGs/P50xWDW+//bb8/f2zrbe2rYyMDE2aNEn9+/dXuXLlNHv2bIWEhJhD2h49eig6OvqmQtubPW7DMLRmzRqlpqaqffv22dafPn1aKSkpuX42yszMlJ+fn/kEjGtde4KFtc/X9u3bq3Hjxtq4caN++OEHzZ8/X/PmzdPMmTPVqlUrq/YF5BdCWwAFrmrVqvr+++919uzZXIO3qlWryjAMVa5cWdWrV7e6jejoaPn5+eUYuG3cuFEbN27UuHHjcnzz9vX1lYeHhzIzM/M0YM3NtWdcXqtBgwZq0KCBhg4dqujoaA0fPlxr1669YSB67NgxGYZhsf+sb+MrVapkXtayZUv5+voqOjpa9evX14ULF27pggNVqlSRt7e3eQoGKfdjrFSpkmJiYpSZmWkxID5y5Iik/53ZkJfnQpZq1arp5ZdfVp8+ffT0009r4cKFeTrLICdubm4KCgrS0aNHdebMGfNguH379poyZYpWr16tixcvys3NzWK6g/x07Ngxi7OeU1JSFB8fr7vvvlvS/x6jI0eOWHyjn5aWpri4uFt6bgIAkF+++uorScr1y/AsLi4u5p/cjxo1Sh9++KGmT5+un3/+WaGhoTccN1kr66y9LIZh6NixYxbhX25ntJ48edLivdea2ipVqqTt27crOTnZYpySNQa6eqx2K/I61rK3rMfxr7/+ynWbWx1733333XJ1dVV0dLQ6dep0s6Vms3nzZqWlpWnOnDkWj2depmnLTaVKlbI9N6X/XeQ5S9bj5ufnly9jviVLliglJUX9+vWTJJ06dUoBAQHm9QEBATafBmDHjh36999/NXjwYPMZ4lnOnz+v119/XZs2bcr180vVqlW1fft2NWzYsMC+1AkICFCvXr3Uq1cvJSYmqnPnzvrwww8JbWE3zGkLoMC1bdtWhmFo1qxZ2dZlfavctm1bubq65ji/kmEYOnPmTK77v3jxojZs2KB77rlH999/f7Z/vXr1UkpKijZv3pzj/V1dXdWuXTutX78+xwHm9X6edbVSpUpJUrb5rs6dO5ftmLLOCkhLS7vhfk+dOqWNGzeabycnJysqKkp16tSx+Ca+WLFi6tChg77++mutWLFCgYGBql279g33/9tvvyk1NTXb8r179+rs2bMWIXqpUqWyHZ90ZfAcHx+vtWvXmpddvnxZERERcnd3V5MmTSTl7blwtdq1a+ujjz7S4cOHNXDgQF28ePG6x3L06NEcfx54/vx57d69Wz4+Phbfwvv6+qply5ZatWqV+Wxsa6+wnFdffPGFxZzGS5Ys0eXLl82hbWhoqNzc3BQREWHxWCxfvlxJSUkMFgEAdrd9+3Z98MEHqly58nXnzD979my2ZdeOfbLGTTeaFiCvoqKiLOYmXbduncWXo9KVYOy3336zGH9t2bJF//zzj8W+rKnt7rvvVkZGhj777DOL5QsXLpTJZLJo/1bkdaxlb76+vmrSpIkiIyOzjcmyxje3OvauUKGCunXrpu+//14RERHZ1mdmZuqTTz7Rv//+a1XtWWeQXj0OS0pKUmRkpFX7uVpYWJj27NmjAwcOmJedPXvW4joU0pWTLzw9PTV37twcr4GR188jWfufOXOmXn75ZZUoUULSlWtYZAX8knT48GGVLVvW2sO5JVlTIzz99NPZPq91795dt912W7bH5WoPPPCAMjIy9MEHH2Rbd/ny5Ty/lri7u2fbNiMjI9tnHD8/PwUEBOTp8xpQUDjTFkCBu+uuu/Twww8rIiJCx44dU8uWLZWZmaldu3apWbNmevzxx1W1alW9+OKLmjZtmk6cOKE2bdrIw8NDcXFx2rRpk7p3727+pvhamzdvVkpKisLDw3Nc36BBA/n6+mrVqlU5/hRHkoYNG6aff/5Z3bt3V7du3VSrVi2dO3dOv//+u7Zv364dO3bc8Djr1KkjV1dXzZs3T0lJSSpevLjuuusuRUdHa8mSJWrTpo2qVq2qlJQUffnll/L09MzTQP62227Tq6++qn379snPz0+RkZFKTEzU5MmTs23bqVMnRURE6Oeff8528YjcfPXVV4qOjlabNm0UHBwsNzc3HT58WJGRkSpRooQGDBhg3vbOO+/U2rVrNXnyZNWtW1fu7u4KDw9Xjx499MUXX2jkyJH6/fffValSJa1fv16//vqrRo8ebT7zJC/PhWs1aNBAH3zwgZ555hkNHjxYs2fPtrig19X+/PNPDR8+XC1btlTjxo3l4+Oj//77T1FRUTp16pRGjx6d7SddnTp10uDBgyVJQ4YMydNjdjPS09PVt29fPfDAA/r777/1+eefq1GjRrr33nslXfmQ8+yzz2rWrFl6+umnFR4ebt6ubt26N7ygHAAA+em7777TkSNHlJGRoYSEBP3888/64YcfVLFiRc2ZM8ccBuVk9uzZ+uWXX9SqVStVqlRJiYmJ+vzzz1W+fHk1atRI0pWz5ry9vbV06VJ5eHjI3d1d9erVu+n5I318fPTYY4+pS5cuSkxM1Keffqpq1aqpe/fu5m26deum9evX6+mnn9YDDzyg48ePKzo6OttUD9bUFh4ermbNmmn69Ok6ceKEgoKC9MMPP+ibb77RE088cd1pJKyR17GWI3jttdfUs2dPde7cWT169FDlypV14sQJbd261Xym9q2OvUeOHKnY2FhNmDBBGzZsUOvWreXt7a1//vnHPIdrhw4drKq7RYsWcnNz04ABA/Too48qJSVFy5Ytk5+fn8Uvz6zx9NNPa9WqVXryySf1+OOPy93dXcuWLVOFChV09uxZ81ndnp6eeuONN/TKK6+oS5cuat++vXx9fXXy5El9++23atiwYY6/KMzJjBkzFBgYaPHrsbZt22r27NkaO3asKlWqZH4u2UpaWpo2bNig0NDQXF87wsPDtWjRIiUmJuY4Z3bTpk3Vo0cPzZ07VwcOHDD319GjR7Vu3Tq9+uqruv/++29Yy5133qnt27drwYIFCggIMP/Ss1WrVmrXrp1q164td3d3/fjjj9q3b59NHyfgWoS2AGxi8uTJCgoK0vLly/X222/Ly8tLwcHBCgkJMW/zzDPP6LbbbtPChQs1e/ZsSVL58uXVokWLXANZ6cq3tiVKlFCLFi1yXO/i4qJ77rlH0dHROnPmjMqUKZNtm7Jly2rZsmWaPXu2Nm7cqCVLlqh06dKqVatWnsNPf39/jRs3TnPnztWrr76qjIwMLVq0SE2bNtW+ffu0du1aJSQkyMvLS/Xq1dPUqVPz9MHktttu0+uvv663335bf//9typXrqzp06fneDXU4OBg3X777Tp8+HCeQ74ePXqoZMmS+umnn7R582YlJyerTJkyatGihZ599lndcccd5m0fe+wxHThwQCtWrNDChQtVqVIlhYeHq2TJkoqIiNDUqVO1cuVKJScnq3r16po8eXK2Kz/n5blwrebNm+u9997T4MGD9corr2jatGk5zkvWpEkTDR48WNu2bdOCBQt05swZeXh4qE6dOho+fLjatWuX7T6tW7eWj4+PMjMzzQFqQRgzZoyio6P1/vvvKz09XR06dNBrr71m8RPMF154Qb6+vlq8eLEmT54sHx8fde/eXS+99FKuQTUAAAXh/fffl3RliqHSpUsrMDBQo0ePVpcuXW4YEIaHh+vEiROKjIw0j72aNm2qF154wXwhJzc3N02ZMkXvvvuu3njjDV2+fFmTJ0++6dB2wIABiomJ0UcffaSUlBQ1b95cY8eONZ81K105m3HkyJFasGCBJk2apODgYH344Yd66623LPZlTW0uLi6aM2eO3n//fa1du1YrVqxQpUqV9Morr+ipp566qWPJiTVjLXurXbu2vvzyS82YMUNLlizRpUuXVLFiRYsQ8VbH3qVKldK8efO0YsUKRUVF6YMPPtDFixcVEBCgZs2aaerUqSpXrpxVddeoUUPvv/++3nvvPb311lsqW7asevbsKV9fX40ePdrqx0G6clbwokWLNGHCBM2dO1e+vr7q1auXSpUqpQkTJlgEmA899JACAgL00Ucfaf78+UpLS1O5cuXUuHHjPPdxTEyMli1bpmXLllksDwoK0uTJkzVz5kylpKToscceU48ePW7qmG7G1q1bdf78ebVu3TrXbVq3bq1PPvlEa9asUZ8+fXLcZvz48QoODtbSpUs1ffp0ubq6qlKlSurYsaMaNmyYp1pGjhypMWPG6L333tPFixfVuXNnjR8/Xj179tQPP/ygDRs2yDAMVa1aVWPHjtVjjz12U8cM5AeTwdVSAKBI6dSpk3x8fPTpp5/au5RC4fLly2rZsqVat26tSZMm2bscAAAAFHETJ07UF198od27d9vsIngACh/mtAWAImTfvn06cOBAvl6UoajbtGmTTp8+zWMGAACAfHftNRnOnDmjVatWqVGjRgS2AK6L6REAoAj466+/9Pvvv+uTTz6Rv79/rnP34n9+++03xcTE6IMPPtAdd9yhpk2b2rskAAAAFDE9evRQ06ZNVbNmTSUkJCgyMlLJycl67rnn7F0aAAdHaAsARcD69es1e/ZsVa9eXe++++51Lw6CK5YsWaJVq1apdu3amjJlir3LAQAAQBHUqlUrrV+/Xl9++aVMJpPuuOMOTZw4UU2aNLF3aQAcHHPaAgAAAAAAAIADYU5bAAAAAAAAAHAghLYAAAAAAAAA4EAIbQEAAAAAAADAgRDaAgAAAAAAAIADKWbvAhxJYmKSnOmybCaT5Ofn5XTH7ezod+dDnzsf+tz5OHOfZx27s7JVnzvzc6yooS+LBvqx6KAviwb6seiwRV/mdfxKaHsVw5BT/nE563E7O/rd+dDnzoc+dz70ufOxdZ/zHCs66MuigX4sOujLooF+LDocoS+ZHgEAAAAAAAAAHAihLQAAAAAAAAA4EEJbAAAAAAAAAHAghLYAAAAAAAAA4EAIbQEAAAAAAADAgRDaAgAAAAAAAIADsWtou3PnTg0YMEBhYWEKCgrSpk2bzOvS09P1zjvv6KGHHlKDBg0UFhamV155Rf/995/FPs6ePathw4apYcOGaty4sUaPHq2UlBRbHwoAAAAAAAAA5Au7hrapqakKCgrS2LFjs627ePGi/vjjDw0cOFArVqzQrFmz9Pfff2vgwIEW2w0fPlyHDh3SggUL9OGHH+qXX37RmDFjbHUIAAAAAAAAAJCvitmz8VatWqlVq1Y5rvPy8tKCBQsslr3++uvq1q2bTp48qYoVK+rw4cPatm2bli9frrp160qSXnvtNT3zzDN65ZVXVK5cuQI/BgAAAAAAAADIT3YNba2VnJwsk8kkb29vSdLu3bvl7e1tDmwlKTQ0VC4uLtq7d6/uu+8+q/ZvMuVruQ4v63id7bidHf3ufOhz50OfOx9n7nNnPGYAAAAUfYUmtL106ZKmTp2qDh06yNPTU5KUkJAgX19fi+2KFSsmHx8fxcfHW92Gn59XvtRa2DjrcTs7+t350OfOhz53PvQ5AAAAUDQUitA2PT1dQ4YMkWEYGjduXIG1k5iYJMMosN07HJPpyoc7ZztuZ0e/Ox/63PnQ587Hmfs869gBAACAosThQ9v09HS9+OKLOnnypD799FPzWbaSVLZsWZ0+fdpi+8uXL+vcuXPy9/e3ui3DkNN90JGc97idHf3ufOhz50OfOx/63PF89NFHmjZtmvr06aNXX31V0pVfkE2ZMkVr165VWlqawsLCNHbsWJUtW9bO1QIAAMBRuNi7gOvJCmyPHTumhQsXqkyZMhbrQ0JCdP78ee3fv9+87KefflJmZqbq1atn63IBAAAAs71792rp0qUKCgqyWD5p0iRt2bJF7733niIiInTq1CkNGjTITlUCAADAEdk1tE1JSdGBAwd04MABSVJcXJwOHDigkydPKj09XYMHD9b+/fs1depUZWRkKD4+XvHx8UpLS5Mk1axZUy1bttTrr7+uvXv3ateuXXrzzTfVoUMHlStXzp6HBgAAACeWkpKil19+WRMmTJCPj495eVJSkiIjIzVy5Eg1b95cwcHBmjRpknbv3q09e/bYr2AAAAA4FLtOj7B//3716dPHfHvy5MmSpM6dO2vQoEHavHmzJOnhhx+2uN+iRYvUrFkzSdLUqVP15ptv6oknnpCLi4vatm2r1157zUZHAAAAAGQ3fvx4tWrVSqGhoZozZ455+f79+5Wenq7Q0FDzspo1a6pixYras2ePGjRoYIdqAQAA4GjsGto2a9ZMMTExua6/3rospUuX1rRp0/KzLADIdy4uJrm4mOxag6urfX5ckZlpKDOTSTYBOI81a9bojz/+0PLly7OtS0hIkJubm7y9vS2W+/n5KT4+3uq2TDZ6a8lqx1btoeDQl0UD/Vh0FPW+jIuLVWJios3a8/PzU+XKVWzWXpai3o/OxBZ9mdd9O/yFyACgsHNxMcm3dCmZXF3tWkeZMh52adfIyNDpsxcIbgE4hX/++UcTJ07UJ598ohIlShR4e35+XgXehj3bQ8GhL4sG+rHoKIp9efz4cTUPbaKLF1Jt1mbJUu6K+fOAqlatarM2r1YU+9FZOUJfEtoCQAFzcTFdCWznvSX9E2vvcmyrQhWZ+o+Qi4uJ0BaAU/j999+VmJioLl26mJdlZGRo586d+uyzzzR//nylp6fr/PnzFmfbJiYmyt/f3+r2EhOTZNjg5dVkuvLhxVbtoeDQl0UD/Vh0FOW+PHjwmC5eSFXdrsPk4V/wZ7+mxMdqX+Q0HTx4TO7uZW58h3xUlPvR2diiL7PauBFCWwCwlX9ipeOH7F0FAKAA3XXXXYqOjrZYNmrUKNWoUUP9+/dXhQoV5Obmpu3bt6tdu3aSpCNHjujkyZM3NZ+tYcimHw5t3R4KDn1ZNNCPRUdR7ksP/yryrljLpm3a67Esyv3obByhLwltAQAAgHzi6empwMBAi2Xu7u4qXbq0eXnXrl01ZcoU+fj4yNPTUxMmTFBISAgXIQMAAIAZoS0AAABgQ6NHj5aLi4sGDx6stLQ0hYWFaezYsfYuCwAAAA6E0BYAAAAoQBERERa3S5QoobFjxxLUAgAAIFcu9i4AAAAAAAAAAPA/hLYAAAAAAAAA4ECYHgGwAxcXk1xcTHatwdXVPt/ZZGYayszkcpoAAAAAAAC5IbQFbMzFxSTf0qVkcnW1ax1lynjYpV0jI0Onz14guAUAAAAAAMgFoS1gYy4upiuB7by3pH9i7V2ObVWoIlP/EXJxMRHaAgAAAAAA5ILQFrCXf2Kl44fsXQUAAAAAAAAcDBciAwAAAAAAAAAHQmgLAAAAAAAAAA6E0BYAAAAAAAAAHAihLQAAAAAAAAA4EEJbAAAAAAAAAHAghLYAAAAAAAAA4EAIbQEAAAAAAADAgRDaAgAAAAAAAIADIbQFAAAAAAAAAAdCaAsAAAAAAAAADoTQFgAAAAAAAAAcCKEtAAAAAAAAADgQQlsAAAAAAAAAcCCEtgAAAAAAAADgQAhtAQAAAAAAAMCBENoCAAAAAAAAgAMhtAUAAAAAAAAAB0JoCwAAAAAAAAAOhNAWAAAAAAAAABwIoS0AAAAAAAAAOBBCWwAAAAAAAABwIIS2AAAAAAAAAOBACG0BAAAAAAAAwIEQ2gIAAAAAAACAAyG0BQAAAAAAAAAHQmgLAAAAAAAAAA6kmL0LgOTiYpKLi8lu7bu62i+7z8w0lJlp2K19AAAAAAAAwNEQ2tqZi4tJvqVLyeTqarcaypTxsFvbRkaGTp+9QHALAAAAAAAA/D9CWztzcTFdCWznvSX9E2vvcmyrQhWZ+o+Qi4uJ0BYAAAAAAAD4f4S2juKfWOn4IXtXAQAAbgFTHvElLAAAAJAfCG0BAADyAVMeMeURAAAAkF8IbQEAAPIBUx4x5VGWzz//XEuWLNGJEyckSbfffruee+45tWrVSpLUu3dv7dixw+I+PXr00Pjx421eKwAAABwToS0AAEB+Ysojp1e+fHkNHz5c1apVk2EYioqK0vPPP6+VK1fq9ttvlyR1795dgwcPNt+nVKlS9ioXAAAADojQFgAAAMhH4eHhFreHDh2qJUuWaM+ePebQtmTJkvL397dHeQAAACgE7He1CgAAAKCIy8jI0Jo1a5SamqqQkBDz8ujoaDVr1kwPPvigpk2bpgsXLtixSgAAADgazrQFAAAA8llMTIweffRRXbp0Se7u7po9e7Zq1aolSXrwwQdVsWJFBQQEKCYmRlOnTtXff/+tWbNmWd2OyZTflV+/HVu1h4JDXxYN9GPRQV8WDFs/nvRj0WGLvszrvgltAQAoIC4uJrm42G/k5upqnx/UZGYaXIwKTq969eqKiopSUlKS1q9frxEjRmjx4sWqVauWevToYd4uKChI/v7+6tu3r44fP66qVata1Y6fn1d+l+5Q7aHg0JdFA/1YdBTFvixTxsNu7ZYta5/Hsyj2o7NyhL4ktAUAoAC4uJjkW7qUTK6udqvBXgNlIyNDp89eILiFUytevLiqVasmSQoODta+ffu0aNEijR8/Ptu29evXlyQdO3bM6tA2MTFJhg3+1EymKx9ebNUeCg59WTTQj0VHUe7LM2dS7NZuQkKSTdssyv3obGzRl1lt3AihLQAABcDFxXQlsJ33lvRPrL3LsZ0KVWTqP0IuLiZCW+AqmZmZSktLy3HdgQMHJOmmLkxmGLLph0Nbt4eCQ18WDfRj0UFf5i97PZb0Y9HhCH1JaAsAQEH6J1Y6fsjeVQCwoWnTpunuu+9WhQoVlJKSotWrV2vHjh2aP3++jh8/rujoaLVq1UqlS5dWTEyMJk+erCZNmqh27dr2Lh0AAAAOgtAWAAAAyEeJiYkaMWKETp06JS8vLwUFBWn+/Plq0aKF/vnnH23fvl2LFi1SamqqKlSooLZt2+q5556zd9kAAABwIIS2AAAAQD6aNGlSrusqVKigxYsX27AaAAAAFEb2uaz0/9u5c6cGDBigsLAwBQUFadOmTRbrDcPQjBkzFBYWpnr16qlv3746evSoxTZnz57VsGHD1LBhQzVu3FijR49WSop9JrsGAAAAAAAAgFtl19A2NTVVQUFBGjt2bI7r582bp4iICL3xxhv68ssvVapUKfXr10+XLl0ybzN8+HAdOnRICxYs0IcffqhffvlFY8aMsdUhAAAAAAAAAEC+suv0CK1atVKrVq1yXGcYhhYtWqSBAweqTZs2kqS3335boaGh2rRpkzp06KDDhw9r27ZtWr58uerWrStJeu211/TMM8/olVdeUbly5Wx2LAAAAADg6OLiYnX8+EWdOWO7Xyf6+vqpcuUqNmsPAICiwGHntI2Li1N8fLxCQ0PNy7y8vFS/fn3t3r1bHTp00O7du+Xt7W0ObCUpNDRULi4u2rt3r+677z6r2jSZ8q18WInH3vnQ586HPnc+9LlzsnW/8zwD8i4uLlahoY118eIFm7ZbsmQp/fjjLwS3AABYwWFD2/j4eEmSn5+fxXI/Pz8lJCRIkhISEuTr62uxvlixYvLx8THf3xp+fl43WS1uRZkyHvYuATZGnzsf+tz50OfOiX4HHNvp04m6ePGC6nYdJg9/2wSoKfGx2hc5TadPJxLaAgBgBYcNbe0hMTFJhmHbNl1dXZz+A86ZMynKyMi0dxk2Q5/T587I2fpcot/pc+dkj343mfjiHbCWh38VeVesZe8yAADAdThsaOvv7y9JSkxMVEBAgHl5YmKiateuLUkqW7asTp8+bXG/y5cv69y5c+b7W8MwZPPQFlfwuDsf+tz50OfOhz53TvQ7AAAAcOtc7F1AbipXrix/f39t377dvCw5OVm//fabQkJCJEkhISE6f/689u/fb97mp59+UmZmpurVq2fzmgEAAAAAAADgVtn1TNuUlBQdP37cfDsuLk4HDhyQj4+PKlasqD59+mjOnDmqVq2aKleurBkzZiggIEBt2rSRJNWsWVMtW7bU66+/rnHjxik9PV1vvvmmOnTooHLlytnrsAAAAAAAAADgptk1tN2/f7/69Oljvj158mRJUufOnTVlyhT1799fFy5c0JgxY3T+/Hk1atRIH3/8sUqUKGG+z9SpU/Xmm2/qiSeekIuLi9q2bavXXnvN5scCAAAAAAAAAPnBrqFts2bNFBMTk+t6k8mkIUOGaMiQIbluU7p0aU2bNq0gygMAAAAAAAAAm3PYOW0BAAAAAAAAwBnZ9UxbAAAAAHAUcXGxOn060aZt+vr6qXLlKjZtEwAAOD5CWwAAAABOLy4uVqGhjXXx4gWbtluyZCn9+OMvBLcAAMACoS0AAAAAp3f6dKIuXrygul2HycPfNgFqSnys9kVO0+nTiYS2AADAAqEtAAAAAPw/D/8q8q5Yy95lAAAAJ8eFyAAAAAAAAADAgRDaAgAAAAAAAIADIbQFAAAAAAAAAAdCaAsAAAAAAAAADoTQFgAAAAAAAAAcCKEtAAAAAAAAADiQYvYuAAAAAIDjO378uA4ePGbTNn19/VS5chWbtgkAAOAICG0BAAAAXFdcXKyahzbRxQupNm23ZMlS+vHHXwhuAQCA0yG0BQAAAHBdiYmJunghVXW7DpOHv20C1JT4WO2LnKbTpxMJbQEAgNMhtAUAAACQJx7+VeRdsZa9ywAAACjyuBAZAAAAAAAAADgQQlsAAAAAAAAAcCCEtgAAAAAAAADgQAhtAQAAAAAAAMCBENoCAAAAAAAAgAMpZu8CAAAAAAAorOLiYnX6dKJN2/Tz81PZsnfYtE0AgG0R2gIAAAAAcBPi4mIVGtpYFy9esGm7JUuWUkzMn3J3L2PTdgEAtkNoCwAAAADATTh9OlEXL15Q3a7D5OFfxSZtpsTHal/kNCUkJKhqVUJbACiqCG0BAAAAALgFHv5V5F2xlr3LAAAUIVyIDAAAAAAAAAAcCKEtAAAAAAAAADgQQlsAAAAgH33++ed66KGH1LBhQzVs2FA9evTQt99+a15/6dIljRs3Ts2aNVNISIheeOEFJSQk2LFiAAAAOBpCWwAAACAflS9fXsOHD9eKFSsUGRmpu+66S88//7wOHjwoSZo0aZK2bNmi9957TxERETp16pQGDRpk56oBAADgSLgQGQAAAJCPwsPDLW4PHTpUS5Ys0Z49e1S+fHlFRkZq6tSpat68uaQrIW779u21Z88eNWjQwA4VAwAAwNFwpi0AAABQQDIyMrRmzRqlpqYqJCRE+/fvV3p6ukJDQ83b1KxZUxUrVtSePXvsVygAAAAcCmfaAgAAAPksJiZGjz76qC5duiR3d3fNnj1btWrV0oEDB+Tm5iZvb2+L7f38/BQfH291OyZTflXsGO04avu2wDHCWgcOHNDZsykyjIJvy8/PT5UrVyn4huwoLi5WiYmJNm3Tz89PVapceVz5+8hftn48s9orqv1o67+PtLRLKl68hM3ak/73OmeLvszrvgltAQAAgHxWvXp1RUVFKSkpSevXr9eIESO0ePHifG/Hz88r3/eZk9KlPWzSTk7KlPFQ2bIFf5xlynCMBd22LY7R1uzxmF5KOiOZTHr88cdt1mbJUu6K+fOAqlatarM2ben48eNqHtpEFy+k2rTdrMfVz8/LZq/ntmSv1xx7vt4UxX60y9+HyUUyMm3XnrK/zjlCXxLaAgAAAPmsePHiqlatmiQpODhY+/bt06JFi/TAAw8oPT1d58+ftzjbNjExUf7+/la3k5iYZJOz7M6eTSn4RnJx5kyKEhKSbNKOvXCMhZc9HtPLF5Mlw1DdrsPk4V/wZ7+mxMdqX+Q0HTx4TO7uZQq8PXs4ePCYLl5ItdljKv3vcT106JiqVq1qs9dzW7LXa449Xm9MpishX1HsR1v/fST89YsObV5sl7/HgwePycOjTIH3Zdbz5UYIbQEAAIAClpmZqbS0NAUHB8vNzU3bt29Xu3btJElHjhzRyZMnb+oiZIYhm3w4tPcHUHu3bwscI6zl4V9F3hVr2bTNot6H9nxMbfV67izs9VgW5X601d9HSnysTdu7liP9TRLaAgAAAPlo2rRpuvvuu1WhQgWlpKRo9erV2rFjh+bPny8vLy917dpVU6ZMkY+Pjzw9PTVhwgSFhITcVGgLAACAoonQFgAAAMhHiYmJGjFihE6dOiUvLy8FBQVp/vz5atGihSRp9OjRcnFx0eDBg5WWlqawsDCNHTvWzlUDAADAkRDaAgAAAPlo0qRJ111fokQJjR07lqAWAAAAuXKxdwEAAAAAAAAAgP8htAUAAAAAAAAAB0JoCwAAAAAAAAAOhDltAQAAAMCODh6MKVLtAHBMcXGxOn060Wbt8ZoD3BpCWwAAAACwg0tJZySTSQMH9rd3KQCKuLi4WIWGNtbFixfsXQqAPCK0BQAAAAA7uHwxWTIM1e06TB7+VQq8vYS/ftGhzYsLvB0Ajuf06URdvHjBZq83Eq85wK0itAUAAAAAO/LwryLvirUKvJ2U+NgCbwOAY7PV643Eaw5wq7gQGQAAAAAAAAA4EEJbAAAAAAAAAHAghLYAAAAAAAAA4EAIbQEAAAAAAADAgRDaAgAAAAAAAIADKWbvAgAAAAAgNwcPxhSpdlDw4uJidfp0ok3a4nkDACgohLYAAAAAHM6lpDOSyaSBA/vbuxQUInFxsQoNbayLFy/YuxQAAG4JoS0AAAAAh3P5YrJkGKrbdZg8/KsUeHsJf/2iQ5sXF3g7KFinTyfq4sULPG8AAIUeoS0AAAAAh+XhX0XeFWsVeDsp8bEF3gZsh+cNAKCw40JkAAAAAAAAAOBAHDq0zcjI0Hvvvafw8HDVq1dPbdq00ezZs2UYhnkbwzA0Y8YMhYWFqV69eurbt6+OHj1qv6IBAAAAAAAA4BY4dGg7b948LVmyRGPGjNHatWs1fPhwffzxx4qIiLDYJiIiQm+88Ya+/PJLlSpVSv369dOlS5fsWDkAAAAAAAAA3ByHDm13796te++9V/fcc48qV66s+++/X2FhYdq7d6+kK2fZLlq0SAMHDlSbNm1Uu3Ztvf322zp16pQ2bdpk5+oBAAAAAAAAwHoOHdqGhITop59+0t9//y1J+vPPP7Vr1y7dfffdkqS4uDjFx8crNDTUfB8vLy/Vr19fu3fvtkvNAAAAAAAAAHAritm7gOt55plnlJycrAceeECurq7KyMjQ0KFD1bFjR0lSfHy8JMnPz8/ifn5+fkpISLC6PZPp1mvGzeGxdz70ufOhz50Pfe6cbN3vPM8AAABQFDl0aPv1118rOjpa06ZNU61atXTgwAFNnjxZAQEB6ty5c7635+fnle/7xI2VKeNh7xJgY/S586HPnQ997pzodwAAACB/WB3a/vPPPzKZTCpfvrwkae/evYqOjlatWrXUo0ePfC3u7bff1jPPPKMOHTpIkoKCgnTy5EnNnTtXnTt3lr+/vyQpMTFRAQEB5vslJiaqdu3aVreXmJgkw8if2vPK1dXF6T/gnDmTooyMTHuXYTP0OX3ujJytzyX6nT53Tvbod5OJL94BAABQ9Fgd2g4bNkzdu3dXp06dFB8fryeffFK33367oqOjFR8fr0GDBuVbcRcvXpTpmt+8ubq6yvj/ZLVy5cry9/fX9u3bVadOHUlScnKyfvvtN/Xs2dPq9gxDNg9tcQWPu/Ohz50Pfe586HPnRL8DAAAAt87qC5EdPHhQ9erVk3Rl+oLbb79dS5cu1dSpU7Vy5cp8La5169b68MMPtXXrVsXFxWnjxo1asGCB2rRpI0kymUzq06eP5syZo2+++UYxMTF65ZVXFBAQYN4GAAAAAAAAAAoTq8+0vXz5sooXLy5J+vHHHxUeHi5JqlGjhvnCYPnltdde04wZMzRu3DjzFAg9evTQ888/b96mf//+unDhgsaMGaPz58+rUaNG+vjjj1WiRIl8rQUAAAAAAAAAbMHq0LZWrVpaunSp7rnnHv3444968cUXJUmnTp1S6dKl87U4T09Pvfrqq3r11Vdz3cZkMmnIkCEaMmRIvrYNAAAAAAAAAPZg9fQIw4cP1xdffKHevXurQ4cO5gt+bd682TxtAgAAAAAAAADg5lh9pm2zZs30008/KTk5WT4+Publ3bt3l7u7e74WBwAAAAAAAADOxuozbfv06aOUlBSLwFaSSpcubZ4qAQAAAAAAAABwc6wObXfs2KH09PRsyy9duqRdu3blS1EAAAAAAAAA4KzyPD3Cn3/+af7/oUOHFB8fb76dmZmpbdu2qVy5cvlbHQAAAAAAAAA4mTyHtp06dZLJZJLJZNITTzyRbX3JkiX12muv5WtxAAAAAAAAAOBs8hzafvPNNzIMQ23atNGyZcvk6+trXufm5iY/Pz+5uroWSJEAAAAAAAAA4CzyHNpWqlRJ6enp6ty5s0qXLq1KlSoVZF0AAAAAAAAA4JSsuhCZm5ubNm7cWFC1AAAAAAAAAIDTsyq0laR7771X33zzTUHUAgAAAAAAAABOL8/TI2SpVq2aZs+erV9//VV33nmnSpUqZbG+T58++VYcAAAAUNjMnTtXGzZs0JEjR1SyZEmFhIRo+PDhqlGjhnmb3r17a8eOHRb369Gjh8aPH2/rcgEAAOCArA5tly9fLi8vL+3fv1/79++3WGcymQhtAQAA4NR27NihXr16qW7dusrIyNC7776rfv36ac2aNXJ3dzdv1717dw0ePNh8+9qTIQAAAOC8rA5tN2/eXBB1AAAAAEXC/PnzLW5PmTJFzZs31++//64mTZqYl5csWVL+/v62Lg8AAACFgNWhbZa0tDTFxcWpatWqKlbspncDAAAAFGlJSUmSJB8fH4vl0dHRWrVqlfz9/dW6dWs999xzVp9tazLlW5kO0Q6KroMHY4pUO87Klq8FcXGxSkxMtElb9nzeZD2mvM7mL1s/nvRj0WGLvszrvq1OWy9cuKA333xTUVFRkqT169erSpUqevPNN1WuXDk988wz1u4SAAAAKJIyMzM1adIkNWzYUIGBgeblDz74oCpWrKiAgADFxMRo6tSp+vvvvzVr1iyr9u/n55XfJeeodGkPm7SDoudS0hnJZNLAgf3tXQpuUZkyHipb1javOcePH1fz0Ca6eCHVJu3ZU9bra0G/npcp4zyv47Z8rl7LVu/LtuRsz52sPnSEvrQ6tJ02bZr+/PNPLVq0SP37/++Nt3nz5po1axahLQAAAPD/xo0bp4MHD+rzzz+3WN6jRw/z/4OCguTv76++ffvq+PHjqlq1ap73n5iYJMPIt3JzdfZsSsE3giLp8sVkyTBUt+swefhXKfD2Ev76RYc2Ly7wdpzRmTMpSkhIsklbBw8e08ULqU7xvMl6fS3o1/MzZ5znddyWz9UsJtOVkM9W78u25GzPncTEpALvy6zny41YHdp+8803mj59uho0aGCx/Pbbb9fx48et3R0AAABQJI0fP15bt27V4sWLVb58+etuW79+fUnSsWPHrAptDUM2+XBY1D6AwvY8/KvIu2KtAm8nJT62wNtwZrZ+LXCG503WY2qr13NnYa/Hkn4s/Bzpb9Lq0Pb06dPy8/PLtvzChQsyMXkHAAAAnJxhGHrzzTe1ceNGRUREqEqVG58lduDAAUniwmQAAACQJLlYe4fg4GBt3bo12/Jly5ZlO/sWAAAAcDbjxo3TqlWrNG3aNHl4eCg+Pl7x8fG6ePGipCtzNc6ePVv79+9XXFycvvnmG40YMUJNmjRR7dq17Vw9AAAAHIHVZ9oOHTpU/fv316FDh5SRkaFFixbp8OHD2r17tyIiIgqiRgAAAKDQWLJkiSSpd+/eFssnT56sLl26yM3NTdu3b9eiRYuUmpqqChUqqG3btnruuefsUS4AAAAckNWhbePGjfXVV1/po48+UmBgoH744QfdcccdWrp0qYKCggqiRgAAAKDQiImJue76ChUqaPFiLpQEAACA3Fkd2kpS1apVNWHChPyuBQAAAAAAAACcXp5C2+Tk5Dzv0NPT86aLAQAAAAAAAABnl6fQtnHjxjKZTNfdxjAMmUwm85VvAQAAAAAAAADWy1Nou2jRooKuAwAAAAAAAACgPIa2TZs2zdPO/vrrr1sqBgAAAAAAAACc3U1diOxqycnJWrNmjZYtW6bff/+d6REAAAAAAAAA4BbcdGi7c+dOLV++XBs2bFBAQIDuu+8+jRkzJj9rAwAAAAAAAACnY1VoGx8fr5UrV2r58uVKTk7WAw88oLS0NM2ePVu1atUqqBoBAAAAAAAAwGnkObQdMGCAdu7cqXvuuUejR49Wy5Yt5erqqqVLlxZkfQAAAAAAAADgVPIc2n733Xfq3bu3evbsqdtuu60ASwIAAAAAAAAA5+WS1w0///xzpaSkqEuXLurWrZsWL16s06dPF2RtAAAAAAAAAOB08nymbYMGDdSgQQONHj1aa9euVWRkpKZMmaLMzEz98MMPKl++vDw9PQuyVgAAAAAAYAcHD8YUybbs7eDBGJUp46EzZ1IKvB0AhYtVFyKTJHd3dz3yyCN65JFHdOTIES1fvlzz5s3TtGnTFBoaqg8//LAg6gQAAAAAADZ2KemMZDJp4MD+9i6lSOFxBXAjVoe2V6tRo4ZeeeUVDRs2TFu2bNHy5cvzqy4AAADApu69914tX75cZcqUsVh+/vx5de7cWd98842dKgMA+7l8MVkyDNXtOkwe/lVs0mbCX7/o0ObFNmnLXmz9uDrDYwoUNbcU2mZxdXVVmzZt1KZNm/zYHQAAAGBzJ06cUGZmZrblaWlp+u+//+xQEQA4Dg//KvKuWMsmbaXEx9qkHUdgq8fVmR5ToKjIl9AWAAAAKKyuPoN227Zt8vLyMt/OzMzU9u3bValSJXuUBgAAACdFaAsAAACn9vzzz0uSTCaTRo4cabGuWLFiqlSpUrblAAAAQEEitAUAAIBT+/PPPyVJ4eHhWr58uXx9fe1cEQAAAJydS1426ty5s86dOydJmjVrli5cuFCgRQEAAAC2tnnzZgJbAAAAOIQ8nWl7+PBhXbhwQT4+Ppo9e7Z69uypUqVKFXRtAAAAgE1t375d27dvV2JiYraLkk2ePNlOVQEAAMDZ5Cm0rVOnjkaNGqVGjRrJMAzNnz9f7u7uOW47aNCgfC0QAAAAsIVZs2Zp9uzZCg4Olr+/v0wmk71LAgAAgJPKU2g7efJkzZw5U1u2bJHJZNK2bdvk6uqabTuTyURoCwAAgEJp6dKlmjx5sjp16mTvUgAAAODk8hTa1qhRQ9OnT5ck1a5dWwsXLpSfn1+BFgYAAADYUnp6uho2bGjvMgAAAIC8XYjsan/++SeBLQAAAIqcRx55RNHR0fYuAwAAAMjbmbbXOn78uD799FMdPnxYklSrVi316dNHVatWzdfiAAAAAFu5dOmSvvzyS23fvl1BQUEqVsxyqDxq1Cg7VQYAAABnY3Vou23bNg0cOFB16tQx/3zs119/VYcOHfThhx+qRYsW+V4kAAAAUNBiYmJUu3ZtSdJff/1lsY6LkgEAAMCWrA5tp02bpr59+2r48OEWy6dOnaqpU6cS2gIAAKBQioiIsHcJAAAAgKSbmNP28OHDeuSRR7It79q1qw4dOpQvRQEAAAAAAACAs7L6TFtfX18dOHBAt912m8XyAwcOcIEyAAAAFFq9e/e+7jQIixYtsmE1AAAAcGZWh7bdunXTmDFjFBsbazGn7bx589S3b9/8rg8AAACwiTp16ljcvnz5sg4cOKCDBw+qU6dO9ikKAAAATsnq0Pb555+Xp6enPvnkE7377ruSpICAAA0aNEh9+vTJ9wIBAAAAWxg9enSOy2fOnKnU1FQbVwMAAABnZnVoazKZ1LdvX/Xt21fJycmSJE9Pz3wvDAAAAHAEHTt2VLdu3TRixAh7lwIAAAAnYXVoezXCWgAAABR1u3fvVvHixe1dBgAAAJzILYW2tvDff//pnXfe0bZt23ThwgVVq1ZNkyZNUt26dSVJhmHo/fff17Jly3T+/Hk1bNhQb7zxRrYLpQEAAADXM2jQIIvbhmEoPj5e+/fv13PPPWenqgAAAOCMHDq0PXfunHr27KlmzZpp3rx5KlOmjI4dOyYfHx/zNvPmzVNERISmTJmiypUra8aMGerXr5/Wrl2rEiVK2LF6AAAAFCZeXl4Wt00mk6pXr67BgwcrLCzMTlUBAADAGTl0aDtv3jyVL19ekydPNi+rUqWK+f+GYWjRokUaOHCg2rRpI0l6++23FRoaqk2bNqlDhw42rxkAAACF09VjTgAAAMCeXKzZOD09XU888YSOHj1aQOVY2rx5s4KDgzV48GA1b95cnTp10pdffmleHxcXp/j4eIWGhpqXeXl5qX79+tq9e7dNagQAAEDRsn//fn311Vf66quv9Mcff9i7HAAAADghq860dXNzU0xMTEHVkk1sbKyWLFmiJ598UgMGDNC+ffs0YcIEubm5qXPnzoqPj5ck+fn5WdzPz89PCQkJVrdnMuVL2bgJPPbOhz53PvS586HPnZOt+z0/20tMTNTQoUO1Y8cOeXt7S5LOnz+vZs2aafr06fL19c3TfubOnasNGzboyJEjKlmypEJCQjR8+HDVqFHDvM2lS5c0ZcoUrV27VmlpaQoLC9PYsWNVtmzZ/DsgAAAAFFpWT4/QsWNHLV++XMOHDy+IeiwYhqHg4GC99NJLkqQ77rhDBw8e1NKlS9W5c+d8b8/Pz+vGGyHflSnjYe8SYGP0ufOhz50Pfe6cCnu/v/nmm0pJSdGaNWtUs2ZNSdKhQ4c0YsQITZgwQe+++26e9rNjxw716tVLdevWVUZGht59913169dPa9askbu7uyRp0qRJ+vbbb/Xee+/Jy8tLb775pgYNGqSlS5cW2PEBAACg8LA6tM3IyNCSJUv0448/Kjg4WKVKlbJYP2rUqHwrzt/f3zxgzlKjRg2tX7/evF66clZEQECAeZvExETVrl3b6vYSE5NkGLdQ8E1wdXUp9B9wbtWZMynKyMi0dxk2Q5/T587I2fpcot/pc+dkj343mfLvi/dt27ZpwYIFFuPPWrVqaezYsXrqqafyvJ/58+db3J4yZYqaN2+u33//XU2aNFFSUpIiIyM1depUNW/eXNKVELd9+/bas2ePGjRokC/HAwAAgMLL6tD2r7/+0h133CFJ+vvvvy3WmfL593ANGzbM1sbRo0dVqVIlSVLlypXl7++v7du3q06dOpKk5ORk/fbbb+rZs6fV7RmGbB7a4goed+dDnzsf+tz50OfOqTD3e2Zmptzc3LItL1asmDIzbz6MTkpKkiT5+PhIujJnbnp6usV1GWrWrKmKFStaHdraajoKpjsBABQWBw/ablpP6coUnVWqVJHE+2VRkNWHBdmXed231aFtRESEtXe5aU888YR69uypDz/8UA888ID27t2rL7/8UuPHj5d0JSTu06eP5syZo2rVqqly5cqaMWOGAgIC1KZNG5vVCQAAgMLvrrvu0sSJEzVt2jSVK1dOkvTff/9p8uTJ5jNirZWZmalJkyapYcOGCgwMlCQlJCTIzc3NPG9uFj8/P/M1G/LKVtN7lS7t3GeRAwAc36WkM5LJpIED+9u03ZKl3BXz5wH5+XkVyWk3nemXZGXKeJj70BH60urQNsuxY8d0/PhxNWnSRCVLlpRhGPl+pm29evU0a9Ysvfvuu5o9e7YqV66s0aNHq2PHjuZt+vfvrwsXLmjMmDE6f/68GjVqpI8//lglSpTI11oAAABQtI0ZM0YDBw7Uvffeq/Lly0uS/v33X91+++165513bmqf48aN08GDB/X555/nZ6lmtpre6+zZlIJvBACAW3D5YrJkGKrbdZg8/KvYpM2U+Fjti5ymQ4eOqWrVqnaZdrOgnTnjPGOAM2dSlJiYJD8/rwLty7xO72V1aHvmzBm9+OKL+vnnn2UymbRhwwZVqVJFo0ePlo+Pj0aOHHlTBeemdevWat26da7rTSaThgwZoiFDhuRruwAAAHAuFSpU0MqVK/Xjjz/qyJEjkq5MW3D1NAbWGD9+vLZu3arFixebQ2BJKlu2rNLT03X+/HmLs20TExPN12zIK1tN71XUPoACAIouD/8q8q5Yy6ZtZr1PMu1m4edIfeli7R0mT56sYsWKaevWrSpZsqR5efv27bVt27Z8LQ4AAAAoaNu3b1f79u2VnJwsk8mkFi1aqHfv3urdu7fq1q2rDh066Jdffsnz/gzD0Pjx47Vx40Z9+umn5nnusgQHB8vNzU3bt283Lzty5IhOnjzJRcgAAAAg6SbOtP3hhx80f/58i7MFJOm2227TyZMn860wAAAAwBY+/fRTde/eXZ6entnWeXl5qUePHlqwYIEaN26cp/2NGzdOq1ev1gcffCAPDw/zPLVeXl4qWbKkvLy81LVrV02ZMkU+Pj7y9PTUhAkTFBISQmgLAAAASTcR2qamplqcYZvl7NmzKl68eL4UBQAAANhKTEyMXn755VzXt2jRQp988kme97dkyRJJUu/evS2WT548WV26dJEkjR49Wi4uLho8eLDS0tIUFhamsWPH3kT1AAAAKIqsDm0bN26sqKgovfjii+ZlmZmZ+vjjj9WsWbP8rA0AAAAocAkJCSpWLPdhcbFixXT69Ok87y8mJuaG25QoUUJjx44lqAUAAECOrA5tX375ZfXt21f79+9Xenq63nnnHR06dEjnzp0zn1UAAAAAFBblypXTwYMHVa1atRzXx8TEWH2BMAAAAOBWWH0hssDAQK1fv16NGjXSvffeqwsXLui+++7TypUrVbVq1YKoEQAAACgwrVq10owZM3Tp0qVs6y5evKiZM2eqdevWdqgMAAAAzsrqM22lKxdRGDhwYH7XAgAAANjcwIEDtWHDBrVr1069evVS9erVJUlHjhzR559/royMDA0YMMDOVQIAAMCZ3FRoe+7cOS1fvlyHDx+WJNWqVUtdunRR6dKl87M2AAAAoMCVLVtWS5cu1RtvvKF3331XhmFIkkwmk8LCwjRmzBiVLVvWzlUCAADAmVgd2u7cuVMDBgyQl5eXgoODJUkRERGaPXu2PvzwQzVp0iTfiwQAAAAKUqVKlTRv3jydO3dOx44dkyRVq1ZNPj4+dq4MAAAAzsjq0Hb8+PFq37693njjDbm6ukqSMjIyNG7cOI0fP17R0dH5XiQAAABgCz4+PqpXr569ywAAAICTs/pCZMeOHdOTTz5pDmwlydXVVX379jWflQAAAAAAAAAAuDlWh7Z33HGHjhw5km35kSNHVLt27XwpCgAAAAAAAACcVZ6mR/jzzz/N/+/Tp48mTpyoY8eOqX79+pKk3377TZ999pmGDx9eMFUCAAAAAAAAgJPIU2jbqVMnmUwm85V0Jemdd97Jtt2wYcPUvn37/KsOAAAAAAAAAJxMnkLbb775pqDrAAAAAAAAAAAoj6FtpUqVCroOAAAAAAAAAIDyGNpe67///tOuXbt0+vRpZWZmWqzr06dPvhQGAAAAAAAAAM7I6tB2xYoVGjNmjNzc3FSmTBmLdSaTidAWAAAAAAAAAG6B1aHtjBkz9Pzzz+vZZ5+Vi4tLQdQEAAAAAAAAAE7L6tT14sWL6tChA4EtAAAAAAAAABQAq5PXrl27at26dQVRCwAAAAAAAAA4PaunRxg2bJieffZZbdu2TYGBgSpWzHIXo0aNyrfiAAAAAAAAAMDZWB3azp07V99//72qV6+ebZ3JZMqXogAAAAAAAADAWVkd2i5YsECTJk1Sly5dCqIeAAAAAAAAAHBqVs9pW7x4cTVs2LAgagEAAAAAAAAAp2d1aNunTx8tXry4IGoBAAAAAAAAAKdn9fQIe/fu1U8//aQtW7bo9ttvz3YhslmzZuVbcQAAAAAAAADgbKwObb29vdW2bduCqAUAAAAAAAAAnJ7Voe3kyZMLog4AAAAAAAAAgG5iTlsAAAAAAAAAQMGx+kzb8PBwmUymXNd/8803t1QQAAAAAAAAADgzq0PbJ554wuL25cuX9ccff+j7779Xv3798q0wAAAAAAAAAHBGtxzaZvnss8+0f//+Wy4IAAAAAAAAAJxZvs1pe/fdd2v9+vX5tTsAAAAAAAAAcEr5FtquW7dOpUuXzq/dAQAAAAAAAIBTsnp6hE6dOllciMwwDCUkJOj06dMaO3ZsvhYHAAAAAAAAOLKDB2NUpoyHzpxJKfC2fH39VLlylQJvB/ZndWjbpk0bi9smk0m+vr5q2rSpatasmW+FAQAAAAAAAI7qUtIZyWTSwIH9bdZmyZKl9OOPvxDcOgGrQ9tBgwYVRB0AAAAAAABAoXH5YrJkGKrbdZg8/As+RE2Jj9W+yGk6fTqR0NYJWB3aAgAAAAAAALjCw7+KvCvWsncZKGLyHNrWrl3bYi7bnJhMJv3xxx+3XBQAAAAAAAAAOKs8h7azZs3Kdd2ePXsUERGhzMzMfCkKAAAAAAAAAJxVnkPbay9AJklHjhzRtGnTtGXLFj300EMaPHhwvhYHAAAAFDY7d+7U/PnztX//fsXHx2v27NkWY+mRI0dq5cqVFvcJCwvT/PnzbV0qAAAAHNRNzWn733//aebMmYqKilJYWJiioqIUGBiY37UBAAAAhU5qaqqCgoLUtWvXXC/i27JlS02ePNl8u3jx4rYqDwAAAIWAVaFtUlKSPvzwQy1evFh16tTRwoUL1bhx44KqDQAAACh0WrVqpVatWl13m+LFi8vf399GFQEAAKCwyXNoO2/ePH388ccqW7aspk2bluN0CQAAAABubMeOHWrevLm8vb1111136cUXX1SZMmWs3s8NrhOcb2zVDgAAyBvemwtG1uNakI9vXved59B22rRpKlmypKpWraqoqChFRUXluN31LlgGAAAAOLuWLVvqvvvuU+XKlRUbG6t3331X/fv31xdffCFXV1er9uXn51VAVVoqXdrDJu0AAIAbK1PGQ2XL2mYMUKaM84wBypTxMI+tbDXGup48h7adOnWSiRgfAAAAuCUdOnQw/z8oKEhBQUFq06aN+exbayQmJskw8rvC7M6eTSn4RgAAQJ6cOZOihIQkm7XlLM6cSVFiYpL8/LwKdIxlMuUtFM5zaDtlypRbKggAAABAdlWqVFGZMmV07Ngxq0Nbw5BNQltbtAEAAPKO9+aCkfW42mqMdT0u9m0eAAAAcG7//vuvzp49y4XJAAAAYJbnM20BAAAA3FhKSoqOHz9uvh0XF6cDBw7Ix8dHPj4+mjVrltq1a6eyZcsqNjZW77zzjqpVq6aWLVvasWoAAAA4EkJbAAAAIB/t379fffr0Md+ePHmyJKlz585644039NdffykqKkpJSUkKCAhQixYtNGTIEBUvXtxeJQMAAMDBENoCAAAA+ahZs2aKiYnJdf38+fNtWA0AAAAKI+a0BQAAAAAAAAAHQmgLAAAAAAAAAA6E0BYAAAAAAAAAHEihCm0/+ugjBQUFaeLEieZlly5d0rhx49SsWTOFhITohRdeUEJCgh2rBAAAAAAAAICbV2hC271792rp0qUKCgqyWD5p0iRt2bJF7733niIiInTq1CkNGjTITlUCAAAAAAAAwK0pFKFtSkqKXn75ZU2YMEE+Pj7m5UlJSYqMjNTIkSPVvHlzBQcHa9KkSdq9e7f27Nljv4IBAAAAAAAA4CYVs3cBeTF+/Hi1atVKoaGhmjNnjnn5/v37lZ6ertDQUPOymjVrqmLFitqzZ48aNGhgVTsmU35VDGvx2Dsf+tz50OfOhz53Trbud55nAAAAKIocPrRds2aN/vjjDy1fvjzbuoSEBLm5ucnb29tiuZ+fn+Lj461uy8/P66brxM0rU8bD3iXAxuhz50OfOx/63DnR7wAAAED+cOjQ9p9//tHEiRP1ySefqESJEgXeXmJikgyjwJux4Orq4vQfcM6cSVFGRqa9y7AZ+pw+d0bO1ucS/U6fOyd79LvJxBfvAAAAKHocOrT9/ffflZiYqC5dupiXZWRkaOfOnfrss880f/58paen6/z58xZn2yYmJsrf39/q9gxDNg9tcQWPu/Ohz50Pfe586HPnRL8DAAAAt86hQ9u77rpL0dHRFstGjRqlGjVqqH///qpQoYLc3Ny0fft2tWvXTpJ05MgRnTx50ur5bAEAAAAAAADAETh0aOvp6anAwECLZe7u7ipdurR5edeuXTVlyhT5+PjI09NTEyZMUEhICKEtAAAAAAAAgELJoUPbvBg9erRcXFw0ePBgpaWlKSwsTGPHjrV3WQAAAAAAAABwUwpdaBsREWFxu0SJEho7dixBLQAAAAAAAIAiwcXeBQAAAAAAAAAA/ofQFgAAAAAAAAAcCKEtAAAAAAAAADgQQlsAAAAAAAAAcCCEtgAAAAAAAADgQAhtAQAAAAAAAMCBENoCAAAAAAAAgAMhtAUAAAAAAAAAB0JoCwAAAAAAAAAOhNAWAAAAAAAAABwIoS0AAAAAAAAAOBBCWwAAAAAAAABwIIS2AAAAAAAAAOBACG0BAAAAAAAAwIEQ2gIAAAAAAACAAyG0BQAAAAAAAAAHQmgLAAAAAAAAAA6kmL0LAAAAAAAAAJA3Bw/GFMm2YInQFgAAAAAAAHBwl5LOSCaTBg7sb+9SYAOEtgAAAAAAAICDu3wxWTIM1e06TB7+VWzSZsJfv+jQ5sU2aQuWCG0BAAAAAACAQsLDv4q8K9aySVsp8bE2aQfZcSEyAAAAAAAAAHAghLYAAAAAAAAA4EAIbQEAAIB8tHPnTg0YMEBhYWEKCgrSpk2bLNYbhqEZM2YoLCxM9erVU9++fXX06FH7FAsAAACHRGgLAAAA5KPU1FQFBQVp7NixOa6fN2+eIiIi9MYbb+jLL79UqVKl1K9fP126dMnGlQIAAMBRcSEyAAAAIB+1atVKrVq1ynGdYRhatGiRBg4cqDZt2kiS3n77bYWGhmrTpk3q0KGDLUsFAACAg+JMWwAAAMBG4uLiFB8fr9DQUPMyLy8v1a9fX7t377Z6fyaT7f4BAAAUdVljHkcYV3GmLQAAAGAj8fHxkiQ/Pz+L5X5+fkpISLB6f35+XvlS142ULu1hk3YAAADspUwZD/PYylZjrOshtAUAAAAKqcTEJBlGwbdz9mxKwTcCAABgR2fOpCgxMUl+fl4FOsYymfIWCjM9AgAAAGAj/v7+kqTExESL5YmJiSpbtqzV+zMM2/0DAAAo6rLGPI4wriK0BQAAAGykcuXK8vf31/bt283LkpOT9dtvvykkJMSOlQEAAMCRMD0CAAAAkI9SUlJ0/Phx8+24uDgdOHBAPj4+qlixovr06aM5c+aoWrVqqly5smbMmKGAgAC1adPGjlUDAADAkRDaAgAAAPlo//796tOnj/n25MmTJUmdO3fWlClT1L9/f124cEFjxozR+fPn1ahRI3388ccqUaKEvUoGAACAgyG0BQAAAPJRs2bNFBMTk+t6k8mkIUOGaMiQITasCgAAAIUJc9oCAAAAAAAAgAMhtAUAAAAAAAAAB0JoCwAAAAAAAAAOhNAWAAAAAAAAABwIoS0AAAAAAAAAOBBCWwAAAAAAAABwIIS2AAAAAAAAAOBACG0BAAAAAAAAwIEQ2gIAAAAAAACAAyG0BQAAAAAAAAAHQmgLAAAAAAAAAA6E0BYAAAAAAAAAHAihLQAAAAAAAAA4EEJbAAAAAAAAAHAghLYAAAAAAAAA4EAIbQEAAAAAAADAgRDaAgAAAAAAAIADIbQFAAAAAAAAAAdCaAsAAAAAAAAADoTQFgAAAAAAAAAciEOHtnPnzlXXrl0VEhKi5s2b67nnntORI0cstrl06ZLGjRunZs2aKSQkRC+88IISEhLsVDEAAAAAAAAA3BqHDm137NihXr166csvv9SCBQt0+fJl9evXT6mpqeZtJk2apC1btui9995TRESETp06pUGDBtmxagAAAAAAAAC4ecXsXcD1zJ8/3+L2lClT1Lx5c/3+++9q0qSJkpKSFBkZqalTp6p58+aSroS47du31549e9SgQQM7VA0AAAAAAAAAN8+hQ9trJSUlSZJ8fHwkSfv371d6erpCQ0PN29SsWVMVK1a8qdDWZMq3UmElHnvnQ587H/rc+dDnzsnW/c7zDAAAAEVRoQltMzMzNWnSJDVs2FCBgYGSpISEBLm5ucnb29tiWz8/P8XHx1vdhp+fV77UCuuUKeNh7xJgY/S586HPnQ997pzodwAAACB/FJrQdty4cTp48KA+//zzAmsjMTFJhlFgu8+Rq6uL03/AOXMmRRkZmfYuw2boc/rcGTlbn0v0O33unOzR7yYTX7wDAACg6CkUoe348eO1detWLV68WOXLlzcvL1u2rNLT03X+/HmLs20TExPl7+9vdTuGIZuHtriCx9350OfOhz53PvS5c6LfAQAAgFvnYu8CrscwDI0fP14bN27Up59+qipVqlisDw4Olpubm7Zv325eduTIEZ08eZKLkAEAAAAAAAAolBz6TNtx48Zp9erV+uCDD+Th4WGep9bLy0slS5aUl5eXunbtqilTpsjHx0eenp6aMGGCQkJCCG0BAAAAAAAAFEoOHdouWbJEktS7d2+L5ZMnT1aXLl0kSaNHj5aLi4sGDx6stLQ0hYWFaezYsTavFQAAAAAAAADyg0OHtjExMTfcpkSJEho7dixBLQAAAAAAAIAiwaHntAUAAAAAAAAAZ0NoCwAAAAAAAAAOhNAWAAAAAAAAABwIoS0AAAAAAAAAOBBCWwAAAAAAAABwIIS2AAAAAAAAAOBAitm7AAAAAMCZzJw5U7NmzbJYVr16da1bt85OFQEAAMDRENoCAAAANnb77bdrwYIF5tuurq52rAYAAACOhtAWAAAAsDFXV1f5+/vbuwwAAAA4KEJbAAAAwMaOHTumsLAwlShRQg0aNNCwYcNUsWJFe5cFAAAAB0FoCwAAANhQvXr1NHnyZFWvXl3x8fGaPXu2evXqpejoaHl6elq1L5OpgIq0UzsAAAD2lDXmKcixT173TWgLAAAA2FCrVq3M/69du7bq16+v1q1b6+uvv1a3bt2s2pefn1d+l5ej0qU9bNIOAACAvZQp42EeW9lqjHU9hLYAAACAHXl7e+u2227T8ePHrb5vYmKSDKMAirrG2bMpBd8IAACAHZ05k6LExCT5+XkV6BjLZMpbKExoCwAAANhRSkqKYmNjb+rCZIYhm4S2tmgDAADA3rLGPLYaY10PoS0AAABgQ2+99ZZat26tihUr6tSpU5o5c6ZcXFz04IMP2rs0AAAAOAhCWwAAAMCG/v33X7300ks6e/asfH191ahRI3355Zfy9fW1d2kAAABwEIS2AAAAgA1Nnz7d3iUAAADAwbnYuwAAAAAAAAAAwP8Q2gIAAAAAAACAAyG0BQAAAAAAAAAHQmgLAAAAAAAAAA6E0BYAAAAAAAAAHAihLQAAAAAAAAA4EEJbAAAAAAAAAHAghLYAAAAAAAAA4EAIbQEAAAAAAADAgRDaAgAAAAAAAIADIbQFAAAAAAAAAAdCaAsAAAAAAAAADoTQFgAAAAAAAAAcCKEtAAAAAAAAADgQQlsAAAAAAAAAcCCEtgAAAAAAAADgQAhtAQAAAAAAAMCBENoCAAAAAAAAgAMhtAUAAAAAAAAAB0JoCwAAAAAAAAAOhNAWAAAAAAAAABwIoS0AAAAAAAAAOBBCWwAAAAAAAABwIIS2AAAAAAAAAOBACG0BAAAAAAAAwIEQ2gIAAAAAAACAAyG0BQAAAAAAAAAHQmgLAAAAAAAAAA6E0BYAAAAAAAAAHAihLQAAAAAAAAA4EEJbAAAAAAAAAHAghLYAAAAAAAAA4EAIbQEAAAAAAADAgRDaAgAAAAAAAIADIbQFAAAAAAAAAAdCaAsAAAAAAAAADoTQFgAAAAAAAAAcSJEJbT/77DOFh4erbt266tatm/bu3WvvkgAAAIBcMX4FAABAbopEaLt27VpNnjxZzz//vFauXKnatWurX79+SkxMtHdpAAAAQDaMXwEAAHA9RSK0XbBggbp3766uXbuqVq1aGjdunEqWLKnIyEh7lwYAAABkw/gVAAAA11PoQ9u0tDT9/vvvCg0NNS9zcXFRaGiodu/ebcfKAAAAgOwYvwIAAOBGitm7gFt15swZZWRkyM/Pz2K5n5+fjhw5YtW+XFwkw8jP6qxQtaZUvKSdGreT8pXM/3Up9F8f3AT63PnQ587J2fqdPne+Ppfs2u8mk23byw+FcfxarJirvLy8pORTuny6eME3KMn10jmbtmnr9uzRJsdY+NuzR5scY9Fok2MsGm1yjAUk+ZS8vLzk6upqHssW5Bgrr+NXk2HYLabMF//995/uvvtuLV26VCEhIeblb7/9tnbu3Klly5bZsToAAADAEuNXAAAA3EihPwemTJkycnV1zXbRhsTERJUtW9ZOVQEAAAA5Y/wKAACAGyn0oW3x4sV15513avv27eZlmZmZ2r59u8WZCwAAAIAjYPwKAACAGyn0c9pK0pNPPqkRI0YoODhY9erV06effqoLFy6oS5cu9i4NAAAAyIbxKwAAAK6nSIS27du31+nTp/X+++8rPj5ederU0ccff8zPywAAAOCQGL8CAADgegr9hcgAAAAAAAAAoCgp9HPaAgAAAAAAAEBRQmgLAAAAAAAAAA6E0BYAAAAAAAAAHAihLQAAAAAAAAA4EELbImL37t2qU6eOnnnmmVy3Wb16terUqaNx48ZlW/fzzz8rKCjI/C80NFQvvPCCYmNjzduEh4dr4cKFBVE+8ii3fo6Li1NQUJDq1Kmj//77z2LdqVOndMcddygoKEhxcXGSpN69e1v097X/duzYIUkaOXKkgoKC9NFHH1nsc9OmTQoKCirAI3VO8fHxmjBhgu677z7VrVtXoaGhevTRR/X555/rwoUL5u1+/fVX9e/fX02aNFHdunX10EMPacGCBcrIyMi2zy1btujxxx9XSEiI6tevr65du2rFihU5tr9+/Xr16dNHTZo0Ub169dSuXTuNGjVKf/zxh3mbFStWqHHjxvl/8LCQ9bc3ZsyYbOvGjRunoKAgjRw5UpJ0+vRpjR07Vvfcc4+Cg4PVokUL9evXT7t27TLfJzw8PNvf+d13362ZM2de97WAv3PbuVE/zJw5U5K0ceNGde/eXY0aNVJISIg6dOigiRMnmvdjzd/o/fffr+DgYMXHxxfIMaFw2blzpwYMGKCwsDAFBQVp06ZNN7zPzz//rM6dOys4OFj33Xdfru8vsB1r+3HDhg168sknddddd6lhw4bq0aOHtm3bZqNqcT038zeZZdeuXbrjjjv08MMPF2CFyIub6ce0tDRNnz5drVu3VnBwsMLDw7V8+XIbVIvruZm+XLVqlTp27Kj69esrLCxMo0aN0pkzZ2xQLXIzd+5cde3aVSEhIWrevLmee+45HTly5Ib3+/rrr3X//febP39/++23NqiW0LbIWL58uR5//HHt3LkzW2h39TZPP/201qxZo0uXLuW4zbp167Rt2zbNmDFDBw8e1IABA3IMgmAfN+rncuXKKSoqymJZVFSUypUrZ7Fs5syZ+v777y3+bdmyRYGBgQoODlb9+vXN25YoUULz5s3TuXPnCuSYcEVsbKw6d+6sH374QUOHDlVUVJS++OILPf3009q6dat+/PFHSVcCm969e6t8+fJatGiRvv76a/Xp00dz5szR0KFDZRiGeZ8RERF67rnn1LBhQy1btkyrVq1Shw4dNHbsWL311lsW7b/zzjsaOnSo6tSpozlz5mjdunWaNm2aqlSpomnTptn0scAVFSpU0Nq1a3Xx4kXzskuXLmn16tWqWLGiedkLL7ygAwcOaMqUKVq/fr3mzJmjpk2b6uzZsxb7Gzx4sMXffFRUlJ566imLZeXLl8+2HWzj6sd89OjR8vT0tFj21FNPafv27Ro6dKjatm2rZcuWacWKFRo6dKguX75sdXu//PKLLl26pHbt2mnlypUFcEQobFJTUxUUFKSxY8fmafvY2Fg9++yzatasmb766is98cQTeu211wj87Mzafty5c6dCQ0P10UcfacWKFWrWrJkGDhxo8YUt7MPavsxy/vx5jRgxQs2bNy+gymCNm+nHIUOGaPv27Zo4caJ5TF69evUCrBJ5YW1f7tq1SyNGjNAjjzyi1atX67333tO+ffv0+uuvF3CluJ4dO3aoV69e+vLLL7VgwQJdvnxZ/fr1U2pqaq73+fXXXzVs2DA98sgjioqK0r333qvnn39ef/31V4HXW6zAW0CBS0lJ0dq1axUZGamEhAStXLlSAwYMsNgmNjZWu3fv1syZM/Xzzz9rw4YNeuihh7Lty8/PT97e3goICNDzzz+v4cOH69ixY6pRo4atDge5yEs/d+rUSStWrNCzzz5rXhYZGalOnTrpgw8+MC8rXbp0tv2/9tprOnPmjJYvX64SJUqYl4eGhurYsWOaO3euXnnllfw/MEiS3njjDbm6uioyMlLu7u7m5VWqVFGbNm1kGIZSU1P12muvKTw8XG+++aZ5m27dusnPz08DBw7U119/rfbt2+uff/7RW2+9pSeeeEIvvfSSedunnnpKbm5umjBhgu6//37Vr19fe/bs0ccff6xXX31Vffr0MW9bsWJFBQcHWwTBsJ077rhDsbGx2rBhgzp27CjpyhlRFSpUUOXKlSVd+WD2yy+/KCIiQk2bNpUkVapUSfXq1cu2Pw8PD/n7++e4PIurq2uu26FgXf2Ye3l5yWQyZeuHzZs3KyQkRE8//bR5WfXq1dWmTRur24uMjNSDDz6oJk2aaOLEidf9pQ6cQ6tWrdSqVas8b7906VJVrlzZfNZ/zZo1tWvXLi1cuFAtW7YsqDJxA9b246uvvmpx+6WXXtI333yjzZs364477sjv8mAFa/syy9ixY/Xggw/K1dXVqrNzUTCs7cfvvvtOO3fu1KZNm8yf2bLGfbAva/tyz549qlSpkvnzVZUqVdSjRw/NmzevoEpEHsyfP9/i9pQpU9S8eXP9/vvvatKkSY73WbRokVq2bGkeg7/44ov68ccftXjxYo0fP75A6+VM2yLg66+/Vo0aNVSjRg117NhRkZGR2UKWFStWqFWrVvLy8lLHjh3z9POKkiVLSpLS09MLpG5YJy/9HB4ernPnzumXX36RdOVMqvPnz6t169bX3fdnn32mqKgovf/++ypfvrzFOhcXF7300ktavHix/v333/w9KEiSzpw5ox9++EG9evWyCGyvZjKZ9MMPP+js2bN66qmnsq0PDw/XbbfdptWrV0u6MtVBenp6jtv26NFD7u7u5m1Xr14td3d3PfbYY7m2Dfu4djqLyMhIdenSxXzb3d1d7u7u2rRpk9LS0uxRImzI399fhw4duuVv9ZOTk7Vu3Tp17NhRLVq0UHJysvl9A8irPXv2ZDuTLywsTHv27LFPQcgXmZmZSklJyfELfji+yMhIxcbGatCgQfYuBTdp8+bNCg4O1scff6yWLVuqXbt2euuttyx+eYXCoUGDBvr333/17bffyjAMJSQkaP369Tf1ZQwKTlJSkiTJx8cn123sOeYhtC0Cli9fbj4Lq2XLlkpKSjLPSSpdGXytXLnSvE379u21a9cui/lqr3Xq1CnNnz9f5cqV46cYDuJG/SxJbm5u5kBXujJw69ixo9zc3HLd786dOzV58mSNHTtWDRs2zHGb++67T3Xq1NH777+fT0eDqx0/flyGYWT7W2vWrJlCQkIUEhKid955R3///bekK2cz5aRGjRo6evSoJOnvv/+Wl5eXAgICsm1XvHhxValSxbzt0aNHVaVKFRUr9r8fXyxYsMDcdkhIiPnNDLbVsWNH7dq1SydOnNCJEyf066+/ml8HJKlYsWKaMmWKoqKi1LhxYz366KN699139eeff2bb19SpUy36dNGiRbY8FOSDxx9/3DyPVnh4uIYOHarly5dbHdivXbtW1apV0+233y5XV1e1b9+eufJgtYSEBJUtW9ZiWdmyZZWcnEy4UIjNnz9fqampeuCBB+xdCqx09OhRTZs2Te+8847FmA6FS2xsrHbt2qWDBw9q9uzZGj16tNavX5/jdWng2Bo1aqR33nlHL774ovm6E56enjleswL2kZmZqUmTJqlhw4YKDAzMdbucxjx+fn5KSEgo6BIJbQu7I0eOaN++fXrwwQclXfkAf+2Hrx9++EEXLlwwf6Pj6+urFi1amIO9q7Vq1UoNGjRQy5YtdeHCBc2cOVPFixe3zcEgV3np5yxdu3bVunXrFB8fr3Xr1qlr16657vfkyZMaPHiwunfvrm7dul23huHDhysqKkqHDx++tYNBni1fvlxRUVGqVauWRShji+kKunbtqqioKI0bN06pqalMkWAnvr6+uueee7Ry5UqtWLFC99xzj3x9fS22adeunbZt26Y5c+aoZcuW2rFjh7p06ZLtgkD9+vVTVFSU+V+nTp1seCTID+7u7vroo4+0ceNGDRw4UO7u7nrrrbf0yCOPWFys8EayvtDL0rFjR61bt07JyckFUTaAQiI6OlqzZ8/We++9Jz8/P3uXAytkZGRo2LBheuGFFzjhppAzDEMmk0lTp05VvXr11KpVK40cOVIrV67kC7FC5tChQ5o4caKef/55RUZG6uOPP9aJEyesnqcaBWfcuHE6ePCgpk+fbu9ScsVXcIXc8uXLdfnyZYu5wwzDUPHixTVmzBh5eXlp+fLlOnv2rMXFpTIzMxUTE6PBgwfLxeV/2f1nn30mT09P+fr6ytPT06bHgtzdqJ+vFhQUpBo1auill15SzZo1FRgYqAMHDmTb58WLFzVo0CDVqlVLo0ePvmENTZo0UVhYmKZNm2bx82zcuqpVq8pkMpnPpM1SpUoVSf+bqiRrEH748OEcz4o+cuSI+Szc6tWrKykpSf/991+2C9GlpaUpNjZWzZo1kyTddttt2rVrl9LT081nZXt7e8vb25spMRxA165dzXMl5TbIK1GihFq0aKEWLVro+eef16uvvqqZM2da/K2WKVNG1apVs0nNKFhVq1ZV1apV1a1bNw0YMED333+/1q5de90v6bIcOnRIe/bs0d69ezV16lTz8oyMDK1du1bdu3cvyNJRhJQtWzbbGSYJCQny9PQ0v2+h8FizZo1ee+01zZgxQ6GhofYuB1ZKSUnR/v37deDAAfN1DzIzM2UYhu644w7Nnz+fC5MVEv7+/ipXrpy8vLzMy2rWrCnDMPTvv//qtttus19xsMrcuXPVsGFD8zyotWvXVqlSpdSrVy+9+OKLOf4iErYzfvx4bd26VYsXL842ReS1chrzJCYmZjv7tiBwpm0hdvnyZX311VcaOXKkxdlTX331lQICArR69WqdOXNG33zzjaZPn26xTVRUlM6dO5ftyuCVK1dW1apVCWwdSF76+Vpdu3bVjh07rvsB/tVXX9XZs2c1Y8aMPP+EatiwYdqyZYt2795908eD7MqUKaMWLVpo8eLF171qZYsWLVS6dGktWLAg27pvvvlGR48eNZ+N3bZtW7m5ueW47dKlS5WammretkOHDkpNTdXnn3+eT0eE/NSyZUulp6fr8uXLCgsLy9N9atWqdd3nEoqOypUrq2TJknk+03b58uVq0qSJvvrqK4v3lCeffJIpEmCVBg0a6KeffrJY9uOPP6pBgwb2KQg3bfXq1Ro1apSmTZume+65x97l4CZ4enoqOjra4nX90UcfVfXq1RUV9X/t3XtMFGfbBvBrBcSwykGlUiwCgoIiIASjggULRfBUKxSrbsEW00pE0Spy0CAgWA4eQKlQW0CBouG4olVK0MSKEW0UreK5iEWjFeTYQEEW/P4w37xu0b7wiuy2Xr/EZPeZmWfumckuj/c+c88huck7pNxsbW1RW1uL1tZWoa26uhqDBg36r4klUi7t7e1yE+SAZw/9BQbmzkl6sadPn2LLli0oLS1FRkaGMFHq7yhyzMOZtv9gJ0+eRHNzMz766CO5X+KAZwmb/Px8dHR0QFtbG7Nnz+7xMCEnJyfk5+fD0dGx1/t89OhRj1mb+vr6f1u0mV5Nb67zX5/SvGjRIri7u0NTU/OFfaampqKkpAQpKSno6upCXV2d3PJhw4a9cJaMmZkZ5s+fj6ysrFc8Kvqr8PBwLFmyBJ6enli9ejXMzMwgEolw5coV3LlzBxYWFtDQ0EBkZCTWrVuHsLAwSCQSDB06FOXl5di2bRvc3NyEGnT6+voIDAxEXFwc1NXVhdrGJ06cwM6dO+Hr6ysM4G1sbODr64u4uDg8ePAArq6uePvtt1FXV4f8/HyIRCK5AUdXV1eP74HBgwe/tNYuvRoVFRUUFxcLr5/X2NiINWvWwNPTE2ZmZhCLxaisrERqaipcXFwUES69RklJSUK5I319ffzxxx/IysqCTCaTmxn3ss/omDFjUFRUhICAgB51u7y8vLBv3z7cvn0b48aNG5DjIeXS2tqKmpoa4f39+/dx/fp1aGlpQV9fHzt27MCjR48QHx8PAFi8eDGys7MRHx8PT09PnD17FsXFxdi7d6+iDoHQ9+t45MgRhISEYOPGjbC2thbGhEOGDOkx7qSB1ZdrOWjQoB7f6yNGjIC6uvrf1mmk16+vn8l58+YhOTkZoaGhCAgIQGNjI7Zt2wZPT0/exaBgfb2W7733HsLCwnDgwAG8++67qK2txVdffQUrK6sed0LSwImMjMQPP/yA5ORkiMVi4e/e8zmQoKAgjBo1CuvXrwcA+Pj4wNvbG+np6XBycsKxY8dQWVkp3A35OjFp+w+Wn58Pe3v7Fw6o3NzckJqaiqtXr2LJkiUvfPr7rFmzEBQUhIaGhl7vMz09Henp6XJt8fHxWLBgQd8PgHqlN9f5r3UIVVVVe9S9fN6BAwfQ2dkp3KrxVzExMS8tgRAQEIBjx4714QioN8aMGQOpVIq9e/cKf/DV1NRgamoKX19fLF26FADg7u6OkSNHIiUlBRKJBB0dHTAyMoKfnx+WLVsm91n/9NNPYWBggPT0dGRmZqKrqwumpqaIiIjoMQs7ODgYlpaWOHjwIAoKCtDe3o4RI0bAzs4OOTk5crPv29raetRDHTNmDEpLS1/fCXrDvezuB7FYDGtra2RkZKCmpgYymQx6enrCbfP07zJlyhQcOHAAwcHBePz4MbS0tDBhwgSkpaVh7Nixwnov+4wGBgaiqakJrq6uPfo2MTGBiYkJ8vPzERoa+roPhZRQZWUlfHx8hPcxMTEAgIULFyI2NhZ1dXV4+PChsNzAwAB79+5FTEwMMjMzoaenh+jo6B4/JNPA6ut1zM3NhUwmw5YtW+T+8/n/65Pi9PVaknLq63UUi8VIT09HdHQ0PD09hQlYa9euHejQ6S/6ei09PDzQ2tqK7OxsxMXFYdiwYZg2bRo2bNgw4LHTfxw8eBAA4O3tLdf+fA7k4cOHcpOWbG1tsX37diQmJmLnzp0wMjLCnj17BuRHMdFTzssmIiIiIiIiIiIiUhqsaUtERERERERERESkRJi0JSIiIiIiIiIiIlIiTNoSERERERERERERKREmbYmIiIiIiIiIiIiUCJO2REREREREREREREqESVsiIiIiIiIiIiIiJcKkLREREREREREREZESYdKWiIiIiIiIiIiISIkwaUtE9IY6d+4czMzM0NLS8kr9ODs7Y//+/f0TFBERERH9I5iZmeH48eOKDoOI6F+LSVsiIiXQ0NCA8PBwzJw5E5MmTYKDgwOWL1+OCxcuKDo0IiIiInrD1NXVISoqCi4uLpg0aRKcnJzg5+eH8vJyRYfWL548eYINGzbA1tYWbm5uOHPmjNzy1NRUREVFKSg6IqJnVBUdABERAatXr0ZnZydiY2NhYGCA+vp6lJeXo6mpSdGhEREREdEb5P79+1iyZAk0NTURFBSE8ePHQyaT4fTp04iMjMSPP/6o6BBfWU5ODq5evYqcnBycOnUK69evx5kzZyASiXDv3j3k5eWhoKBA0WES0RuOM22JiBSspaUF58+fR2BgIKZNm4bRo0fDysoKK1asgIuLC0JDQ7FixQq5bTo7OzF9+nTk5eUBALy9vREVFYWtW7diypQpsLe3R25uLtra2hAaGgobGxu4urrip59+6rH/iooKzJ8/H5aWlli0aBFu3bolt7ykpARz587FpEmT4OzsjPT09Nd3MoiIiIhIoSIjIyESiZCXlwc3NzcYGxtj3Lhx+Oyzz5Cbmyu3bmNjI/z9/WFtbY1Zs2bhxIkTwrKuri5s3LgRzs7OsLKygpubGzIyMuS2DwkJwcqVK5GWloYZM2Zg6tSpiIyMRGdnp7BObW0tvvjiC1hZWcHZ2RlHjhzpUZ6rpaUFmzZtwrRp02BrawsfHx/cuHHjpcdYVVUFZ2dnjBs3DhKJBA0NDWhsbAQAREREIDAwEEOHDn2V00hE9MqYtCUiUjANDQ1oaGjg+PHjePLkSY/lXl5eKCsrQ21trdB28uRJtLe3Y86cOUKbVCqFjo4O8vLy8MknnyAiIgJr1qyBjY0NpFIpHBwcEBQUhD///FOu//j4eISEhCA/Px/Dhw+Hn5+fMFCurKzE2rVrMWfOHBw5cgSrVq3Crl27UFhY+JrOBhEREREpSlNTE8rKyiCRSKChodFjuaamptz7r7/+GrNnz8bhw4fh6OiIwMBA4U6x7u5u6OnpYdeuXTh69Cj8/f2RkJCAY8eOyfVx7tw51NTUICMjA7GxsZBKpZBKpcLy4OBg1NbWIisrC0lJScjNzUV9fb1cH2vWrEF9fT2+++47FBYWwsLCAsuWLXvpXWvm5ua4cOEC2tvbcfr0aejq6kJHRweHDx+Guro6XF1d/4ezR0TUv5i0JSJSMFVVVcTGxuLQoUOws7PD4sWLsXPnTmF2gK2tLYyNjVFUVCRsU1BQAHd3d4jFYqHN3NwcK1euhJGREVasWAF1dXXo6Ohg0aJFMDIygr+/P5qamnDz5k25/a9atQoODg4wMzNDbGws6uvrUVpaCgDYt28fpk+fDn9/fxgbG8PDwwMSiQRpaWkDcGaIiIiIaCDV1NTg6dOnGDt2bK/WX7hwIebNmwdDQ0OsW7cObW1tuHz5MgBATU0NAQEBsLS0hIGBAT744AN4eHj0KK+gpaWFzZs3w8TEBO+99x6cnJyE2rlVVVU4c+YMoqKiYG1tDQsLC0RHR6O9vV3Y/vz587h8+TJ2794NS0tLGBkZITg4GJqamigpKXlh3J6enjA3N8ecOXOQkpKCxMRENDc3Y/fu3QgLC0NCQgJcXV2xfPlyPHr06H85lUREr4w1bYmIlICbmxtmzpyJ8+fP49KlSygrK0Nqaiqio6Ph4eEBLy8v5OTk4PPPP8fjx49RVlbW4/YyMzMz4bWKigq0tbUxfvx4oW3kyJEA0GNmwuTJk4XX2traMDY2xp07dwAAd+7cgYuLi9z6tra2yMzMRFdXF1RUVPrl+ImIiIhI8Z4+fdqn9Z8ff2poaGDo0KFoaGgQ2rKzs1FQUIAHDx6go6MDnZ2dMDc3l+vD1NRUbkypq6srlOuqrq6GqqoqLCwshOWGhobQ0tIS3t+8eRNtbW2YOnWqXL/t7e2oqal5YdxqamoIDw+XawsNDYW3tzeuXbuGEydOoKioSBiPJyUl9faUEBH1GyZtiYiUhLq6OhwcHODg4AB/f39s2rQJSUlJ8PDwwIIFC7B9+3ZcvHgRFy9exDvvvAM7Ozu57VVV5b/SRSKRXJtIJALQ98E4EREREb0ZDA0NIRKJhB/w/xs1NTW59yKRCN3d3QCAo0ePIi4uDsHBwbCxsYFYLEZaWhp++eUXuW1eNIbty3i1tbUVurq6yMrK6rFs2LBhverj7NmzuH37NqKjoxEfHw9HR0doaGhg9uzZyM7O7nUsRET9ieURiIiUlKmpKdra2gAAOjo6eP/991FYWAipVAoPD49+28+lS5eE183Nzbh7965wS9zYsWNRUVEht35FRQWMjIw4y5aIiIjoX0ZbWxszZsxAdna2MA59XktLS6/7qqiogI2NDSQSCSZOnAhDQ8OXznx9GWNjY8hkMly7dk1o++2339Dc3Cy8t7CwwOPHj6GiogJDQ0O5f8OHD/+v++jo6MCWLVuwZcsWqKiooKurCzKZDAAgk8nQ1dXVp5iJiPoLk7ZERArW2NgIHx8fFBUV4caNG7h37x6Ki4uRmpoqV5rAy8sLUqkUVVVV+PDDD/tt/8nJySgvL8etW7cQEhIiJIgBwNfXF+Xl5dizZw+qq6shlUqRnZ0NX1/ffts/ERERESmP8PBwdHd3w8vLCyUlJbh79y6qqqqQmZmJjz/+uNf9GBoaorKyEmVlZaiurkZiYiKuXLnSp1hMTExgb2+PzZs34/Lly7h27RrCwsIwZMgQ4S4ye3t7TJ48Gf7+/jh9+jTu37+PiooKJCQk9Gp/ycnJcHJywsSJEwE8KwVWWlqKGzdu4Pvvv4etrW2fYiYi6i8sj0BEpGBisRjW1tbIyMhATU0NZDIZ9PT04OXlBT8/P2E9e3t7vPXWWzA1NcWoUaP6bf/r16/H1q1bcffuXUyYMAEpKSkYPHgwgGczFxITE7F7926kpKRAV1cXAQEB/TrTl4iIiIiUh4GBAQoLC/HNN98gLi4OtbW1GD58OCwsLBAREdHrfhYvXozr16/jyy+/hEgkwty5c7F06VKcOnWqT/HExcVh06ZNkEgk0NXVxbp16/Drr79CXV0dwLNyCt9++y0SExMRGhqKxsZGjBw5EnZ2dsIzHV7m1q1bKC4uxqFDh4Q2d3d3/Pzzz5BIJDA2NsaOHTv6FC8RUX8RPWVxQyKif4TW1lY4OjoiJiYGs2bNUnQ4REREREQD7vfff4eTkxP279+P6dOnKzocIqLXhjNtiYiUXHd3NxobG5Geng5NTU04OzsrOiQiIiIiogFRXl6OtrY2jB8/HnV1ddi2bRtGjx7d46G8RET/NkzaEhEpuQcPHsDFxQV6enqIjY3t8YRdIiIiIqJ/K5lMhoSEBNy7dw9isRg2NjbYvn071NTUFB0aEdFrxfIIREREREREREREREpkkKIDICIiIiIiIiIiIqL/YNKWiIiIiIiIiIiISIkwaUtERERERERERESkRJi0JSIiIiIiIiIiIlIiTNoSERERERERERERKREmbYmIiIiIiIiIiIiUCJO2REREREREREREREqESVsiIiIiIiIiIiIiJcKkLREREREREREREZES+T/iHJD+wIOXTQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Plot saved as price_alerts.png\n" + ] + } + ], + "source": [ + "# Visualize alerts\n", + "if all_alerts:\n", + " df_alerts = pd.DataFrame(all_alerts)\n", + " fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n", + " df_alerts.groupby('symbol').size().plot(kind='bar', ax=axes[0], color='tomato')\n", + " axes[0].set_title('Price Alerts by Stock Symbol')\n", + " axes[0].set_xlabel('Symbol')\n", + " axes[0].set_ylabel('Number of Alerts')\n", + " axes[0].tick_params(axis='x', rotation=0)\n", + " axes[1].hist(df_alerts['change_pct'], bins=20, color='steelblue', edgecolor='black')\n", + " axes[1].set_title('Distribution of Price Change % in Alerts')\n", + " axes[1].set_xlabel('Change %')\n", + " axes[1].set_ylabel('Count')\n", + " plt.tight_layout()\n", + " plt.savefig('price_alerts.png', dpi=100, bbox_inches='tight')\n", + " plt.show()\n", + " print('Plot saved as price_alerts.png')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 7: Performance Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Batch 50: 0.009s | 5689.0 events/sec\n", + "Batch 100: 0.011s | 9279.2 events/sec\n", + "Batch 200: 0.073s | 2747.2 events/sec\n", + "Batch 500: 0.046s | 10783.5 events/sec\n" + ] + } + ], + "source": [ + "# Throughput test: produce 500 events and measure time\n", + "producer = KafkaProducer(\n", + " bootstrap_servers=KAFKA_BROKER,\n", + " value_serializer=lambda v: json.dumps(v).encode('utf-8'),\n", + " key_serializer=lambda k: k.encode('utf-8'),\n", + ")\n", + "batch_sizes = [50, 100, 200, 500]\n", + "throughputs = []\n", + "for batch in batch_sizes:\n", + " start = time.time()\n", + " for _ in range(batch):\n", + " symbol = random.choice(STOCK_SYMBOLS)\n", + " event = generate_stock_event(symbol)\n", + " producer.send(TOPIC_NAME, key=symbol, value=event)\n", + " producer.flush()\n", + " elapsed = time.time() - start\n", + " tput = batch / elapsed\n", + " throughputs.append(tput)\n", + " print(f'Batch {batch:4d}: {elapsed:.3f}s | {tput:.1f} events/sec')\n", + "producer.close()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Throughput plot saved!\n" + ] + } + ], + "source": [ + "# Visualize throughput\n", + "plt.figure(figsize=(8, 4))\n", + "plt.plot(batch_sizes, throughputs, marker='o', color='steelblue', linewidth=2)\n", + "plt.title('Kafka Producer Throughput vs Batch Size')\n", + "plt.xlabel('Batch Size (number of events)')\n", + "plt.ylabel('Throughput (events/sec)')\n", + "plt.grid(True)\n", + "plt.tight_layout()\n", + "plt.savefig('throughput.png', dpi=100, bbox_inches='tight')\n", + "plt.show()\n", + "print('Throughput plot saved!')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 8: Summary and Results" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Step 9: Spark Batch Read from Kafka\n", + "Read all events from Kafka using Spark and compute aggregations using the Spark engine directly." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + ":: loading settings :: url = jar:file:/usr/local/lib/python3.11/site-packages/pyspark/jars/ivy-2.5.1.jar!/org/apache/ivy/core/settings/ivysettings.xml\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Ivy Default Cache set to: /root/.ivy2/cache\n", + "The jars for the packages stored in: /root/.ivy2/jars\n", + "org.apache.spark#spark-sql-kafka-0-10_2.12 added as a dependency\n", + ":: resolving dependencies :: org.apache.spark#spark-submit-parent-72e941cb-be67-4329-8dde-5c1a11198e32;1.0\n", + "\tconfs: [default]\n", + "\tfound org.apache.spark#spark-sql-kafka-0-10_2.12;3.5.1 in central\n", + "\tfound org.apache.spark#spark-token-provider-kafka-0-10_2.12;3.5.1 in central\n", + "\tfound org.apache.kafka#kafka-clients;3.4.1 in central\n", + "\tfound org.lz4#lz4-java;1.8.0 in central\n", + "\tfound org.xerial.snappy#snappy-java;1.1.10.3 in central\n", + "\tfound org.slf4j#slf4j-api;2.0.7 in central\n", + "\tfound org.apache.hadoop#hadoop-client-runtime;3.3.4 in central\n", + "\tfound org.apache.hadoop#hadoop-client-api;3.3.4 in central\n", + "\tfound commons-logging#commons-logging;1.1.3 in central\n", + "\tfound com.google.code.findbugs#jsr305;3.0.0 in central\n", + "\tfound org.apache.commons#commons-pool2;2.11.1 in central\n", + ":: resolution report :: resolve 669ms :: artifacts dl 26ms\n", + "\t:: modules in use:\n", + "\tcom.google.code.findbugs#jsr305;3.0.0 from central in [default]\n", + "\tcommons-logging#commons-logging;1.1.3 from central in [default]\n", + "\torg.apache.commons#commons-pool2;2.11.1 from central in [default]\n", + "\torg.apache.hadoop#hadoop-client-api;3.3.4 from central in [default]\n", + "\torg.apache.hadoop#hadoop-client-runtime;3.3.4 from central in [default]\n", + "\torg.apache.kafka#kafka-clients;3.4.1 from central in [default]\n", + "\torg.apache.spark#spark-sql-kafka-0-10_2.12;3.5.1 from central in [default]\n", + "\torg.apache.spark#spark-token-provider-kafka-0-10_2.12;3.5.1 from central in [default]\n", + "\torg.lz4#lz4-java;1.8.0 from central in [default]\n", + "\torg.slf4j#slf4j-api;2.0.7 from central in [default]\n", + "\torg.xerial.snappy#snappy-java;1.1.10.3 from central in [default]\n", + "\t---------------------------------------------------------------------\n", + "\t| | modules || artifacts |\n", + "\t| conf | number| search|dwnlded|evicted|| number|dwnlded|\n", + "\t---------------------------------------------------------------------\n", + "\t| default | 11 | 0 | 0 | 0 || 11 | 0 |\n", + "\t---------------------------------------------------------------------\n", + ":: retrieving :: org.apache.spark#spark-submit-parent-72e941cb-be67-4329-8dde-5c1a11198e32\n", + "\tconfs: [default]\n", + "\t0 artifacts copied, 11 already retrieved (0kB/12ms)\n", + "26/05/05 19:19:56 WARN NativeCodeLoader: Unable to load native-hadoop library for your platform... using builtin-java classes where applicable\n", + "Setting default log level to \"WARN\".\n", + "To adjust logging level use sc.setLogLevel(newLevel). For SparkR, use setLogLevel(newLevel).\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spark version: 3.5.1\n", + "Spark session initialized successfully!\n" + ] + } + ], + "source": [ + "import findspark\n", + "findspark.init()\n", + "from pyspark.sql import SparkSession\n", + "from pyspark.sql import functions as F\n", + "from pyspark.sql.types import StructType, StructField, StringType, DoubleType, IntegerType\n", + "\n", + "# Initialize Spark session with Kafka connector\n", + "spark = SparkSession.builder \\\n", + " .appName('StockMarketBatchAnalysis') \\\n", + " .config('spark.jars.packages', 'org.apache.spark:spark-sql-kafka-0-10_2.12:3.5.1') \\\n", + " .config('spark.sql.shuffle.partitions', '4') \\\n", + " .getOrCreate()\n", + "spark.sparkContext.setLogLevel('WARN')\n", + "print(f'Spark version: {spark.version}')\n", + "print('Spark session initialized successfully!')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "26/05/05 19:20:02 WARN AdminClientConfig: These configurations '[key.deserializer, value.deserializer, enable.auto.commit, max.poll.records, auto.offset.reset]' were supplied but are not used yet.\n", + "[Stage 0:> (0 + 1) / 1]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total raw messages read from Kafka: 3155\n", + "Raw Kafka DataFrame schema:\n", + "root\n", + " |-- key: binary (nullable = true)\n", + " |-- value: binary (nullable = true)\n", + " |-- topic: string (nullable = true)\n", + " |-- partition: integer (nullable = true)\n", + " |-- offset: long (nullable = true)\n", + " |-- timestamp: timestamp (nullable = true)\n", + " |-- timestampType: integer (nullable = true)\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " " + ] + } + ], + "source": [ + "# Define schema for stock events\n", + "stock_schema = StructType([\n", + " StructField('symbol', StringType(), True),\n", + " StructField('price', DoubleType(), True),\n", + " StructField('volume', IntegerType(), True),\n", + " StructField('timestamp', StringType(), True),\n", + " StructField('change_pct', DoubleType(), True),\n", + "])\n", + "\n", + "# Read ALL messages from Kafka as a batch DataFrame\n", + "kafka_batch_df = spark.read \\\n", + " .format('kafka') \\\n", + " .option('kafka.bootstrap.servers', 'kafka:29092') \\\n", + " .option('subscribe', 'stock-prices') \\\n", + " .option('startingOffsets', 'earliest') \\\n", + " .option('endingOffsets', 'latest') \\\n", + " .load()\n", + "\n", + "print(f'Total raw messages read from Kafka: {kafka_batch_df.count()}')\n", + "print('Raw Kafka DataFrame schema:')\n", + "kafka_batch_df.printSchema()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "26/05/05 19:20:07 WARN AdminClientConfig: These configurations '[key.deserializer, value.deserializer, enable.auto.commit, max.poll.records, auto.offset.reset]' were supplied but are not used yet.\n", + "26/05/05 19:20:08 WARN AdminClientConfig: These configurations '[key.deserializer, value.deserializer, enable.auto.commit, max.poll.records, auto.offset.reset]' were supplied but are not used yet.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Parsed events: 3155\n", + "Parsed DataFrame schema:\n", + "root\n", + " |-- symbol: string (nullable = true)\n", + " |-- price: double (nullable = true)\n", + " |-- volume: integer (nullable = true)\n", + " |-- timestamp: string (nullable = true)\n", + " |-- change_pct: double (nullable = true)\n", + " |-- event_time: timestamp (nullable = true)\n", + "\n", + "\n", + "Sample events:\n", + "+------+------+------+--------------------------+----------+--------------------------+\n", + "|symbol|price |volume|timestamp |change_pct|event_time |\n", + "+------+------+------+--------------------------+----------+--------------------------+\n", + "|AAPL |173.3 |7464 |2026-05-05T19:00:45.825186|-0.9706 |2026-05-05 19:00:45.825186|\n", + "|AAPL |173.01|9910 |2026-05-05T19:01:19.605244|-1.1369 |2026-05-05 19:01:19.605244|\n", + "|AAPL |174.1 |6464 |2026-05-05T19:02:39.476751|-0.5134 |2026-05-05 19:02:39.476751|\n", + "|AAPL |174.19|6193 |2026-05-05T19:04:09.466306|-0.4603 |2026-05-05 19:04:09.466306|\n", + "|AAPL |178.09|349 |2026-05-05T19:05:14.493077|1.7675 |2026-05-05 19:05:14.493077|\n", + "+------+------+------+--------------------------+----------+--------------------------+\n", + "only showing top 5 rows\n", + "\n" + ] + } + ], + "source": [ + "# Parse JSON values into structured columns\n", + "parsed_df = kafka_batch_df \\\n", + " .select(F.from_json(F.col('value').cast('string'), stock_schema).alias('data')) \\\n", + " .select('data.*') \\\n", + " .withColumn('event_time', F.to_timestamp('timestamp')) \\\n", + " .filter(F.col('symbol').isNotNull())\n", + "\n", + "print(f'Parsed events: {parsed_df.count()}')\n", + "print('Parsed DataFrame schema:')\n", + "parsed_df.printSchema()\n", + "print('\\nSample events:')\n", + "parsed_df.show(5, truncate=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Spark Aggregation: Price Statistics per Symbol ===\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "26/05/05 19:20:09 WARN AdminClientConfig: These configurations '[key.deserializer, value.deserializer, enable.auto.commit, max.poll.records, auto.offset.reset]' were supplied but are not used yet.\n", + "[Stage 7:> (0 + 1) / 1]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------+-----------+---------+---------+---------+------------+----------+\n", + "|symbol|event_count|avg_price|min_price|max_price|price_stddev|avg_volume|\n", + "+------+-----------+---------+---------+---------+------------+----------+\n", + "|AAPL |620 |175.06 |171.51 |178.48 |2.051 |4984.0 |\n", + "|AMZN |652 |185.02 |181.3 |188.69 |2.1288 |5184.0 |\n", + "|GOOGL |632 |139.95 |137.21 |142.78 |1.6055 |5062.0 |\n", + "|MSFT |611 |380.02 |372.47 |387.58 |4.4598 |5055.0 |\n", + "|TSLA |640 |249.85 |245.02 |255.0 |2.9198 |5006.0 |\n", + "+------+-----------+---------+---------+---------+------------+----------+\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + " " + ] + } + ], + "source": [ + "# Spark Aggregation 1: Average, Min, Max price per stock symbol\n", + "print('=== Spark Aggregation: Price Statistics per Symbol ===')\n", + "price_stats = parsed_df.groupBy('symbol') \\\n", + " .agg(\n", + " F.count('price').alias('event_count'),\n", + " F.round(F.avg('price'), 2).alias('avg_price'),\n", + " F.round(F.min('price'), 2).alias('min_price'),\n", + " F.round(F.max('price'), 2).alias('max_price'),\n", + " F.round(F.stddev('price'), 4).alias('price_stddev'),\n", + " F.round(F.avg('volume'), 0).alias('avg_volume'),\n", + " ) \\\n", + " .orderBy('symbol')\n", + "\n", + "price_stats.show(truncate=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Spark SQL: Price Alert Detection ===\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "26/05/05 19:20:11 WARN AdminClientConfig: These configurations '[key.deserializer, value.deserializer, enable.auto.commit, max.poll.records, auto.offset.reset]' were supplied but are not used yet.\n", + " " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Total alerts detected by Spark: 1612\n", + "\n", + "Alerts per symbol:\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "26/05/05 19:20:14 WARN AdminClientConfig: These configurations '[key.deserializer, value.deserializer, enable.auto.commit, max.poll.records, auto.offset.reset]' were supplied but are not used yet.\n", + " " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------+---------+-----+\n", + "|symbol|direction|count|\n", + "+------+---------+-----+\n", + "| AAPL| UP| 170|\n", + "| AAPL| DOWN| 147|\n", + "| AMZN| UP| 166|\n", + "| AMZN| DOWN| 163|\n", + "| GOOGL| UP| 158|\n", + "| GOOGL| DOWN| 164|\n", + "| MSFT| UP| 159|\n", + "| MSFT| DOWN| 154|\n", + "| TSLA| UP| 153|\n", + "| TSLA| DOWN| 178|\n", + "+------+---------+-----+\n", + "\n", + "Sample alerts:\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "26/05/05 19:20:16 WARN AdminClientConfig: These configurations '[key.deserializer, value.deserializer, enable.auto.commit, max.poll.records, auto.offset.reset]' were supplied but are not used yet.\n", + "26/05/05 19:20:17 WARN GarbageCollectionMetrics: To enable non-built-in garbage collector(s) List(G1 Concurrent GC), users should configure it(them) to spark.eventLog.gcMetrics.youngGenerationGarbageCollectors or spark.eventLog.gcMetrics.oldGenerationGarbageCollectors\n", + " " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------+------+----------+-----------------+---------+--------------------------+\n", + "|symbol|price |base_price|change_pct_actual|direction|event_time |\n", + "+------+------+----------+-----------------+---------+--------------------------+\n", + "|AAPL |173.25|175.0 |1.0 |DOWN |2026-05-05 19:19:52.618414|\n", + "|AAPL |176.75|175.0 |1.0 |UP |2026-05-05 19:07:59.809912|\n", + "|AAPL |173.24|175.0 |1.0057 |DOWN |2026-05-05 19:18:51.428944|\n", + "|AAPL |176.76|175.0 |1.0057 |UP |2026-05-05 19:19:40.333993|\n", + "|AAPL |173.24|175.0 |1.0057 |DOWN |2026-05-05 19:18:51.538341|\n", + "|AAPL |176.76|175.0 |1.0057 |UP |2026-05-05 19:07:47.772311|\n", + "|AAPL |176.76|175.0 |1.0057 |UP |2026-05-05 19:18:51.42997 |\n", + "|AAPL |176.76|175.0 |1.0057 |UP |2026-05-05 19:07:59.874774|\n", + "|AAPL |173.23|175.0 |1.0114 |DOWN |2026-05-05 19:07:59.862465|\n", + "|AAPL |173.23|175.0 |1.0114 |DOWN |2026-05-05 19:18:51.550096|\n", + "+------+------+----------+-----------------+---------+--------------------------+\n", + "only showing top 10 rows\n", + "\n" + ] + } + ], + "source": [ + "# Spark Aggregation 2: Price alerts using Spark SQL\n", + "print('=== Spark SQL: Price Alert Detection ===')\n", + "\n", + "# Register base prices as a Spark DataFrame\n", + "base_prices_data = [(k, v) for k, v in BASE_PRICES.items()]\n", + "base_df = spark.createDataFrame(base_prices_data, ['symbol', 'base_price'])\n", + "\n", + "# Join with parsed events and compute alerts\n", + "alerts_df = parsed_df.join(base_df, on='symbol') \\\n", + " .withColumn('change_pct_actual',\n", + " F.round(F.abs((F.col('price') - F.col('base_price')) / F.col('base_price') * 100), 4)) \\\n", + " .withColumn('direction',\n", + " F.when(F.col('price') > F.col('base_price'), 'UP').otherwise('DOWN')) \\\n", + " .filter(F.col('change_pct_actual') >= 1.0) \\\n", + " .select('symbol', 'price', 'base_price', 'change_pct_actual', 'direction', 'event_time') \\\n", + " .orderBy('symbol', 'change_pct_actual')\n", + "\n", + "print(f'Total alerts detected by Spark: {alerts_df.count()}')\n", + "print('\\nAlerts per symbol:')\n", + "alerts_df.groupBy('symbol', 'direction').count().orderBy('symbol').show()\n", + "print('Sample alerts:')\n", + "alerts_df.show(10, truncate=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Spark Window Function: Moving Average ===\n", + "Moving averages computed by Spark:\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "26/05/05 19:20:18 WARN AdminClientConfig: These configurations '[key.deserializer, value.deserializer, enable.auto.commit, max.poll.records, auto.offset.reset]' were supplied but are not used yet.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------+--------------------------+------+------+------+\n", + "|symbol|event_time |price |MA5 |MA10 |\n", + "+------+--------------------------+------+------+------+\n", + "|AAPL |2026-05-05 19:00:45.825186|173.3 |173.3 |173.3 |\n", + "|AAPL |2026-05-05 19:01:19.605244|173.01|173.16|173.16|\n", + "|AAPL |2026-05-05 19:02:39.476751|174.1 |173.47|173.47|\n", + "|AAPL |2026-05-05 19:04:09.466306|174.19|173.65|173.65|\n", + "|AAPL |2026-05-05 19:05:14.493077|178.09|174.54|174.54|\n", + "|AAPL |2026-05-05 19:07:47.769887|176.82|175.24|174.92|\n", + "|AAPL |2026-05-05 19:07:47.770096|175.6 |175.76|175.02|\n", + "|AAPL |2026-05-05 19:07:47.770192|177.3 |176.4 |175.3 |\n", + "|AAPL |2026-05-05 19:07:47.770447|175.45|176.65|175.32|\n", + "|AAPL |2026-05-05 19:07:47.77048 |178.02|176.64|175.59|\n", + "|AAPL |2026-05-05 19:07:47.770876|175.05|176.28|175.76|\n", + "|AAPL |2026-05-05 19:07:47.77091 |174.08|175.98|175.87|\n", + "|AAPL |2026-05-05 19:07:47.770941|175.86|175.69|176.05|\n", + "|AAPL |2026-05-05 19:07:47.77103 |171.94|174.99|175.82|\n", + "|AAPL |2026-05-05 19:07:47.771441|175.52|174.49|175.56|\n", + "|AAPL |2026-05-05 19:07:47.771611|176.59|174.8 |175.54|\n", + "|AAPL |2026-05-05 19:07:47.771757|175.42|175.07|175.52|\n", + "|AAPL |2026-05-05 19:07:47.772311|176.76|175.25|175.47|\n", + "|AAPL |2026-05-05 19:07:47.77244 |176.65|176.19|175.59|\n", + "|AAPL |2026-05-05 19:07:47.772632|176.9 |176.46|175.48|\n", + "+------+--------------------------+------+------+------+\n", + "only showing top 20 rows\n", + "\n" + ] + } + ], + "source": [ + "# Spark Aggregation 3: Time-windowed moving average using Spark\n", + "print('=== Spark Window Function: Moving Average ===')\n", + "from pyspark.sql.window import Window\n", + "\n", + "# Define window spec: partition by symbol, order by event_time\n", + "window_spec_5 = Window.partitionBy('symbol').orderBy('event_time').rowsBetween(-4, 0)\n", + "window_spec_10 = Window.partitionBy('symbol').orderBy('event_time').rowsBetween(-9, 0)\n", + "\n", + "# Compute moving averages using Spark window functions\n", + "ma_df = parsed_df \\\n", + " .withColumn('MA5', F.round(F.avg('price').over(window_spec_5), 2)) \\\n", + " .withColumn('MA10', F.round(F.avg('price').over(window_spec_10), 2)) \\\n", + " .select('symbol', 'event_time', 'price', 'MA5', 'MA10') \\\n", + " .orderBy('symbol', 'event_time')\n", + "\n", + "print('Moving averages computed by Spark:')\n", + "ma_df.show(20, truncate=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "=== Spark SQL Query ===\n", + "Stock analysis ranked by volatility (Spark SQL):\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "26/05/05 19:20:19 WARN AdminClientConfig: These configurations '[key.deserializer, value.deserializer, enable.auto.commit, max.poll.records, auto.offset.reset]' were supplied but are not used yet.\n", + " " + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+------+------------+---------+-----------+----------+------------+\n", + "|symbol|total_events|avg_price|price_range|volatility|total_volume|\n", + "+------+------------+---------+-----------+----------+------------+\n", + "|MSFT |611 |380.02 |15.11 |4.4598 |3088776 |\n", + "|TSLA |640 |249.85 |9.98 |2.9198 |3203813 |\n", + "|AMZN |652 |185.02 |7.39 |2.1288 |3380174 |\n", + "|AAPL |620 |175.06 |6.97 |2.051 |3089971 |\n", + "|GOOGL |632 |139.95 |5.57 |1.6055 |3199296 |\n", + "+------+------------+---------+-----------+----------+------------+\n", + "\n", + "Spark session stopped.\n" + ] + } + ], + "source": [ + "# Spark SQL: Register as temp view and run SQL queries\n", + "print('=== Spark SQL Query ===')\n", + "parsed_df.createOrReplaceTempView('stock_events')\n", + "\n", + "result = spark.sql(\"\"\"\n", + " SELECT\n", + " symbol,\n", + " COUNT(*) as total_events,\n", + " ROUND(AVG(price), 2) as avg_price,\n", + " ROUND(MAX(price) - MIN(price), 2) as price_range,\n", + " ROUND(STDDEV(price), 4) as volatility,\n", + " SUM(volume) as total_volume\n", + " FROM stock_events\n", + " GROUP BY symbol\n", + " ORDER BY volatility DESC\n", + "\"\"\")\n", + "\n", + "print('Stock analysis ranked by volatility (Spark SQL):')\n", + "result.show(truncate=False)\n", + "\n", + "spark.stop()\n", + "print('Spark session stopped.')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Challenges and What I Learned\n", + "\n", + "### 1. Docker networking was the biggest hurdle\n", + "When I first ran the notebooks, every Kafka connection threw `NoBrokersAvailable`. I spent a while thinking the Kafka container wasn't starting properly, but the actual issue was simpler \u2014 I was using `localhost:9092` inside a Jupyter container that has no idea what `localhost` means in that context. Switching to `kafka:29092` (the internal Docker service name) fixed it immediately.\n", + "\n", + "### 2. Numpy and seaborn version conflict\n", + "My initial `requirements.txt` had `numpy==1.24.0` but seaborn explicitly excludes that version. Docker build failed after 3 minutes of downloading. Had to bump numpy to 1.26.0 and seaborn to 0.13.0.\n", + "\n", + "### 3. Kafka retains all messages by default\n", + "After multiple test runs, the consumer was reading 1,000+ events even though I only produced 200. This is because Kafka retains all messages until the retention period expires. In production you would configure consumer groups and offsets carefully to avoid reprocessing old data.\n", + "\n", + "### 4. Spark streaming vs batch in a notebook\n", + "True Spark Structured Streaming requires a continuous write stream running in the background, which is hard to demonstrate interactively in a notebook. I used Spark batch read from Kafka instead \u2014 this gives identical analytical results and is much cleaner to demonstrate and explain.\n", + "\n", + "### Key takeaway\n", + "The combination of Kafka and Spark is genuinely powerful. Kafka handles the ingestion at high throughput (7,000+ events/sec in our Docker environment), while Spark handles the analytics with window functions and SQL. Understanding how they connect \u2014 especially the Spark-Kafka connector JAR and the bootstrap server configuration \u2014 was the most valuable thing I learned." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + "PIPELINE SUMMARY\n", + "============================================================\n", + "Total events produced : 200\n", + "Total events consumed : 1050\n", + "Total alerts triggered: 547\n", + "Alert rate : 52.1%\n", + "\n", + "Moving Average Results (last values):\n", + " AAPL: price=$178.19 | MA5=$176.62 | MA10=$175.80\n", + " GOOGL: price=$142.42 | MA5=$141.02 | MA10=$140.20\n", + " MSFT: price=$376.72 | MA5=$377.15 | MA10=$379.21\n", + " AMZN: price=$187.08 | MA5=$184.59 | MA10=$184.73\n", + " TSLA: price=$254.98 | MA5=$249.59 | MA10=$249.82\n", + "\n", + "Conclusion:\n", + " - Apache Kafka successfully ingested real-time stock price events\n", + " - Moving averages smoothed out short-term price fluctuations\n", + " - Price alerts identified stocks with significant movements\n", + " - The pipeline is scalable and runs fully locally via Docker\n" + ] + } + ], + "source": [ + "print('=' * 60)\n", + "print('PIPELINE SUMMARY')\n", + "print('=' * 60)\n", + "print(f'Total events produced : {N_EVENTS}')\n", + "print(f'Total events consumed : {len(consumed_events)}')\n", + "print(f'Total alerts triggered: {len(all_alerts)}')\n", + "print(f'Alert rate : {len(all_alerts)/len(consumed_events)*100:.1f}%')\n", + "print()\n", + "print('Moving Average Results (last values):')\n", + "for symbol in STOCK_SYMBOLS:\n", + " df_sym = results[symbol]\n", + " last_price = df_sym['price'].iloc[-1]\n", + " last_ma5 = df_sym['MA5'].dropna().iloc[-1] if len(df_sym['MA5'].dropna()) > 0 else float('nan')\n", + " last_ma10 = df_sym['MA10'].dropna().iloc[-1] if len(df_sym['MA10'].dropna()) > 0 else float('nan')\n", + " print(f' {symbol}: price=${last_price:.2f} | MA5=${last_ma5:.2f} | MA10=${last_ma10:.2f}')\n", + "print()\n", + "print('Conclusion:')\n", + "print(' - Apache Kafka successfully ingested real-time stock price events')\n", + "print(' - Moving averages smoothed out short-term price fluctuations')\n", + "print(' - Price alerts identified stocks with significant movements')\n", + "print(' - The pipeline is scalable and runs fully locally via Docker')\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.15" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/kafka_spark_utils.py b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/kafka_spark_utils.py new file mode 100644 index 000000000..1c85adb7c --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/kafka_spark_utils.py @@ -0,0 +1,162 @@ +""" +Utility functions for the Real-Time Stock Market Pipeline using Kafka and Spark. +""" +import json +import random +import time +from datetime import datetime +from typing import Dict, List + +STOCK_SYMBOLS = ["AAPL", "GOOGL", "MSFT", "AMZN", "TSLA"] + +BASE_PRICES = { + "AAPL": 175.0, + "GOOGL": 140.0, + "MSFT": 380.0, + "AMZN": 185.0, + "TSLA": 250.0, +} + + +def generate_stock_event(symbol: str) -> Dict: + """ + Generate a simulated stock price event. + + Args: + symbol: Stock ticker symbol (e.g., 'AAPL') + + Returns: + Dictionary containing stock event data + """ + base_price = BASE_PRICES[symbol] + change_pct = random.uniform(-0.02, 0.02) + price = round(base_price * (1 + change_pct), 2) + volume = random.randint(100, 10000) + return { + "symbol": symbol, + "price": price, + "volume": volume, + "timestamp": datetime.now().isoformat(), + "change_pct": round(change_pct * 100, 4), + } + + +def generate_stock_stream(n_events: int = 100, delay: float = 0.0) -> List[Dict]: + """ + Generate a stream of stock events for all symbols. + + Args: + n_events: Number of events to generate + delay: Delay between events in seconds + + Returns: + List of stock event dictionaries + """ + events = [] + for _ in range(n_events): + symbol = random.choice(STOCK_SYMBOLS) + event = generate_stock_event(symbol) + events.append(event) + if delay > 0: + time.sleep(delay) + return events + + +def serialize_event(event: Dict) -> bytes: + """ + Serialize a stock event to JSON bytes for Kafka. + + Args: + event: Stock event dictionary + + Returns: + JSON-encoded bytes + """ + return json.dumps(event).encode("utf-8") + + +def deserialize_event(data: bytes) -> Dict: + """ + Deserialize a Kafka message to a stock event dictionary. + + Args: + data: JSON-encoded bytes from Kafka + + Returns: + Stock event dictionary + """ + return json.loads(data.decode("utf-8")) + + +def compute_moving_average(prices: List[float], window: int = 5) -> List[float]: + """ + Compute moving average of stock prices. + + Args: + prices: List of stock prices + window: Window size for moving average + + Returns: + List of moving averages (None for initial values) + """ + averages = [] + for i in range(len(prices)): + if i < window - 1: + averages.append(None) + else: + avg = sum(prices[i - window + 1:i + 1]) / window + averages.append(round(avg, 2)) + return averages + + +def check_price_alert(price: float, symbol: str, threshold_pct: float = 1.5) -> Dict: + """ + Check if a stock price has moved beyond a threshold. + + Args: + price: Current stock price + symbol: Stock ticker symbol + threshold_pct: Alert threshold percentage + + Returns: + Alert dictionary if threshold exceeded, else None + """ + base_price = BASE_PRICES[symbol] + change_pct = abs((price - base_price) / base_price * 100) + if change_pct >= threshold_pct: + direction = "UP" if price > base_price else "DOWN" + return { + "symbol": symbol, + "alert": f"Price moved {direction} by {change_pct:.2f}%", + "current_price": price, + "base_price": base_price, + "change_pct": round(change_pct, 4), + "timestamp": datetime.now().isoformat(), + } + return None + + +def format_kafka_summary(events: List[Dict]) -> str: + """ + Format a summary of Kafka events for display. + + Args: + events: List of stock event dictionaries + + Returns: + Formatted summary string + """ + summary = [f"Total events: {len(events)}"] + by_symbol = {} + for e in events: + sym = e["symbol"] + if sym not in by_symbol: + by_symbol[sym] = [] + by_symbol[sym].append(e["price"]) + for sym, prices in sorted(by_symbol.items()): + avg = sum(prices) / len(prices) + summary.append( + f"{sym}: {len(prices)} events | " + f"avg: ${avg:.2f} | min: ${min(prices):.2f} | max: ${max(prices):.2f}" + ) + return "\n".join(summary) diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/moving_averages.png b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/moving_averages.png new file mode 100644 index 000000000..b40293f9f Binary files /dev/null and b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/moving_averages.png differ diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/price_alerts.png b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/price_alerts.png new file mode 100644 index 000000000..2a6300ce2 Binary files /dev/null and b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/price_alerts.png differ diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/requirements.txt b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/requirements.txt new file mode 100644 index 000000000..ce9757bca --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/requirements.txt @@ -0,0 +1,8 @@ +kafka-python==2.0.2 +pyspark==3.5.1 +pandas==2.1.0 +numpy==1.26.0 +matplotlib==3.7.0 +seaborn==0.13.0 +yfinance==0.2.28 +findspark==2.0.1 diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/run_jupyter.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/run_jupyter.sh new file mode 100644 index 000000000..d725c3fe7 --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/run_jupyter.sh @@ -0,0 +1,35 @@ +#!/bin/bash +# """ +# Launch Jupyter Lab server. +# +# This script starts Jupyter Lab on port 8888 with the following configuration: +# - No browser auto-launch (useful for Docker containers) +# - Accessible from any IP address (0.0.0.0) +# - Root user allowed (required for Docker environments) +# - No authentication token or password (for development convenience) +# - Vim keybindings can be enabled via JUPYTER_USE_VIM environment variable +# """ + +# Exit immediately if any command exits with a non-zero status. +set -e + +# Print each command to stdout before executing it. +#set -x + +# Import the utility functions from /git_root. +GIT_ROOT=/git_root +source $GIT_ROOT/class_project/project_template/utils.sh + +# Load Docker configuration variables for this script. +get_docker_vars_script ${BASH_SOURCE[0]} +source $DOCKER_NAME +print_docker_vars + +# Setup Jupyter Lab environment. +setup_jupyter_environment + +# Initialize Jupyter Lab command with base configuration. +JUPYTER_ARGS=$(get_jupyter_args) + +# Start Jupyter Lab with development-friendly settings. +run "jupyter lab $JUPYTER_ARGS" diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/stock_distributions.png b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/stock_distributions.png new file mode 100644 index 000000000..27b91f7e6 Binary files /dev/null and b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/stock_distributions.png differ diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/test/test_docker_all.py b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/test/test_docker_all.py new file mode 100644 index 000000000..904cdd7af --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/test/test_docker_all.py @@ -0,0 +1,48 @@ +""" +Run each notebook in class_project/project_template/ inside Docker using docker_cmd.sh. + +Import as: + +import class_project.project_template.test.test_docker_all as tptdal +""" + +import logging + +import pytest + +import helpers.hdocker_tests as hdoctest + +_LOG = logging.getLogger(__name__) + + +# ############################################################################# +# Test_docker +# ############################################################################# + + +class Test_docker(hdoctest.DockerTestCase): + """ + Run all Docker tests for class_project/project_template/. + """ + + _test_file = __file__ + + @pytest.mark.slow + def test1(self) -> None: + """ + Test that template.example.ipynb runs without error inside Docker. + """ + # Prepare inputs. + notebook_name = "template.example.ipynb" + # Run test. + self._helper(notebook_name) + + @pytest.mark.slow + def test2(self) -> None: + """ + Test that template.API.ipynb runs without error inside Docker. + """ + # Prepare inputs. + notebook_name = "template.API.ipynb" + # Run test. + self._helper(notebook_name) diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/throughput.png b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/throughput.png new file mode 100644 index 000000000..3c594e957 Binary files /dev/null and b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/throughput.png differ diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/utils.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/utils.sh new file mode 100644 index 000000000..cc0ed8c4a --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/utils.sh @@ -0,0 +1,607 @@ +#!/bin/bash +# """ +# Utility functions for Docker container management. +# """ + + +# ############################################################################# +# General utilities +# ############################################################################# + + +run() { + # """ + # Execute a command with echo output. + # + # :param cmd: Command string to execute + # :return: Exit status of the executed command + # """ + cmd="$*" + echo "> $cmd" + eval "$cmd" +} + + +enable_verbose_mode() { + # """ + # Enable shell command tracing (set -x) when VERBOSE is set to 1. + # + # Reads the VERBOSE variable set by parse_docker_jupyter_args. + # Call this after parsing args to activate tracing for the rest of the script. + # """ + if [[ $VERBOSE == 1 ]]; then + set -x + fi +} + + +# ############################################################################# +# Argument parsing +# ############################################################################# + + +_print_default_help() { + # """ + # Print usage information and available default options for docker scripts. + # """ + echo "Usage: $(basename $0) [options]" + echo "" + echo "Options:" + echo " -f Force kill existing container with same name before starting" + echo " -h Print this help message and exit" + echo " -v Enable verbose output (set -x)" +} + + +parse_default_args() { + # """ + # Parse default command-line arguments for docker scripts. + # + # Sets VERBOSE and FORCE variables in the caller's scope. Enables set -x + # when -v is passed. Prints help and exits when -h is passed. + # Updates OPTIND so the caller can shift away processed arguments. + # + # :param @: command-line arguments forwarded from the calling script + # """ + VERBOSE=0 + FORCE=0 + while getopts "fhv" flag; do + case "${flag}" in + f) FORCE=1;; + h) _print_default_help; exit 0;; + v) VERBOSE=1;; + *) _print_default_help; exit 1;; + esac + done + enable_verbose_mode +} + + +_print_docker_jupyter_help() { + # """ + # Print usage information and available options for docker_jupyter.sh. + # """ + echo "Usage: $(basename $0) [options]" + echo "" + echo "Launch Jupyter Lab inside a Docker container." + echo "" + echo "Options:" + echo " -f Force kill existing container with same name before starting" + echo " -h Print this help message and exit" + echo " -p PORT Host port to forward to Jupyter Lab (default: 8888)" + echo " -u Enable vim keybindings in Jupyter Lab" + echo " -v Enable verbose output (set -x)" +} + + +parse_docker_jupyter_args() { + # """ + # Parse command-line arguments for docker_jupyter.sh. + # + # Sets JUPYTER_HOST_PORT, JUPYTER_USE_VIM, TARGET_DIR, VERBOSE, FORCE, and + # OLD_CMD_OPTS in the caller's scope. Enables set -x when -v is passed. + # Prints help and exits when -h is passed. + # + # :param @: command-line arguments forwarded from the calling script + # """ + # Set defaults. + JUPYTER_HOST_PORT=8888 + JUPYTER_USE_VIM=0 + VERBOSE=0 + FORCE=0 + # Save original args to pass through to run_jupyter.sh. + OLD_CMD_OPTS="$*" + # Parse options. + while getopts "fhp:uv" flag; do + case "${flag}" in + f) FORCE=1;; + h) _print_docker_jupyter_help; exit 0;; + p) JUPYTER_HOST_PORT=${OPTARG};; # Port for Jupyter Lab. + u) JUPYTER_USE_VIM=1;; # Enable vim bindings. + v) VERBOSE=1;; # Enable verbose output. + *) _print_docker_jupyter_help; exit 1;; + esac + done + # Enable command tracing if verbose mode is requested. + enable_verbose_mode +} + + +# ############################################################################# +# Docker image management +# ############################################################################# + + +get_docker_vars_script() { + # """ + # Load Docker variables from docker_name.sh script. + # + # :param script_path: Path to the script to determine the Docker configuration directory + # :return: Sources REPO_NAME, IMAGE_NAME, and FULL_IMAGE_NAME variables + # """ + local script_path=$1 + # Find the name of the container. + SCRIPT_DIR=$(dirname $script_path) + DOCKER_NAME="$SCRIPT_DIR/docker_name.sh" + if [[ ! -e $SCRIPT_DIR ]]; then + echo "Can't find $DOCKER_NAME" + exit -1 + fi; + source $DOCKER_NAME +} + + +print_docker_vars() { + # """ + # Print current Docker variables to stdout. + # """ + echo "REPO_NAME=$REPO_NAME" + echo "IMAGE_NAME=$IMAGE_NAME" + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" +} + + +build_container_image() { + # """ + # Build a Docker container image. + # + # Supports both single-architecture and multi-architecture builds. + # Creates temporary build directory, copies files, and builds the image. + # + # :param @: Additional options to pass to docker build/buildx build + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + # Prepare build area. + #tar -czh . | docker build $OPTS -t $IMAGE_NAME - + DIR="../tmp.build" + if [[ -d $DIR ]]; then + rm -rf $DIR + fi; + cp -Lr . $DIR || true + # Build container. + echo "DOCKER_BUILDKIT=$DOCKER_BUILDKIT" + echo "DOCKER_BUILD_MULTI_ARCH=$DOCKER_BUILD_MULTI_ARCH" + if [[ $DOCKER_BUILD_MULTI_ARCH != 1 ]]; then + # Build for a single architecture. + echo "Building for current architecture..." + OPTS="--progress plain $@" + (cd $DIR; docker build $OPTS -t $FULL_IMAGE_NAME . 2>&1 | tee ../docker_build.log; exit ${PIPESTATUS[0]}) + else + # Build for multiple architectures. + echo "Building for multiple architectures..." + OPTS="$@" + export DOCKER_CLI_EXPERIMENTAL=enabled + # Create a new builder. + #docker buildx rm --all-inactive --force + #docker buildx create --name mybuilder + #docker buildx use mybuilder + # Use the default builder. + docker buildx use multiarch + docker buildx inspect --bootstrap + # Note that one needs to push to the repo since otherwise it is not + # possible to keep multiple. + (cd $DIR; docker buildx build --push --platform linux/arm64,linux/amd64 $OPTS --tag $FULL_IMAGE_NAME . 2>&1 | tee ../docker_build.log; exit ${PIPESTATUS[0]}) + # Report the status. + docker buildx imagetools inspect $FULL_IMAGE_NAME + fi; + # Report build version. + if [ -f docker_build.version.log ]; then + rm docker_build.version.log + fi + (cd $DIR; docker run --rm -it -v $(pwd):/data $FULL_IMAGE_NAME bash -c "/data/version.sh") 2>&1 | tee docker_build.version.log + # + docker image ls $REPO_NAME/$IMAGE_NAME + rm -rf $DIR + echo "*****************************" + echo "SUCCESS" + echo "*****************************" +} + + +remove_container_image() { + # """ + # Remove Docker container image(s) matching the current configuration. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker image ls | grep $FULL_IMAGE_NAME + docker image ls | grep $FULL_IMAGE_NAME | awk '{print $1}' | xargs -n 1 -t docker image rm -f + docker image ls + echo "${FUNCNAME[0]} ... done" +} + + +push_container_image() { + # """ + # Push Docker container image to registry. + # + # Authenticates using credentials from ~/.docker/passwd.$REPO_NAME.txt. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker login --username $REPO_NAME --password-stdin <~/.docker/passwd.$REPO_NAME.txt + docker images $FULL_IMAGE_NAME + docker push $FULL_IMAGE_NAME + echo "${FUNCNAME[0]} ... done" +} + + +pull_container_image() { + # """ + # Pull Docker container image from registry. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker pull $FULL_IMAGE_NAME + echo "${FUNCNAME[0]} ... done" +} + + +# ############################################################################# +# Docker container management +# ############################################################################# + + +kill_container() { + # """ + # Kill and remove Docker container(s) matching the current configuration. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker container ls + # + CONTAINER_ID=$(docker container ls -a | grep $FULL_IMAGE_NAME | awk '{print $1}') + echo "CONTAINER_ID=$CONTAINER_ID" + if [[ ! -z $CONTAINER_ID ]]; then + docker container rm -f $CONTAINER_ID + docker container ls + fi; + echo "${FUNCNAME[0]} ... done" +} + + +kill_container_by_name() { + # """ + # Kill and remove a Docker container by its name. + # + # :param container_name: Name of the container to kill + # """ + local container_name=$1 + echo "# ${FUNCNAME[0]}: $container_name" + # Check if container exists (running or stopped). + local container_id=$(docker container ls -a --filter "name=^${container_name}$" --format "{{.ID}}") + if [[ -n $container_id ]]; then + echo "Killing container: $container_name (ID: $container_id)" + docker container rm -f $container_id + else + echo "Container '$container_name' not found" + fi + echo "${FUNCNAME[0]} ... done" +} + + +exec_container() { + # """ + # Execute bash shell in running Docker container. + # + # Opens an interactive bash session in the first container matching the + # current configuration. + # """ + echo "# ${FUNCNAME[0]} ..." + FULL_IMAGE_NAME=$REPO_NAME/$IMAGE_NAME + echo "FULL_IMAGE_NAME=$FULL_IMAGE_NAME" + docker container ls + # + CONTAINER_ID=$(docker container ls -a | grep $FULL_IMAGE_NAME | awk '{print $1}') + echo "CONTAINER_ID=$CONTAINER_ID" + docker exec -it $CONTAINER_ID bash + echo "${FUNCNAME[0]} ... done" +} + + +# ############################################################################# +# Docker common options +# ############################################################################# + + +get_docker_common_options() { + # """ + # Return docker run options common to all container types. + # + # Includes volume mount for the git root, plus environment variables for + # PYTHONPATH and host OS name. + # + # :return: docker run options string with volume mounts and env vars + # """ + echo "-v $GIT_ROOT:/git_root \ + -e PYTHONPATH=/git_root:/git_root/helpers_root:/git_root/msml610/tutorials \ + -e CSFY_GIT_ROOT_PATH=/git_root \ + -e CSFY_HOST_OS_NAME=$(uname -s) \ + -e CSFY_HOST_NAME=$(uname -n)" +} + + +# ############################################################################# +# Docker bash +# ############################################################################# + + +get_docker_bash_command() { + # """ + # Return the base docker run command for an interactive bash shell. + # + # :return: docker run command string with --rm and -ti flags + # """ + if [ -t 0 ]; then + echo "docker run --rm -ti" + else + echo "docker run --rm -i" + fi +} + + +get_docker_bash_options() { + # """ + # Return docker run options for a Docker container. + # + # :param container_name: Name for the Docker container + # :param port: Port number to forward (optional, skipped if empty) + # :param extra_opts: Additional docker run options (optional) + # :return: docker run options string with name, volume mounts, and env vars + # """ + local container_name=$1 + local port=$2 + local extra_opts=$3 + local port_opt="" + if [[ -n $port ]]; then + port_opt="-p $port:$port" + fi + echo "--name $container_name \ + $port_opt \ + $extra_opts \ + $(get_docker_common_options)" +} + + +# ############################################################################# +# Docker cmd +# ############################################################################# + + +get_docker_cmd_command() { + # """ + # Return the base docker run command for executing a non-interactive command. + # + # :return: docker run command string with --rm and -i flags + # """ + echo "docker run --rm -i" +} + + +# ############################################################################# +# Docker Jupyter +# ############################################################################# + + +get_docker_jupyter_command() { + # """ + # Return the base docker run command for running Jupyter Lab interactively. + # + # :return: docker run command string with --rm and -ti flags (if TTY available) + # """ + local docker_cmd="docker run --rm" + # Add interactive and TTY flags only if stdin is a TTY. + if [[ -t 0 ]]; then + docker_cmd="$docker_cmd -ti" + fi + echo "$docker_cmd" +} + + +get_docker_jupyter_options() { + # """ + # Return docker run options for a Jupyter Lab container. + # + # :param container_name: Name for the Docker container + # :param host_port: Host port to forward to container port 8888 + # :param jupyter_use_vim: 0 or 1 to enable vim bindings + # :return: docker run options string + # """ + local container_name=$1 + local host_port=$2 + local jupyter_use_vim=$3 + # Run as the current user when user is saggese. + if [[ "$(whoami)" == "saggese" ]]; then + echo "Overwriting jupyter_use_vim since user='saggese'" >&2 + jupyter_use_vim=1 + fi + echo "--name $container_name \ + -p $host_port:8888 \ + $(get_docker_common_options) \ + -e JUPYTER_USE_VIM=$jupyter_use_vim" +} + + +configure_jupyter_vim_keybindings() { + # """ + # Configure JupyterLab vim keybindings based on JUPYTER_USE_VIM env var. + # + # Reads JUPYTER_USE_VIM; if 1, verifies jupyterlab_vim is installed and + # writes enabled settings; otherwise writes disabled settings. + # """ + mkdir -p ~/.jupyter/lab/user-settings/@axlair/jupyterlab_vim + if [[ $JUPYTER_USE_VIM == 1 ]]; then + # Check that jupyterlab_vim is installed before trying to enable it. + if ! pip show jupyterlab_vim > /dev/null 2>&1; then + echo "ERROR: jupyterlab_vim is not installed but vim bindings were requested." + echo "Install it with: pip install jupyterlab_vim" + exit 1 + fi + echo "Enabling vim." + cat < ~/.jupyter/lab/user-settings/\@axlair/jupyterlab_vim/plugin.jupyterlab-settings +{ + "enabled": true, + "enabledInEditors": true, + "extraKeybindings": [], + "autosaveInterval": 6 +} +EOF + else + echo "Disabling vim." + cat < ~/.jupyter/lab/user-settings/\@axlair/jupyterlab_vim/plugin.jupyterlab-settings +{ + "enabled": false, + "enabledInEditors": false, + "extraKeybindings": [], + "autosaveInterval": 6 +} +EOF + fi; +} + + +configure_jupyter_notifications() { + # """ + # Disable JupyterLab news fetching and update checks. + # """ + mkdir -p ~/.jupyter/lab/user-settings/@jupyterlab/apputils-extension + cat < ~/.jupyter/lab/user-settings/\@jupyterlab/apputils-extension/notification.jupyterlab-settings +{ + // Notifications + // @jupyterlab/apputils-extension:notification + // Notifications settings. + + // Fetch official Jupyter news + // Whether to fetch news from the Jupyter news feed. If Always (`true`), it will make a request to a website. + "fetchNews": "false", + "checkForUpdates": false +} +EOF +} + + +configure_jupyter_autosave() { + # """ + # Configure JupyterLab global autosave interval to 6 seconds. + # """ + mkdir -p ~/.jupyter/lab/user-settings/@jupyterlab/docmanager-extension + cat < ~/.jupyter/lab/user-settings/\@jupyterlab/docmanager-extension/plugin.jupyterlab-settings +{ + "autosaveInterval": 6 +} +EOF +} + + +check_jupytext_installed() { + # """ + # Verify that jupytext is installed before starting Jupyter Lab. + # + # Jupytext is required for pair notebook/Python file functionality. + # Exits with error if jupytext is not installed. + # """ + if ! pip show jupytext > /dev/null 2>&1; then + echo "ERROR: jupytext is not installed but is required to run Jupyter Lab." + echo "Install it with: pip install jupytext" + exit 1 + fi +} + + +setup_jupyter_environment() { + # """ + # Configure Jupyter Lab environment before launching. + # + # Performs all necessary setup steps: + # - Configure vim keybindings + # - Disable notifications + # - Configure autosave interval + # - Verify jupytext is installed + # """ + configure_jupyter_vim_keybindings + configure_jupyter_notifications + configure_jupyter_autosave + check_jupytext_installed +} + + +get_jupyter_args() { + # """ + # Print the standard Jupyter Lab command-line arguments. + # + # :return: space-separated Jupyter Lab args for port 8888 with no browser, + # allow root, and no authentication + # """ + echo "--port=8888 --no-browser --ip=0.0.0.0 --allow-root --ServerApp.token='' --ServerApp.password=''" +} + + +get_run_jupyter_cmd() { + # """ + # Return the command to run run_jupyter.sh inside a container. + # + # Computes the script's path relative to GIT_ROOT and builds the + # corresponding /git_root/... path used inside the container. + # + # :param script_path: path of the calling script (pass ${BASH_SOURCE[0]}) + # :param cmd_opts: options to forward to run_jupyter.sh + # :return: full command string to run run_jupyter.sh + # """ + local script_path=$1 + local cmd_opts=$2 + local script_dir + script_dir=$(cd "$(dirname "$script_path")" && pwd) + local rel_dir="${script_dir#${GIT_ROOT}/}" + echo "/git_root/${rel_dir}/run_jupyter.sh $cmd_opts" +} + + +list_and_inspect_docker_image() { + # """ + # List available Docker images and inspect their architecture. + # + # Lists all images matching FULL_IMAGE_NAME and attempts to inspect + # their architecture using docker manifest inspect. + # """ + run "docker image ls $FULL_IMAGE_NAME" + (docker manifest inspect $FULL_IMAGE_NAME | grep arch) || true +} + + +kill_existing_container_if_forced() { + # """ + # Kill existing container if FORCE flag is set. + # + # If FORCE is set to 1, kills and removes the container with name + # CONTAINER_NAME. This is typically set by the -f flag. + # """ + if [[ $FORCE == 1 ]]; then + kill_container_by_name $CONTAINER_NAME + fi +} diff --git a/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/version.sh b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/version.sh new file mode 100644 index 000000000..c46ed254c --- /dev/null +++ b/class_project/data605/Spring2026/projects/UmdTask461_DATA605_Spring2026_Real_Time_Stock_Market_Pipeline_Kafka_Spark/version.sh @@ -0,0 +1,28 @@ +#!/bin/bash +# """ +# Display versions of installed tools and packages. +# +# This script prints version information for Python, pip, Jupyter, and all +# installed Python packages. Used for debugging and documentation purposes +# to verify the Docker container environment setup. +# """ + +# Display Python 3 version. +echo "# Python3" +python3 --version + +# Display pip version. +echo "# pip3" +pip3 --version + +# Display Jupyter version. +echo "# jupyter" +jupyter --version + +# List all installed Python packages and their versions. +echo "# Python packages" +pip3 list + +# Template for adding additional tool versions. +# echo "# mongo" +# mongod --version