From dc260f3304b3a43884e58ad1b40e0186a376a005 Mon Sep 17 00:00:00 2001 From: the-ride-never-ends Date: Fri, 28 Feb 2025 17:35:24 -0800 Subject: [PATCH] First commit: Created outline of red_ribbon and socialtoolkit classes. Architecture --- .gitignore | 2 - custom_nodes/red_ribbon/__init__.py | 28 + custom_nodes/red_ribbon/choice_lists.py | 46 ++ custom_nodes/red_ribbon/config_example.py | 34 ++ custom_nodes/red_ribbon/configs.py | 105 ++++ custom_nodes/red_ribbon/configs.yaml | 22 + custom_nodes/red_ribbon/main.py | 129 +++++ custom_nodes/red_ribbon/node_types.py | 74 +++ .../plug_in_play_transformer/__init__.py | 5 + .../plug_in_play_transformer.py | 22 + custom_nodes/red_ribbon/private_configs.yaml | 14 + custom_nodes/red_ribbon/red_ribbon.py | 40 ++ .../red_ribbon/red_ribbon_core/__init__.py | 39 ++ .../red_ribbon/red_ribbon_core/red_ribbon.py | 36 ++ .../red_ribbon/socialtoolkit/__init__.py | 37 ++ .../document_retrieval_from_websites.py | 156 ++++++ .../architecture/document_storage.py | 492 ++++++++++++++++++ .../architecture/high_level_architecture.py | 122 +++++ .../socialtoolkit/architecture/llm_service.py | 27 + .../architecture/prompt_decision_tree.py | 366 +++++++++++++ .../architecture/relevance_assessment.py | 452 ++++++++++++++++ .../architecture/top10_document_retrieval.py | 295 +++++++++++ .../architecture/variable_codebook.py | 384 ++++++++++++++ .../socialtoolkit/mermaid_charts/README.md | 248 +++++++++ ...olkit_document_retrieval_from_websites.png | Bin 0 -> 31272 bytes .../socialtoolkit_document_storage.png | Bin 0 -> 73178 bytes .../socialtoolkit_high_level_architecture.png | Bin 0 -> 32815 bytes .../socialtoolkit_prompt_decision_tree.png | Bin 0 -> 73099 bytes .../socialtoolkit_relevance_assessment.png | Bin 0 -> 36299 bytes ...socialtoolkit_top10_document_retrieval.png | Bin 0 -> 27079 bytes ...toolkit_variable_code_book_sample_page.png | Bin 0 -> 52509 bytes .../red_ribbon/socialtoolkit/socialtoolkit.py | 57 ++ custom_nodes/red_ribbon/utils/__init__.py | 58 +++ custom_nodes/red_ribbon/utils/utils.py | 39 ++ install.sh | 41 ++ requirements_custom_nodes.txt | 52 ++ start.sh | 22 + 37 files changed, 3442 insertions(+), 2 deletions(-) create mode 100644 custom_nodes/red_ribbon/__init__.py create mode 100644 custom_nodes/red_ribbon/choice_lists.py create mode 100644 custom_nodes/red_ribbon/config_example.py create mode 100644 custom_nodes/red_ribbon/configs.py create mode 100644 custom_nodes/red_ribbon/configs.yaml create mode 100644 custom_nodes/red_ribbon/main.py create mode 100644 custom_nodes/red_ribbon/node_types.py create mode 100644 custom_nodes/red_ribbon/plug_in_play_transformer/__init__.py create mode 100644 custom_nodes/red_ribbon/plug_in_play_transformer/plug_in_play_transformer.py create mode 100644 custom_nodes/red_ribbon/private_configs.yaml create mode 100644 custom_nodes/red_ribbon/red_ribbon.py create mode 100644 custom_nodes/red_ribbon/red_ribbon_core/__init__.py create mode 100644 custom_nodes/red_ribbon/red_ribbon_core/red_ribbon.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/__init__.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/architecture/document_retrieval_from_websites.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/architecture/document_storage.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/architecture/high_level_architecture.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/architecture/llm_service.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/architecture/prompt_decision_tree.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/architecture/relevance_assessment.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/architecture/top10_document_retrieval.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/architecture/variable_codebook.py create mode 100644 custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/README.md create mode 100644 custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_document_retrieval_from_websites.png create mode 100644 custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_document_storage.png create mode 100644 custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_high_level_architecture.png create mode 100644 custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_prompt_decision_tree.png create mode 100644 custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_relevance_assessment.png create mode 100644 custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_top10_document_retrieval.png create mode 100644 custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_variable_code_book_sample_page.png create mode 100644 custom_nodes/red_ribbon/socialtoolkit/socialtoolkit.py create mode 100644 custom_nodes/red_ribbon/utils/__init__.py create mode 100644 custom_nodes/red_ribbon/utils/utils.py create mode 100644 install.sh create mode 100644 requirements_custom_nodes.txt create mode 100644 start.sh diff --git a/.gitignore b/.gitignore index 61881b8a..5fca1d97 100644 --- a/.gitignore +++ b/.gitignore @@ -5,8 +5,6 @@ __pycache__/ !/input/example.png /models/ /temp/ -/custom_nodes/ -!custom_nodes/example_node.py.example extra_model_paths.yaml /.vs .vscode/ diff --git a/custom_nodes/red_ribbon/__init__.py b/custom_nodes/red_ribbon/__init__.py new file mode 100644 index 00000000..e7f398fd --- /dev/null +++ b/custom_nodes/red_ribbon/__init__.py @@ -0,0 +1,28 @@ +""" +Red Ribbon - A collection of custom nodes for ComfyUI +""" + +import easy_nodes +import os + +# Version information +__version__ = "0.1.0" + +# NOTE This only needs to be called once. +easy_nodes.initialize_easy_nodes(default_category="Red Ribbon") + +# Import all modules - this must come after calling initialize_easy_nodes +from . import main + +# Get the combined node mappings for ComfyUI +NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS = easy_nodes.get_node_mappings() + +# Export so that ComfyUI can pick them up. +__all__ = ['NODE_CLASS_MAPPINGS', 'NODE_DISPLAY_NAME_MAPPINGS'] + +# Optional: export the node list to a file so that e.g. ComfyUI-Manager can pick it up. +easy_nodes.save_node_list( + os.path.join(os.path.dirname(__file__), "red_ribbon_node_list.json") +) + +print(f"Red Ribbon v{__version__}: Successfully loaded {len(NODE_CLASS_MAPPINGS)} nodes") \ No newline at end of file diff --git a/custom_nodes/red_ribbon/choice_lists.py b/custom_nodes/red_ribbon/choice_lists.py new file mode 100644 index 00000000..498ebbd1 --- /dev/null +++ b/custom_nodes/red_ribbon/choice_lists.py @@ -0,0 +1,46 @@ + + +class GetChoices: + + def __init__(self, resources, configs): + self.resources = resources + self.configs = configs + + def get_choices(self, source: str): + """ + Get choices of things from certain websites + + """ + + + + +# Create a list of available models for the API +AVAILABLE_MODELS: list[str] = [] +ANTHROPIC_MODELS = [ + "claude-3-5-sonnet-latest", + "claude-3-5-haiku-latest", + "claude-3-opus-latest", +] +OPEN_AI_MODELS = [ + "gpt-4o", + "chatgpt-4o-latest", + "gpt-4o-mini", + "o1", + "o1-mini", + "o1-preview", + "gpt-4o-realtime-preview", + "gpt-4o-mini-realtime-preview", + "gpt-4o-audio-preview", +] +AVAILABLE_MODELS.extend(ANTHROPIC_MODELS) +AVAILABLE_MODELS.extend(OPEN_AI_MODELS) + + +OPEN_AI_EMBEDDING_MODELS = [ + "text-embedding-3-small", + "text-embedding-3-large", + "text-embedding-ada-002", +] +TEXT_EMBEDDING_MODELS = [] +TEXT_EMBEDDING_MODELS.append(OPEN_AI_EMBEDDING_MODELS) \ No newline at end of file diff --git a/custom_nodes/red_ribbon/config_example.py b/custom_nodes/red_ribbon/config_example.py new file mode 100644 index 00000000..665de15c --- /dev/null +++ b/custom_nodes/red_ribbon/config_example.py @@ -0,0 +1,34 @@ +#!/usr/bin/env python +# Example of using the Configs class + +from configs import Configs + +def main(): + # Get the configuration instance + config = Configs.get() + + # Access configuration values as read-only properties + print("API URL:", config.API_URL) + print("Debug Mode:", config.DEBUG_MODE) + print("Max Batch Size:", config.MAX_BATCH_SIZE) + + # Access nested dictionary values + print("\nModel Paths:") + for model_type, path in config.MODEL_PATHS.items(): + print(f" {model_type}: {path}") + + print("\nCustom Settings:") + for key, value in config.CUSTOM_SETTINGS.items(): + print(f" {key}: {value}") + + # Attempt to modify a value (will raise an error due to frozen=True) + try: + config.API_URL = "http://new-url.com" + except Exception as e: + print(f"\nAttempted to modify API_URL and got: {type(e).__name__}: {e}") + + # Configuration stays unchanged + print("\nAPI URL is still:", config.API_URL) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/custom_nodes/red_ribbon/configs.py b/custom_nodes/red_ribbon/configs.py new file mode 100644 index 00000000..a995f15e --- /dev/null +++ b/custom_nodes/red_ribbon/configs.py @@ -0,0 +1,105 @@ +from pathlib import Path +from typing import Any, Dict, Optional +import os +import yaml +from pydantic import BaseModel, Field +from functools import lru_cache + + + +class Paths(BaseModel): + THIS_FILE = Path(__file__).resolve() + RED_RIBBON_DIR = THIS_FILE.parent + CUSTOM_NODES_DIR = RED_RIBBON_DIR.parent + COMFYUI_DIR = CUSTOM_NODES_DIR.parent + LLM_OUTPUTS_DIR = COMFYUI_DIR / "output" / "red_ribbon_outputs" + LLM_MODELS_DIR = COMFYUI_DIR / "models" / "llm_models" + + class Config: + frozen = True # Make the model immutable (read-only) + + +class SocialToolkitConfigs(BaseModel): + """Configuration for High Level Architecture workflow""" + approved_document_sources: list[str] + llm_api_config: dict[str, Any] + document_retrieval_threshold: int = 10 + relevance_threshold: float = 0.7 + output_format: str = "json" + + codebook: Optional[dict[str, Any]] = None + document_retrieval: Optional[dict[str, Any]] = None + llm_service: Optional[dict[str, Any]] = None + top10_retrieval: Optional[dict[str, Any]] = None + relevance_assessment: Optional[dict[str, Any]] = None + prompt_decision_tree: Optional[dict[str, Any]] = None + + +class ConfigsBase(BaseModel): + """Base model for configuration with read-only fields.""" + + class Config: + frozen = True # Make the model immutable (read-only) + + +@lru_cache() +def get_config() -> 'Configs': + """ + Load configuration from YAML files and cache the result. + Returns a read-only Configs object. + """ + base_dir = os.path.dirname(os.path.abspath(__file__)) + + # Load main configs + config_path = os.path.join(base_dir, "configs.yaml") + config_data = {} + if os.path.exists(config_path): + with open(config_path, 'r') as f: + config_data = yaml.safe_load(f) or {} + + # Load private configs (overrides main configs) + private_config_path = os.path.join(base_dir, "private_configs.yaml") + private_config_data = {} + if os.path.exists(private_config_path): + with open(private_config_path, 'r') as f: + private_config_data = yaml.safe_load(f) or {} + + # Merge configs, with private taking precedence + merged_config = {**config_data, **private_config_data} + + return Configs(**merged_config) + + +class Configs(ConfigsBase): + """ + Configuration constants loaded from YAML files. + All fields are read-only. + + Loads from: + - configs.yaml (base configuration) + - private_configs.yaml (overrides base configuration) + """ + # Add your configuration fields here with defaults + # Example: + API_URL: str = Field("http://localhost:8000", description="API URL") + DEBUG_MODE: bool = Field(default=False, description="Enable debug mode") + MAX_BATCH_SIZE: int = Field(default=4, description="Maximum batch size") + MODEL_PATHS: Dict[str, str] = Field(default_factory=dict, description="Paths to models") + CUSTOM_SETTINGS: Dict[str, Any] = Field(default_factory=dict, description="Custom configuration settings") + + _paths: Paths = Field(default_factory=Paths) + _socialtoolkit: SocialToolkitConfigs = Field(default_factory=SocialToolkitConfigs) + + # Access the singleton instance through this class method + @classmethod + def get(cls) -> 'Configs': + """Get the singleton instance of Configs.""" + return get_config() + + @property + def paths(self) -> Paths: + return self._paths + + @property + def socialtoolkit(self) -> SocialToolkitConfigs: + return self._socialtoolkit \ No newline at end of file diff --git a/custom_nodes/red_ribbon/configs.yaml b/custom_nodes/red_ribbon/configs.yaml new file mode 100644 index 00000000..67d7dbc8 --- /dev/null +++ b/custom_nodes/red_ribbon/configs.yaml @@ -0,0 +1,22 @@ +# Main Configuration File +# These are the default settings that can be overridden by private_configs.yaml + +# API Settings +API_URL: "http://localhost:8000" +DEBUG_MODE: false +MAX_BATCH_SIZE: 4 + +# Model Paths +MODEL_PATHS: + stable_diffusion: "models/stable-diffusion" + controlnet: "models/controlnet" + vae: "models/vae" + lora: "models/lora" + +# Custom Settings +CUSTOM_SETTINGS: + cache_dir: "cache" + temp_dir: "temp" + max_image_size: 2048 + default_sampler: "euler_a" + default_scheduler: "normal" \ No newline at end of file diff --git a/custom_nodes/red_ribbon/main.py b/custom_nodes/red_ribbon/main.py new file mode 100644 index 00000000..ed656e0c --- /dev/null +++ b/custom_nodes/red_ribbon/main.py @@ -0,0 +1,129 @@ +""" +Red Ribbon - Main module for importing and registering all nodes +""" +from typing import Type + + +from easy_nodes import ( + NumberInput, + ComfyNode, + StringInput, + Choice, +) + + +# Import components from subdirectories +from .socialtoolkit.socialtoolkit import SocialToolkitAPI +from .red_ribbon_core.red_ribbon import RedRibbonAPI +from .plug_in_play_transformer.plug_in_play_transformer import TransformerAPI +from .utils.utils import UtilsAPI +from .configs import Configs +from .node_types import register_pydantic_models + + +modules_to_register = [ + "red_ribbon", + "socialtoolkit", + "utils", + "plug_in_play_transformer", + "configs", +] +register_pydantic_models(modules_to_register) + + +class RedRibbonPackage: + """Main interface for the Red Ribbon package""" + + def __init__(self, resources: dict[str, object] = None, configs: Configs = None): + """Initialize the Red Ribbon package components""" + self.configs = configs + self.resources = resources + + self.social: Type[SocialToolkitAPI] = self.resources.get("social") + self.rr: Type[RedRibbonAPI] = self.resources.get("rr") + self.trans: Type[TransformerAPI] = self.resources.get("trans") + self.utils: Type[UtilsAPI] = self.resources.get("utils") + + def version(self): + """Get the version of the Red Ribbon package""" + from . import __version__ + return __version__ + + +rr_resources = { +} +social_resources = { +} +trans_resources = { +} +utils_resources = { +} + +configs = Configs() +resources = { + "social": SocialToolkitAPI(social_resources, configs), + "rr": RedRibbonAPI(rr_resources, configs), + "trans": TransformerAPI(trans_resources, configs), + "utils": UtilsAPI(utils_resources, configs) +} + +# Initialize the Red Ribbon package +package = RedRibbonPackage(resources, configs) + + +@ComfyNode("Socialtoolkit", + color="#d30e0e", + bg_color="#ff0000", + display_name="Rank and Sort Similarity Search Results") +def rank_and_sort_similar_search_results( + search_results: list, + search_query: str, + search_type: str, + rank_by: str, + sort_by: str +) -> list: + """ + Rank and sort similarity search results. + """ + return package.social.rank_and_sort_similar_search_results( + search_results, + search_query, + search_type, + rank_by, + sort_by + ) + +@ComfyNode("Socialtoolkit", + color="#d30e0e", + bg_color="#ff0000", + display_name="Retrieve Documents from Websites") +def document_retrieval_from_websites( + domain_urls: list[str] +) -> tuple['Document', 'Metadata', 'Vectors']: + """ + Document retrieval from websites. + """ + resources: dict[str, object], + configs: Configs + + socialtoolkit = SocialToolkitAPI(resources, configs) + return socialtoolkit.document_retrieval_from_websites( + domain_urls + ) + + +# Main function that can be called when using this as a script +def main(): + print("Red Ribbon package loaded successfully") + package = RedRibbonPackage() + print(f"Version: {package.version()}") + print("Available components:") + print("- SocialToolkit") + print("- RedRibbon Core") + print("- Plug-in-Play Transformer") + print("- Utils") + +if __name__ == "__main__": + main() + + diff --git a/custom_nodes/red_ribbon/node_types.py b/custom_nodes/red_ribbon/node_types.py new file mode 100644 index 00000000..5e90e293 --- /dev/null +++ b/custom_nodes/red_ribbon/node_types.py @@ -0,0 +1,74 @@ +import importlib +import inspect +from typing import Type + +from easy_nodes import register_type +from easy_nodes.easy_nodes import AnythingVerifier +try: + from pydantic import BaseModel +except ImportError: + print("Pydantic not found. Please install it with 'pip install pydantic'") + BaseModel = object # Fallback if pydantic isn't installed + + +def registration_callback(register_these_classes: list[Type[BaseModel]]) -> None: + for this_class in register_these_classes: + with_its_class_name_in_all_caps: str = this_class.__qualname__.upper() + register_type(this_class, with_its_class_name_in_all_caps, verifier=AnythingVerifier()) + + +def register_pydantic_models( + module_names: list[str], +) -> None: + """ + Loads Pydantic classes from specified modules and registers them. + + Args: + module_names: list of module names to search for Pydantic models + registration_callback: Optional function to call for each model (for registration) + If None, a dummy registration function will be used + + Returns: + Side-effect: registers Pydantic models with EasyNodes. + """ + models = [] + for module_name in module_names: + try: + # Import the module + module = importlib.import_module(module_name) + + # Find all Pydantic classes in the module + for _, obj in inspect.getmembers(module): + # Check if it's a class and a subclass of BaseModel but not BaseModel itself + if (inspect.isclass(obj) and + issubclass(obj, BaseModel) and + obj is not BaseModel): + models.append(obj) + except ImportError as e: + print(f"Error importing module {module_name}: {e}") + except Exception as e: + print(f"Error processing module {module_name}: {e}") + + # Register the model using the provided callback + try: + registration_callback(models) + except Exception as e: + print(f"{type(e)} registering models: {e}") + + return models + +# Example usage: +# if __name__ == "__main__": +# modules_to_scan = ["your_module.models", "another_module.types"] +# models = register_pydantic_models(modules_to_scan) +# print(f"Found {len(models)} Pydantic models") + + + + + + + + + + diff --git a/custom_nodes/red_ribbon/plug_in_play_transformer/__init__.py b/custom_nodes/red_ribbon/plug_in_play_transformer/__init__.py new file mode 100644 index 00000000..e9ee854d --- /dev/null +++ b/custom_nodes/red_ribbon/plug_in_play_transformer/__init__.py @@ -0,0 +1,5 @@ +""" +Plug-in-Play Transformer Module for Red Ribbon +""" + + diff --git a/custom_nodes/red_ribbon/plug_in_play_transformer/plug_in_play_transformer.py b/custom_nodes/red_ribbon/plug_in_play_transformer/plug_in_play_transformer.py new file mode 100644 index 00000000..45f18968 --- /dev/null +++ b/custom_nodes/red_ribbon/plug_in_play_transformer/plug_in_play_transformer.py @@ -0,0 +1,22 @@ +""" +Plug-in-Play Transformer - Main entrance file for transformer functionality +""" + +from . import PiPTransformerNode + +class TransformerAPI: + """API for accessing Transformer functionality from other modules""" + + def __init__(self, resources, configs): + self.configs = configs + self.resources = resources + +# Main function that can be called when using this as a script +def main(): + print("Plug-in-Play Transformer module loaded successfully") + print("Available tools:") + print("- PiPTransformerNode: Node for ComfyUI integration") + print("- TransformerAPI: API for programmatic access") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/custom_nodes/red_ribbon/private_configs.yaml b/custom_nodes/red_ribbon/private_configs.yaml new file mode 100644 index 00000000..bac67338 --- /dev/null +++ b/custom_nodes/red_ribbon/private_configs.yaml @@ -0,0 +1,14 @@ +# Private Configuration File +# These settings override the ones in configs.yaml +# Add this file to .gitignore to keep sensitive information private + +# API Settings +API_URL: "http://localhost:8001" # Override the default port + +# Custom private settings +DEBUG_MODE: true # Enable debug mode in development environment + +# Custom Settings with overrides +CUSTOM_SETTINGS: + api_key: "your_secret_api_key_here" # Add private API keys + database_url: "postgresql://user:password@localhost:5432/db" \ No newline at end of file diff --git a/custom_nodes/red_ribbon/red_ribbon.py b/custom_nodes/red_ribbon/red_ribbon.py new file mode 100644 index 00000000..7fdd07d3 --- /dev/null +++ b/custom_nodes/red_ribbon/red_ribbon.py @@ -0,0 +1,40 @@ +""" +Red Ribbon - Main entrance file for the entire Red Ribbon package +""" + +# Import components from subdirectories +from .socialtoolkit.socialtoolkit import SocialToolkitAPI +from .red_ribbon_core.red_ribbon import RedRibbonAPI +from .plug_in_play_transformer.plug_in_play_transformer import TransformerAPI +from .utils.utils import UtilsAPI + + +from .main import package + + + +# Main function that can be called when using this as a script +def main(): + print("Red Ribbon package loaded successfully") + print(f"Version: {package.version()}") + print("Available components:") + print("- SocialToolkit") + print("- RedRibbon Core") + print("- Plug-in-Play Transformer") + print("- Utils") + while True: + choice_was = input("Enter your choice: ") + match choice_was: + case "SocialToolkit": + print("SocialToolkitAPI") + case "RedRibbon Core": + print("RedRibbonAPI") + case "Plug-in-Play Transformer": + print("TransformerAPI") + case "Utils": + print("UtilsAPI") + case _: + print("Invalid choice. Try again.") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/custom_nodes/red_ribbon/red_ribbon_core/__init__.py b/custom_nodes/red_ribbon/red_ribbon_core/__init__.py new file mode 100644 index 00000000..daed1306 --- /dev/null +++ b/custom_nodes/red_ribbon/red_ribbon_core/__init__.py @@ -0,0 +1,39 @@ +""" +Red Ribbon Core Module +""" + +class RedRibbonNode: + """Main node for Red Ribbon functionality""" + + @classmethod + def INPUT_TYPES(cls): + return { + "required": { + "image": ("IMAGE",), + "effect": (["basic", "advanced", "extreme"], {"default": "basic"}), + "intensity": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 2.0, "step": 0.01}), + }, + } + + RETURN_TYPES = ("IMAGE",) + FUNCTION = "process" + CATEGORY = "Red Ribbon/Effects" + + def process(self, image, effect, intensity): + # Process the image with Red Ribbon effects + # In a real implementation, this would apply the selected effect + return (image,) + +# Dictionary of nodes to be imported by main.py +NODE_CLASS_MAPPINGS = { + "RedRibbonNode": RedRibbonNode +} + +# Add display names for the nodes +NODE_DISPLAY_NAME_MAPPINGS = { + "RedRibbonNode": "Red Ribbon Effect" +} + +# Function to be called from main.py +def red_ribbon(): + return NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS \ No newline at end of file diff --git a/custom_nodes/red_ribbon/red_ribbon_core/red_ribbon.py b/custom_nodes/red_ribbon/red_ribbon_core/red_ribbon.py new file mode 100644 index 00000000..0759ceb1 --- /dev/null +++ b/custom_nodes/red_ribbon/red_ribbon_core/red_ribbon.py @@ -0,0 +1,36 @@ +""" +Red Ribbon - Main entrance file for core Red Ribbon functionality +""" + +from . import RedRibbonNode + +class RedRibbonAPI: + """API for accessing Red Ribbon functionality from other modules""" + + def __init__(self, resources, configs): + self.configs = configs + self.resources = resources + + def create_text_embedding(self, text): + """Create an embedding for the given text + + Args: + text (str): The text to embed + + Returns: + list: The embedding vector + """ + # In a real implementation, this would use an actual embedding model + embedding = [ord(char) for char in text] + return embedding + + +# Main function that can be called when using this as a script +def main(): + print("Red Ribbon core module loaded successfully") + print("Available tools:") + print("- RedRibbonNode: Node for ComfyUI integration") + print("- RedRibbonAPI: API for programmatic access") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/custom_nodes/red_ribbon/socialtoolkit/__init__.py b/custom_nodes/red_ribbon/socialtoolkit/__init__.py new file mode 100644 index 00000000..c15adfb5 --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/__init__.py @@ -0,0 +1,37 @@ +""" +Social Toolkit Module for Red Ribbon +""" + +class SocialToolkitNode: + """Node for social media integration tools""" + + @classmethod + def INPUT_TYPES(cls): + return { + "required": { + "text": ("STRING", {"multiline": True}), + "platform": (["twitter", "instagram", "facebook"], {"default": "twitter"}), + }, + } + + RETURN_TYPES = ("STRING",) + FUNCTION = "process" + CATEGORY = "Red Ribbon/Social" + + def process(self, text, platform): + # Process the text for social media + return (f"[{platform.upper()}]: {text}",) + +# Dictionary of nodes to be imported by main.py +NODE_CLASS_MAPPINGS = { + "SocialToolkitNode": SocialToolkitNode +} + +# Add display names for the nodes +NODE_DISPLAY_NAME_MAPPINGS = { + "SocialToolkitNode": "Social Media Toolkit" +} + +# Function to be called from main.py +def socialtoolkit(): + return NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS \ No newline at end of file diff --git a/custom_nodes/red_ribbon/socialtoolkit/architecture/document_retrieval_from_websites.py b/custom_nodes/red_ribbon/socialtoolkit/architecture/document_retrieval_from_websites.py new file mode 100644 index 00000000..ea309a83 --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/architecture/document_retrieval_from_websites.py @@ -0,0 +1,156 @@ +from pydantic import BaseModel +from typing import Dict, List, Any, Optional, Tuple +from enum import Enum +import logging + +logger = logging.getLogger(__name__) + +class WebpageType(str, Enum): + STATIC = "static" + DYNAMIC = "dynamic" + +class DocumentRetrievalConfigs(BaseModel): + """Configuration for Document Retrieval from Websites workflow""" + timeout_seconds: int = 30 + max_retries: int = 3 + user_agent: str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" + dynamic_rendering_wait_time: int = 5 + selenium_enabled: bool = False + headers: Dict[str, str] = {} + batch_size: int = 10 + follow_links: bool = False + max_depth: int = 1 + + +class DocumentRetrievalFromWebsites: + """ + Document Retrieval from Websites for data extraction system + based on mermaid chart in README.md + """ + + def __init__(self, resources: Dict[str, Any], configs: DocumentRetrievalConfigs): + """ + Initialize with injected dependencies and configuration + + Args: + resources: Dictionary of resources including services + configs: Configuration for Document Retrieval + """ + self.resources = resources + self.configs = configs + + # Extract needed services from resources + self.static_webpage_parser = resources.get("static_webpage_parser") + self.dynamic_webpage_parser = resources.get("dynamic_webpage_parser") + self.data_extractor = resources.get("data_extractor") + self.vector_generator = resources.get("vector_generator") + self.metadata_generator = resources.get("metadata_generator") + self.document_storage = resources.get("document_storage_service") + self.url_path_generator = resources.get("url_path_generator") + + logger.info("DocumentRetrievalFromWebsites initialized with services") + + def execute(self, domain_urls: List[str]) -> Dict[str, Any]: + """ + Execute the document retrieval flow based on the mermaid chart + + Args: + domain_urls: List of domain URLs to retrieve documents from + + Returns: + Dictionary containing retrieved documents, metadata, and vectors + """ + logger.info(f"Starting document retrieval from {len(domain_urls)} domains") + + all_documents = [] + all_metadata = [] + all_vectors = [] + + for domain_url in domain_urls: + # Step 1: Generate URLs from domain URL + urls = self._generate_urls(domain_url) + + for url in urls: + # Step 2: Determine webpage type and parse accordingly + webpage_type = self._determine_webpage_type(url) + + if webpage_type == WebpageType.STATIC: + raw_data = self.static_webpage_parser.parse(url) + else: + raw_data = self.dynamic_webpage_parser.parse(url) + + # Step 3: Extract structured data from raw data + raw_strings = self.data_extractor.extract(raw_data) + + # Step 4: Generate documents, vectors, and metadata + documents = self._create_documents(raw_strings, url) + document_vectors = self.vector_generator.generate(documents) + document_metadata = self.metadata_generator.generate(documents, url) + + all_documents.extend(documents) + all_vectors.extend(document_vectors) + all_metadata.extend(document_metadata) + + # Step 5: Store documents, vectors, and metadata + self.document_storage.store(all_documents, all_metadata, all_vectors) + + logger.info(f"Retrieved and stored {len(all_documents)} documents") + return { + "documents": all_documents, + "metadata": all_metadata, + "vectors": all_vectors + } + + def retrieve_documents(self, domain_urls: List[str]) -> Tuple[List[Any], List[Any], List[Any]]: + """ + Public method to retrieve documents from websites + + Args: + domain_urls: List of domain URLs to retrieve documents from + + Returns: + Tuple of (documents, metadata, vectors) + """ + result = self.control_flow(domain_urls) + return ( + result["documents"], + result["metadata"], + result["vectors"] + ) + + def _generate_urls(self, domain_url: str) -> List[str]: + """Generate URLs from domain URL using URL path generator""" + return self.url_path_generator.generate(domain_url) + + def _determine_webpage_type(self, url: str) -> WebpageType: + """ + Determine whether a webpage is static or dynamic + + This is a simple implementation that could be enhanced with + more sophisticated detection mechanisms + """ + # Check URL patterns that typically indicate dynamic content + dynamic_indicators = [ + "#!", "?", "api", "ajax", "load", "spa", "react", + "angular", "vue", "dynamic", "js-rendered" + ] + + for indicator in dynamic_indicators: + if indicator in url.lower(): + return WebpageType.DYNAMIC + + return WebpageType.STATIC + + def _create_documents(self, raw_strings: List[str], url: str) -> List[Any]: + """Create documents from raw strings""" + # Implementation would create document objects from raw text content + # This is a placeholder implementation + documents = [] + for i, content in enumerate(raw_strings): + documents.append({ + "id": f"{url}_{i}", + "content": content, + "url": url, + "timestamp": self.resources.get("timestamp_service").now() + }) + return documents \ No newline at end of file diff --git a/custom_nodes/red_ribbon/socialtoolkit/architecture/document_storage.py b/custom_nodes/red_ribbon/socialtoolkit/architecture/document_storage.py new file mode 100644 index 00000000..ce82861a --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/architecture/document_storage.py @@ -0,0 +1,492 @@ +from pydantic import BaseModel +from typing import Dict, List, Any, Optional, Tuple +from enum import Enum +from uuid import UUID, uuid4 +from datetime import datetime +import logging + +logger = logging.getLogger(__name__) + +class DocumentStatus(str, Enum): + NEW = "new" + PROCESSING = "processing" + COMPLETE = "complete" + ERROR = "error" + +class VersionStatus(str, Enum): + DRAFT = "draft" + ACTIVE = "active" + SUPERSEDED = "superseded" + +class SourceType(str, Enum): + PRIMARY = "primary" + SECONDARY = "secondary" + TERTIARY = "tertiary" + +class DocumentStorageConfigs(BaseModel): + """Configuration for Document Storage""" + database_connection_string: str + cache_enabled: bool = True + cache_ttl_seconds: int = 3600 + batch_size: int = 100 + vector_dim: int = 1536 # Common dimension for embeddings like OpenAI's + storage_type: str = "sql" # Alternatives: "nosql", "in_memory", etc. + +class DocumentStorage: + """ + Document Storage system based on mermaid ER diagram in README.md + Manages the storage and retrieval of documents, versions, metadata, and vectors + """ + + def __init__(self, resources: Dict[str, Any], configs: DocumentStorageConfigs): + """ + Initialize with injected dependencies and configuration + + Args: + resources: Dictionary of resources including storage services + configs: Configuration for Document Storage + """ + self.resources = resources + self.configs = configs + + # Extract needed services from resources + self.db_service = resources.get("database_service") + self.cache_service = resources.get("cache_service") + self.vector_store = resources.get("vector_store_service") + self.id_generator = resources.get("id_generator_service", self._generate_uuid) + + logger.info("DocumentStorage initialized with services") + + def execute(self, action: str, **kwargs) -> Dict[str, Any]: + """ + Execute document storage operations based on the action + + Args: + action: Operation to perform (store, retrieve, update, delete) + **kwargs: Operation-specific parameters + + Returns: + Dictionary containing operation results + """ + logger.info(f"Starting document storage operation: {action}") + + if action == "store": + return self._store_documents( + kwargs.get("documents", []), + kwargs.get("metadata", []), + kwargs.get("vectors", []) + ) + elif action == "retrieve": + return self._retrieve_documents( + document_ids=kwargs.get("document_ids", []), + filters=kwargs.get("filters", {}) + ) + elif action == "update": + return self._update_documents( + kwargs.get("documents", []) + ) + elif action == "delete": + return self._delete_documents( + kwargs.get("document_ids", []) + ) + elif action == "get_vectors": + return self._get_vectors( + kwargs.get("document_ids", []) + ) + else: + logger.error(f"Unknown action: {action}") + raise ValueError(f"Unknown action: {action}") + + def store(self, documents: List[Any], metadata: List[Any], vectors: List[Any]) -> Dict[str, Any]: + """ + Store documents, metadata, and vectors + + Args: + documents: Documents to store + metadata: Metadata for the documents + vectors: Vectors for the documents + + Returns: + Dictionary with storage status + """ + return self.control_flow("store", documents=documents, metadata=metadata, vectors=vectors) + + def get_documents_and_vectors(self, document_ids: List[str] = None, + filters: Dict[str, Any] = None) -> Tuple[List[Any], List[Any]]: + """ + Retrieve documents and their vectors + + Args: + document_ids: Optional list of document IDs to retrieve + filters: Optional filters to apply + + Returns: + Tuple of (documents, vectors) + """ + result = self.control_flow( + "retrieve", document_ids=document_ids, filters=filters + ) + documents = result.get("documents", []) + + vectors_result = self.control_flow( + "get_vectors", document_ids=[doc.get("id") for doc in documents] + ) + vectors = vectors_result.get("vectors", []) + + return documents, vectors + + def _store_documents(self, documents: List[Any], metadata: List[Any], vectors: List[Any]) -> Dict[str, Any]: + """Store documents, metadata, and vectors in the database""" + try: + # 1. Store source information if needed + source_ids = self._store_sources(documents) + + # 2. Store documents + document_ids = self._store_document_entries(documents, source_ids) + + # 3. Create versions for documents + version_ids = self._create_versions(document_ids) + + # 4. Store metadata + self._store_metadata(metadata, document_ids) + + # 5. Store content + content_ids = self._store_content(documents, version_ids) + + # 6. Create version-content associations + self._create_version_content_links(version_ids, content_ids) + + # 7. Store vectors + self._store_vectors(vectors, content_ids) + + return { + "success": True, + "document_ids": document_ids, + "version_ids": version_ids, + "content_ids": content_ids + } + except Exception as e: + logger.error(f"Error storing documents: {e}") + return { + "success": False, + "error": str(e) + } + + def _retrieve_documents(self, document_ids: List[str] = None, + filters: Dict[str, Any] = None) -> Dict[str, Any]: + """Retrieve documents from the database""" + try: + documents = [] + + # Use document IDs if provided, otherwise use filters + if document_ids: + query = f"SELECT * FROM Documents WHERE document_id IN ({','.join(['?']*len(document_ids))})" + documents = self.db_service.execute(query, document_ids) + elif filters: + # Build WHERE clause based on filters + where_clauses = [] + params = [] + + for key, value in filters.items(): + where_clauses.append(f"{key} = ?") + params.append(value) + + query = f"SELECT * FROM Documents WHERE {' AND '.join(where_clauses)}" + documents = self.db_service.execute(query, params) + else: + # Retrieve all documents (with limit) + query = f"SELECT * FROM Documents LIMIT {self.configs.batch_size}" + documents = self.db_service.execute(query) + + return { + "success": True, + "documents": documents + } + except Exception as e: + logger.error(f"Error retrieving documents: {e}") + return { + "success": False, + "error": str(e) + } + + def _update_documents(self, documents: List[Any]) -> Dict[str, Any]: + """Update existing documents""" + # Implementation for updating documents + return {"success": True} + + def _delete_documents(self, document_ids: List[str]) -> Dict[str, Any]: + """Delete documents by ID""" + # Implementation for deleting documents + return {"success": True} + + def _get_vectors(self, document_ids: List[str]) -> Dict[str, Any]: + """Get vectors for the specified document IDs""" + try: + # Get content IDs for the documents + content_ids_query = """ + SELECT c.content_id FROM Contents c + JOIN VersionsContents vc ON c.content_id = vc.content_id + JOIN Versions v ON vc.version_id = v.version_id + JOIN Documents d ON v.document_id = d.document_id + WHERE d.document_id IN ({}) AND v.current_version = 1 + """.format(','.join(['?']*len(document_ids))) + + content_ids_result = self.db_service.execute(content_ids_query, document_ids) + content_ids = [r["content_id"] for r in content_ids_result] + + # Get vectors for the content + vectors_query = f""" + SELECT * FROM Vectors WHERE content_id IN ({','.join(['?']*len(content_ids))}) + """ + vectors = self.db_service.execute(vectors_query, content_ids) + + return { + "success": True, + "vectors": vectors + } + except Exception as e: + logger.error(f"Error retrieving vectors: {e}") + return { + "success": False, + "error": str(e), + "vectors": [] + } + + # Helper methods for database operations + def _store_sources(self, documents: List[Any]) -> Dict[str, str]: + """Store sources and return a mapping of URL to source_id""" + source_map = {} + for doc in documents: + url = doc.get("url", "") + domain = self._extract_domain(url) + + if domain not in source_map: + source_id = self.id_generator() + + # Check if source already exists + query = "SELECT id FROM Sources WHERE id = ?" + result = self.db_service.execute(query, [domain]) + + if not result: + # Insert new source + insert_query = "INSERT INTO Sources (id) VALUES (?)" + self.db_service.execute(insert_query, [domain]) + + source_map[domain] = domain # Source ID is the domain + + return source_map + + def _store_document_entries(self, documents: List[Any], source_ids: Dict[str, str]) -> List[str]: + """Store document entries and return document IDs""" + document_ids = [] + + for doc in documents: + url = doc.get("url", "") + domain = self._extract_domain(url) + source_id = source_ids.get(domain) + + document_id = self.id_generator() + document_type = self._determine_document_type(url) + + # Insert document + insert_query = """ + INSERT INTO Documents ( + document_id, source_id, url, document_type, + status, priority + ) VALUES (?, ?, ?, ?, ?, ?) + """ + + params = [ + document_id, + source_id, + url, + document_type, + DocumentStatus.NEW.value, + 5 # Default priority + ] + + self.db_service.execute(insert_query, params) + document_ids.append(document_id) + + return document_ids + + def _create_versions(self, document_ids: List[str]) -> List[str]: + """Create initial versions for documents""" + version_ids = [] + + for document_id in document_ids: + version_id = self.id_generator() + + # Insert version + insert_query = """ + INSERT INTO Versions ( + version_id, document_id, current_version, + version_number, status, processed_at + ) VALUES (?, ?, ?, ?, ?, ?) + """ + + params = [ + version_id, + document_id, + True, # Current version + "1.0", # Initial version + VersionStatus.ACTIVE.value, + datetime.now() + ] + + self.db_service.execute(insert_query, params) + + # Update document with current version ID + update_query = """ + UPDATE Documents + SET current_version_id = ?, status = ? + WHERE document_id = ? + """ + + update_params = [ + version_id, + DocumentStatus.COMPLETE.value, + document_id + ] + + self.db_service.execute(update_query, update_params) + version_ids.append(version_id) + + return version_ids + + def _store_metadata(self, metadata_list: List[Any], document_ids: List[str]) -> None: + """Store metadata for documents""" + for i, metadata in enumerate(metadata_list): + if i >= len(document_ids): + break + + document_id = document_ids[i] + metadata_id = self.id_generator() + + # Insert metadata + insert_query = """ + INSERT INTO Metadatas ( + metadata_id, document_id, other_metadata, + created_at, updated_at + ) VALUES (?, ?, ?, ?, ?) + """ + + params = [ + metadata_id, + document_id, + metadata.get("metadata", "{}"), + datetime.now(), + datetime.now() + ] + + self.db_service.execute(insert_query, params) + + def _store_content(self, documents: List[Any], version_ids: List[str]) -> List[str]: + """Store content for document versions""" + content_ids = [] + + for i, doc in enumerate(documents): + if i >= len(version_ids): + break + + version_id = version_ids[i] + content_id = self.id_generator() + + # Insert content + insert_query = """ + INSERT INTO Contents ( + content_id, version_id, raw_content, + processed_content, hash + ) VALUES (?, ?, ?, ?, ?) + """ + + content = doc.get("content", "") + processed_content = content # In reality, this might go through processing + content_hash = self._generate_hash(content) + + params = [ + content_id, + version_id, + content, + processed_content, + content_hash + ] + + self.db_service.execute(insert_query, params) + content_ids.append(content_id) + + return content_ids + + def _create_version_content_links(self, version_ids: List[str], content_ids: List[str]) -> None: + """Create links between versions and content""" + for i, version_id in enumerate(version_ids): + if i >= len(content_ids): + break + + content_id = content_ids[i] + + # Insert version-content link + insert_query = """ + INSERT INTO VersionsContents ( + version_id, content_id, created_at, source_type + ) VALUES (?, ?, ?, ?) + """ + + params = [ + version_id, + content_id, + datetime.now(), + SourceType.PRIMARY.value + ] + + self.db_service.execute(insert_query, params) + + def _store_vectors(self, vectors: List[Any], content_ids: List[str]) -> None: + """Store vectors for content""" + for i, vector in enumerate(vectors): + if i >= len(content_ids): + break + + content_id = content_ids[i] + vector_id = self.id_generator() + + # Insert vector + insert_query = """ + INSERT INTO Vectors ( + vector_id, content_id, vector_embedding, embedding_type + ) VALUES (?, ?, ?, ?) + """ + + params = [ + vector_id, + content_id, + vector.get("embedding"), + vector.get("embedding_type", "default") + ] + + self.db_service.execute(insert_query, params) + + # Utility methods + def _generate_uuid(self) -> str: + """Generate a UUID string""" + return str(uuid4()) + + def _extract_domain(self, url: str) -> str: + """Extract domain from URL""" + import re + match = re.search(r'https?://([^/]+)', url) + return match.group(1) if match else url + + def _determine_document_type(self, url: str) -> str: + """Determine document type from URL""" + if url.endswith('.pdf'): + return 'pdf' + elif url.endswith('.doc') or url.endswith('.docx'): + return 'word' + else: + return 'html' + + def _generate_hash(self, content: str) -> str: + """Generate a hash for content""" + import hashlib + return hashlib.sha256(content.encode()).hexdigest() \ No newline at end of file diff --git a/custom_nodes/red_ribbon/socialtoolkit/architecture/high_level_architecture.py b/custom_nodes/red_ribbon/socialtoolkit/architecture/high_level_architecture.py new file mode 100644 index 00000000..05e03efa --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/architecture/high_level_architecture.py @@ -0,0 +1,122 @@ +from pydantic import BaseModel +from typing import Dict, List, Any, Optional, Type +import logging + +logger = logging.getLogger(__name__) + +from configs import Configs + + +class SocialtoolkitConfigs(BaseModel): + """Configuration for High Level Architecture workflow""" + approved_document_sources: List[str] + llm_api_config: Dict[str, Any] + document_retrieval_threshold: int = 10 + relevance_threshold: float = 0.7 + output_format: str = "json" + get_documents_from_web: bool = False + + +class Socialtoolkit: + """ + High Level Architecture for document retrieval and data extraction system + based on mermaid chart in README.md + """ + + def __init__(self, resources: Dict[str, Any], configs: Configs): + """ + Initialize with injected dependencies and configuration + + Args: + resources: Dictionary of resources including services + configs: Configuration for High Level Architecture + """ + self.resources = resources + self.configs: SocialtoolkitConfigs = configs.socialtoolkit + self.llm_api = self.llm_service(resources, configs) + + # Extract needed services from resources + self.document_retrieval = resources.get("document_retrieval_service") + self.document_storage = resources.get("document_storage_service") + self.llm_service = resources.get("llm_service") + self.top10_retrieval = resources.get("top10_retrieval_service") + self.relevance_assessment = resources.get("relevance_assessment_service") + self.prompt_decision_tree = resources.get("prompt_decision_tree_service") + self.variable_codebook = resources.get("variable_codebook_service") + + logger.info("Socialtoolkit initialized with services") + + + def execute(self, input_data_point: str) -> dict[str, str] | list[dict[str, str]]: + """ + Execute the control flow based on the mermaid chart + + Args: + input_data_point: The question or information request. This can be a single request. + + Returns: + Dictionary containing the output data point. + If the request was interpreted as having more than one response, a list of dictionaries is returned. + """ + logger.info(f"Starting high level control flow with input: {input_data_point}") + + if self.configs.approved_document_sources: + # Step 1: Get domain URLs from pre-approved sources + domain_urls: list[str] = self.document_retrieval.execute(domain_urls) + + # Step 2: Retrieve documents from websites + documents, metadata, vectors = self.document_retrieval.execute(domain_urls) + documents: list[tuple[str, ...]] + metadata: list[dict[str, Any]] + vectors: list[dict[str, list[float]]] + + # Step 3: Store documents in document storage + storage_successful: bool = self.document_storage.execute(documents, metadata, vectors) + if storage_successful: + logger.info("Documents stored successfully") + else: + logger.warning("Failed to store documents") + + # Step 4: Retrieve documents and document vectors + stored_docs, stored_vectors = self.document_retrieval.execute( + input_data_point, + self.llm_service.execute("retrieve_documents") + ) + stored_docs: list[tuple[str, ...]] + stored_vectors: list[dict[str, list[float]]] + + # Step 5: Perform top-10 document retrieval + potentially_relevant_docs = self.top10_retrieval.execute( + input_data_point, + stored_docs, + stored_vectors + ) + potentially_relevant_docs: list[tuple[str, ...]] + + # Step 6: Get variable definition from codebook + prompt_sequence = self.variable_codebook.execute(self.llm_service, input_data_point) + + # Step 7: Perform relevance assessment + relevant_documents = self.relevance_assessment.execute( + potentially_relevant_docs, + prompt_sequence, + self.llm_service.execute("relevance_assessment") + ) + + # Step 8: Execute prompt decision tree + output_data_point = self.prompt_decision_tree.execute( + relevant_documents, + prompt_sequence, + self.llm_service.execute("prompt_decision_tree") + ) + + if output_data_point is None: + logger.warning("Failed to execute prompt decision tree") + else: + logger.info(f"Completed high level control flow with output: {output_data_point}") + + return {"output_data_point": output_data_point} + + def _get_domain_urls(self) -> List[str]: + """Extract domain URLs from pre-approved document sources""" + return self.configs.approved_document_sources \ No newline at end of file diff --git a/custom_nodes/red_ribbon/socialtoolkit/architecture/llm_service.py b/custom_nodes/red_ribbon/socialtoolkit/architecture/llm_service.py new file mode 100644 index 00000000..bc87c4a3 --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/architecture/llm_service.py @@ -0,0 +1,27 @@ +from logging import Logger +from typing import Any + +from configs import Configs + +class LLMService: + + def __init__(self, resources: dict[str, Any], configs: Configs): + self.resources = resources + self.configs = configs + self.logger: Logger = resources.get("logger") + + self.llm_model = resources.get("llm_model") + self.llm_tokenizer = resources.get("llm_tokenizer") + self.llm_vectorizer = resources.get("llm_vectorizer") + self.llm_vector_storage = resources.get("llm_vector_storage") + + self.logger.info("LLMService initialized with services") + + def execute(self, command_context: str, *args, **kwargs): + """ + + + """ + pass + + diff --git a/custom_nodes/red_ribbon/socialtoolkit/architecture/prompt_decision_tree.py b/custom_nodes/red_ribbon/socialtoolkit/architecture/prompt_decision_tree.py new file mode 100644 index 00000000..b1aad84e --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/architecture/prompt_decision_tree.py @@ -0,0 +1,366 @@ +from pydantic import BaseModel +from typing import Dict, List, Any, Optional, Union +import logging +from enum import Enum + +logger = logging.getLogger(__name__) + +class PromptDecisionTreeConfigs(BaseModel): + """Configuration for Prompt Decision Tree workflow""" + max_tokens_per_prompt: int = 2000 + max_pages_to_concatenate: int = 10 + max_iterations: int = 5 + confidence_threshold: float = 0.7 + enable_human_review: bool = True # Whether to enable human review for low confidence or errors + context_window_size: int = 8000 # Maximum context window size for LLM + +class PromptDecisionTreeNodeType(str, Enum): + """Types of nodes in the prompt decision tree""" + QUESTION = "question" + DECISION = "decision" + FINAL = "final" + +class PromptDecisionTreeEdge(BaseModel): + """Edge in the prompt decision tree""" + condition: str + next_node_id: str + +class PromptDecisionTreeNode(BaseModel): + """Node in the prompt decision tree""" + id: str + type: PromptDecisionTreeNodeType + prompt: str + edges: Optional[List[PromptDecisionTreeEdge]] = None + is_final: bool = False + +class PromptDecisionTree: + """ + Prompt Decision Tree system based on mermaid flowchart in README.md + Executes a decision tree of prompts to extract information from documents + """ + + def __init__(self, resources: Dict[str, Any], configs: PromptDecisionTreeConfigs): + """ + Initialize with injected dependencies and configuration + + Args: + resources: Dictionary of resources including services + configs: Configuration for Prompt Decision Tree + """ + self.resources = resources + self.configs = configs + + # Extract needed services from resources + self.variable_codebook = resources.get("variable_codebook_service") + self.human_review_service = resources.get("human_review_service") + + logger.info("PromptDecisionTree initialized with services") + + def control_flow(self, relevant_pages: List[Any], + prompt_sequence: List[str], + llm_api: Any) -> Dict[str, Any]: + """ + Execute the prompt decision tree flow based on the mermaid flowchart + + Args: + relevant_pages: List of relevant document pages + prompt_sequence: List of prompts in the decision tree + llm_api: LLM API instance + + Returns: + Dictionary containing the output data point + """ + logger.info(f"Starting prompt decision tree with {len(relevant_pages)} pages") + + # Step 1: Concatenate pages + concatenated_pages = self._concatenate_pages(relevant_pages) + + # Step 2: Get desired data point codebook entry & prompt sequence + # (Already provided as input parameter) + + # Step 3: Execute prompt decision tree + result = self._execute_decision_tree( + concatenated_pages, prompt_sequence, llm_api + ) + + # Step 4: Handle errors and unforeseen edgecases if needed + if result.get("error") and self.configs.enable_human_review: + result = self._request_human_review(result, concatenated_pages) + + logger.info("Completed prompt decision tree execution") + return result + + def execute(self, relevant_pages: List[Any], prompt_sequence: List[str], + llm_api: Any) -> Any: + """ + Public method to execute prompt decision tree + + Args: + relevant_pages: List of relevant document pages + prompt_sequence: List of prompts in the decision tree + llm_api: LLM API instance + + Returns: + Output data point + """ + result = self.control_flow(relevant_pages, prompt_sequence, llm_api) + return result.get("output_data_point", "") + + def _concatenate_pages(self, pages: List[Any]) -> str: + """ + Concatenate pages into a single document + + Args: + pages: List of pages to concatenate + + Returns: + Concatenated document text + """ + # Limit number of pages to avoid context window issues + pages_to_use = pages[:self.configs.max_pages_to_concatenate] + + concatenated_text = "" + + for i, page in enumerate(pages_to_use): + content = page.get("content", "") + title = page.get("title", f"Document {i+1}") + url = page.get("url", "") + + page_text = f""" +--- DOCUMENT {i+1}: {title} --- +Source: {url} + +{content} + +""" + concatenated_text += page_text + + return concatenated_text + + def _execute_decision_tree(self, document_text: str, + prompt_sequence: List[str], + llm_api: Any) -> Dict[str, Any]: + """ + Execute the prompt decision tree + + Args: + document_text: Concatenated document text + prompt_sequence: List of prompts in the decision tree + llm_api: LLM API instance + + Returns: + Dictionary containing the execution result + """ + # Create a simplified decision tree from the prompt sequence + decision_tree = self._create_decision_tree(prompt_sequence) + + try: + # Start with the first node + current_node = decision_tree[0] + iteration = 0 + responses = [] + + # Follow the decision tree until a final node is reached or max iterations is exceeded + while not current_node.is_final and iteration < self.configs.max_iterations: + # Generate prompt for the current node + prompt = self._generate_node_prompt(current_node, document_text) + + # Get response from LLM + llm_response = llm_api.generate(prompt, max_tokens=self.configs.max_tokens_per_prompt) + responses.append({ + "node_id": current_node.id, + "prompt": prompt, + "response": llm_response + }) + + # Determine next node based on response + if current_node.edges: + next_node_id = self._determine_next_node(llm_response, current_node.edges) + current_node = next( + (node for node in decision_tree if node.id == next_node_id), + decision_tree[-1] # Default to the last node if not found + ) + else: + # No edges, move to the next node in sequence + node_index = decision_tree.index(current_node) + if node_index + 1 < len(decision_tree): + current_node = decision_tree[node_index + 1] + else: + # End of sequence, mark as final + current_node.is_final = True + + iteration += 1 + + # Process the final response + final_response = responses[-1]["response"] if responses else "" + output_data_point = self._extract_output_data_point(final_response) + + return { + "success": True, + "output_data_point": output_data_point, + "responses": responses, + "iterations": iteration + } + + except Exception as e: + logger.error(f"Error executing decision tree: {e}") + return { + "success": False, + "error": str(e), + "output_data_point": "" + } + + def _create_decision_tree(self, prompt_sequence: List[str]) -> List[PromptDecisionTreeNode]: + """ + Create a decision tree from a prompt sequence + + This is a simplified implementation that creates a linear sequence of nodes. + In a real system, this would create a proper tree structure with branches. + + Args: + prompt_sequence: List of prompts + + Returns: + List of nodes in the decision tree + """ + nodes = [] + + for i, prompt in enumerate(prompt_sequence): + # Create a node for each prompt + node = PromptDecisionTreeNode( + id=f"node_{i}", + type=PromptDecisionTreeNodeType.QUESTION, + prompt=prompt, + is_final=(i == len(prompt_sequence) - 1) # Last node is final + ) + + # Add edges if not the last node + if i < len(prompt_sequence) - 1: + node.edges = [ + PromptDecisionTreeEdge( + condition="default", + next_node_id=f"node_{i+1}" + ) + ] + + nodes.append(node) + + return nodes + + def _generate_node_prompt(self, node: PromptDecisionTreeNode, document_text: str) -> str: + """ + Generate a prompt for a node in the decision tree + + Args: + node: Current node in the decision tree + document_text: Document text + + Returns: + Prompt for the node + """ + # Truncate document text if too long + max_doc_length = self.configs.context_window_size - 500 # Reserve space for instructions + if len(document_text) > max_doc_length: + document_text = document_text[:max_doc_length] + "..." + + prompt = f""" +You are an expert tax researcher assisting with data extraction from official documents. +Please carefully analyze the following documents to answer this specific question: + +QUESTION: {node.prompt} + +DOCUMENTS: +{document_text} + +Based solely on the information provided in these documents, please answer the question above. +If the answer is explicitly stated in the documents, provide the exact information along with its source. +If the answer requires interpretation, explain your reasoning clearly. +If the information is not available in the documents, respond with "Information not available in the provided documents." + +Your answer should be concise, factual, and directly address the question. +""" + return prompt + + def _determine_next_node(self, response: str, edges: List[PromptDecisionTreeEdge]) -> str: + """ + Determine the next node based on the response + + This is a simplified implementation that just follows the default edge. + In a real system, this would analyze the response to determine the path. + + Args: + response: LLM response + edges: List of edges from the current node + + Returns: + ID of the next node + """ + # In this simplified version, just follow the first edge + if edges: + return edges[0].next_node_id + return "" + + def _extract_output_data_point(self, response: str) -> str: + """ + Extract the output data point from the final response + + Args: + response: Final LLM response + + Returns: + Extracted output data point + """ + # Look for patterns like "X%" or "X percent" + import re + + # Try to find percentage patterns + percentage_match = re.search(r'(\d+(?:\.\d+)?)\s*%', response) + if percentage_match: + return percentage_match.group(0) + + percentage_word_match = re.search(r'(\d+(?:\.\d+)?)\s+percent', response, re.IGNORECASE) + if percentage_word_match: + value = percentage_word_match.group(1) + return f"{value}%" + + # Look for specific statements about rates + rate_match = re.search(r'rate\s+is\s+(\d+(?:\.\d+)?)', response, re.IGNORECASE) + if rate_match: + value = rate_match.group(1) + return f"{value}%" + + # If no specific patterns are found, return a cleaned up version of the response + # Limit to 100 characters for brevity + cleaned_response = response.strip() + if len(cleaned_response) > 100: + cleaned_response = cleaned_response[:97] + "..." + + return cleaned_response + + def _request_human_review(self, result: Dict[str, Any], document_text: str) -> Dict[str, Any]: + """ + Request human review for errors or low confidence results + + Args: + result: Result from decision tree execution + document_text: Document text + + Returns: + Updated result after human review + """ + if self.human_review_service: + review_request = { + "error": result.get("error"), + "document_text": document_text, + "responses": result.get("responses", []) + } + + human_review_result = self.human_review_service.review(review_request) + + if human_review_result.get("success"): + result["output_data_point"] = human_review_result.get("output_data_point", "") + result["human_reviewed"] = True + result["success"] = True + result.pop("error", None) + + return result \ No newline at end of file diff --git a/custom_nodes/red_ribbon/socialtoolkit/architecture/relevance_assessment.py b/custom_nodes/red_ribbon/socialtoolkit/architecture/relevance_assessment.py new file mode 100644 index 00000000..f1e3a3b5 --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/architecture/relevance_assessment.py @@ -0,0 +1,452 @@ +from pydantic import BaseModel +from typing import Dict, List, Any, Optional +import logging + +logger = logging.getLogger(__name__) + +class RelevanceAssessmentConfigs(BaseModel): + """Configuration for Relevance Assessment workflow""" + criteria_threshold: float = 0.7 # Minimum relevance score threshold + max_retries: int = 3 # Maximum number of retry attempts for LLM API calls + max_citation_length: int = 500 # Maximum length of text citations + use_hallucination_filter: bool = True # Whether to filter for hallucinations + +class RelevanceAssessment: + """ + Relevance Assessment system based on mermaid flowchart in README.md + Evaluates document relevance using LLM assessments + """ + + def __init__(self, resources: Dict[str, Any], configs: RelevanceAssessmentConfigs): + """ + Initialize with injected dependencies and configuration + + Args: + resources: Dictionary of resources including services + configs: Configuration for Relevance Assessment + """ + self.resources = resources + self.configs = configs + + # Extract needed services from resources + self.variable_codebook = resources.get("variable_codebook_service") + self.top10_retrieval = resources.get("top10_retrieval_service") + self.cited_page_extractor = resources.get("cited_page_extractor_service") + self.prompt_decision_tree = resources.get("prompt_decision_tree_service") + + logger.info("RelevanceAssessment initialized with services") + + def control_flow(self, potentially_relevant_docs: List[Any], + variable_definition: Dict[str, Any], + llm_api: Any) -> Dict[str, Any]: + """ + Execute the relevance assessment flow based on the mermaid flowchart + + Args: + potentially_relevant_docs: List of potentially relevant documents + variable_definition: Variable definition and description + llm_api: LLM API instance + + Returns: + Dictionary containing relevant documents and page numbers + """ + logger.info(f"Starting relevance assessment for {len(potentially_relevant_docs)} documents") + + # Step 1: Assess document relevance + assessment_results = self._assess_document_relevance( + potentially_relevant_docs, + variable_definition, + llm_api + ) + + # Step 2: Filter for hallucinations if configured + if self.configs.use_hallucination_filter: + assessment_results = self._filter_hallucinations(assessment_results, llm_api) + + # Step 3: Score relevance + relevance_scores = self._score_relevance(assessment_results, potentially_relevant_docs) + + # Step 4: Apply threshold to separate relevant from irrelevant + relevant_pages, discarded_pages = self._apply_threshold(relevance_scores) + + # Step 5: Extract page numbers + page_numbers = self._extract_page_numbers(relevant_pages) + + # Step 6: Extract cited pages + relevant_pages_content = self._extract_cited_pages( + potentially_relevant_docs, page_numbers + ) + + logger.info(f"Completed relevance assessment: {len(relevant_pages_content)} relevant pages") + return { + "relevant_pages": relevant_pages_content, + "relevant_doc_ids": [page["doc_id"] for page in relevant_pages], + "page_numbers": page_numbers, + "relevance_scores": relevance_scores + } + + def assess(self, potentially_relevant_docs: List[Any], + prompt_sequence: List[str], llm_api: Any) -> List[Any]: + """ + Public method to assess document relevance + + Args: + potentially_relevant_docs: List of potentially relevant documents + prompt_sequence: List of prompts to use for assessment + llm_api: LLM API instance + + Returns: + List of relevant documents + """ + # Get variable definition from prompt sequence + variable_definition = { + "prompt_sequence": prompt_sequence, + "description": "Tax information for business operations" # Default description if not available + } + + result = self.control_flow(potentially_relevant_docs, variable_definition, llm_api) + return result["relevant_pages"] + + def _assess_document_relevance(self, docs: List[Any], + variable_definition: Dict[str, Any], + llm_api: Any) -> List[Dict[str, Any]]: + """ + Assess document relevance using LLM + + Args: + docs: List of documents to assess + variable_definition: Variable definition and description + llm_api: LLM API instance + + Returns: + List of assessment results + """ + assessment_results = [] + + for doc in docs: + # Create assessment prompt + assessment_prompt = self._create_assessment_prompt(doc, variable_definition) + + # Get LLM assessment + try: + llm_response = llm_api.generate(assessment_prompt, max_tokens=1000) + + # Parse assessment results + assessment = self._parse_assessment(llm_response, doc) + assessment_results.append(assessment) + + except Exception as e: + logger.error(f"Error assessing document {doc.get('id')}: {e}") + # Add failed assessment + assessment_results.append({ + "doc_id": doc.get("id"), + "relevant": False, + "confidence": 0.0, + "citation": "", + "error": str(e) + }) + + return assessment_results + + def _filter_hallucinations(self, assessments: List[Dict[str, Any]], + llm_api: Any) -> List[Dict[str, Any]]: + """ + Filter for hallucinations in LLM assessments + + Args: + assessments: List of assessment results + llm_api: LLM API instance + + Returns: + Filtered list of assessment results + """ + filtered_assessments = [] + + for assessment in assessments: + # Skip already irrelevant assessments + if not assessment.get("relevant", False): + filtered_assessments.append(assessment) + continue + + # Create hallucination check prompt + hallucination_prompt = self._create_hallucination_prompt(assessment) + + try: + # Get LLM hallucination check + hallucination_response = llm_api.generate(hallucination_prompt, max_tokens=500) + + # Parse hallucination check + is_hallucination = self._parse_hallucination_check(hallucination_response) + + if is_hallucination: + # Downgrade relevance for hallucinations + assessment["relevant"] = False + assessment["confidence"] = 0.0 + assessment["hallucination"] = True + + filtered_assessments.append(assessment) + + except Exception as e: + logger.error(f"Error checking hallucination for document {assessment.get('doc_id')}: {e}") + # Keep original assessment in case of error + filtered_assessments.append(assessment) + + return filtered_assessments + + def _score_relevance(self, assessments: List[Dict[str, Any]], + docs: List[Any]) -> List[Dict[str, Any]]: + """ + Score relevance based on LLM assessments + + Args: + assessments: List of assessment results + docs: List of original documents + + Returns: + List of documents with relevance scores + """ + # Create a dict mapping document ID to original document + doc_map = {doc.get("id"): doc for doc in docs} + + relevance_scores = [] + + for assessment in assessments: + doc_id = assessment.get("doc_id") + doc = doc_map.get(doc_id) + + if not doc: + logger.warning(f"Document not found for ID: {doc_id}") + continue + + # Calculate relevance score based on LLM confidence + relevance_score = { + "doc_id": doc_id, + "page_number": assessment.get("page_number", 1), # Default to page 1 if not specified + "score": assessment.get("confidence", 0.0), + "relevant": assessment.get("relevant", False), + "citation": assessment.get("citation", ""), + "content": doc.get("content", "") + } + + relevance_scores.append(relevance_score) + + return relevance_scores + + def _apply_threshold(self, relevance_scores: List[Dict[str, Any]]) -> tuple: + """ + Apply threshold to relevance scores + + Args: + relevance_scores: List of documents with relevance scores + + Returns: + Tuple of (relevant_pages, discarded_pages) + """ + relevant_pages = [] + discarded_pages = [] + + for score in relevance_scores: + if score.get("score", 0.0) >= self.configs.criteria_threshold: + relevant_pages.append(score) + else: + discarded_pages.append(score) + + return relevant_pages, discarded_pages + + def _extract_page_numbers(self, relevant_pages: List[Dict[str, Any]]) -> Dict[str, List[int]]: + """ + Extract page numbers from relevant pages + + Args: + relevant_pages: List of relevant pages + + Returns: + Dictionary mapping document IDs to lists of page numbers + """ + page_numbers = {} + + for page in relevant_pages: + doc_id = page.get("doc_id") + page_number = page.get("page_number", 1) # Default to page 1 if not specified + + if doc_id not in page_numbers: + page_numbers[doc_id] = [] + + page_numbers[doc_id].append(page_number) + + return page_numbers + + def _extract_cited_pages(self, docs: List[Any], + page_numbers: Dict[str, List[int]]) -> List[Dict[str, Any]]: + """ + Extract cited pages from documents + + Args: + docs: List of original documents + page_numbers: Dictionary mapping document IDs to lists of page numbers + + Returns: + List of relevant page contents + """ + # If cited page extractor service is available, use it + if self.cited_page_extractor: + return self.cited_page_extractor.extract(docs, page_numbers) + + # Fallback implementation + cited_pages = [] + + # Create a dict mapping document ID to original document + doc_map = {doc.get("id"): doc for doc in docs} + + for doc_id, page_nums in page_numbers.items(): + doc = doc_map.get(doc_id) + + if not doc: + logger.warning(f"Document not found for ID: {doc_id}") + continue + + # Extract content for each page + for page_num in page_nums: + # In this simplified implementation, we assume the whole document is the content + # In a real system, this would extract specific pages from multi-page documents + cited_pages.append({ + "doc_id": doc_id, + "page_number": page_num, + "content": doc.get("content", ""), + "title": doc.get("title", ""), + "url": doc.get("url", "") + }) + + return cited_pages + + def _create_assessment_prompt(self, doc: Dict[str, Any], + variable_definition: Dict[str, Any]) -> str: + """ + Create assessment prompt for document relevance + + Args: + doc: Document to assess + variable_definition: Variable definition and description + + Returns: + Assessment prompt + """ + # Get document content + content = doc.get("content", "")[:5000] # Limit content length + + # Get variable information + description = variable_definition.get("description", "") + prompt_sequence = variable_definition.get("prompt_sequence", []) + + # Create assessment prompt + prompt = f""" +You are a document relevance assessor. Your task is to determine if the following document is relevant to the given information need. + +Information Need: {description} + +Key Questions: +{chr(10).join([f"- {p}" for p in prompt_sequence])} + +Document Content: +{content} + +Please assess the document's relevance to the information need based on the following criteria: +1. Does the document contain information directly related to the information need? +2. Does the document provide sufficient detail to answer at least one of the key questions? +3. Is the document from a credible source? + +Provide your assessment in the following format: +RELEVANT: [Yes/No] +CONFIDENCE: [0.0-1.0] +CITATION: [Most relevant text snippet from the document that supports your assessment] +REASONING: [Brief explanation for your assessment] +""" + return prompt + + def _parse_assessment(self, llm_response: str, doc: Dict[str, Any]) -> Dict[str, Any]: + """ + Parse LLM assessment response + + Args: + llm_response: LLM response text + doc: Original document + + Returns: + Parsed assessment + """ + assessment = { + "doc_id": doc.get("id"), + "relevant": False, + "confidence": 0.0, + "citation": "", + "reasoning": "" + } + + try: + # Parse relevant + if "RELEVANT: Yes" in llm_response: + assessment["relevant"] = True + + # Parse confidence + confidence_match = re.search(r"CONFIDENCE: (0\.\d+|1\.0)", llm_response) + if confidence_match: + assessment["confidence"] = float(confidence_match.group(1)) + + # Parse citation + citation_match = re.search(r"CITATION: (.*?)(?=REASONING:|$)", llm_response, re.DOTALL) + if citation_match: + citation = citation_match.group(1).strip() + # Truncate if necessary + if len(citation) > self.configs.max_citation_length: + citation = citation[:self.configs.max_citation_length] + "..." + assessment["citation"] = citation + + # Parse reasoning + reasoning_match = re.search(r"REASONING: (.*?)$", llm_response, re.DOTALL) + if reasoning_match: + assessment["reasoning"] = reasoning_match.group(1).strip() + + except Exception as e: + logger.error(f"Error parsing assessment: {e}") + + return assessment + + def _create_hallucination_prompt(self, assessment: Dict[str, Any]) -> str: + """ + Create prompt to check for hallucinations + + Args: + assessment: Document assessment + + Returns: + Hallucination check prompt + """ + citation = assessment.get("citation", "") + + prompt = f""" +You are a fact-checking assistant. Your task is to analyze the following excerpt and determine if it directly addresses tax rates, specific tax information, or tax regulations. + +Text excerpt: +{citation} + +Please analyze this text and determine if it contains SPECIFIC information about tax rates, tax percentages, or tax regulations. +Answer with "HALLUCINATION: Yes" if the text does NOT contain specific tax information. +Answer with "HALLUCINATION: No" if the text DOES contain specific tax information. + +Provide a brief explanation for your decision. +""" + return prompt + + def _parse_hallucination_check(self, hallucination_response: str) -> bool: + """ + Parse hallucination check response + + Args: + hallucination_response: LLM response text + + Returns: + True if hallucination detected, False otherwise + """ + return "HALLUCINATION: Yes" in hallucination_response + +import re # Added for regex pattern matching in parsing \ No newline at end of file diff --git a/custom_nodes/red_ribbon/socialtoolkit/architecture/top10_document_retrieval.py b/custom_nodes/red_ribbon/socialtoolkit/architecture/top10_document_retrieval.py new file mode 100644 index 00000000..f8b008ca --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/architecture/top10_document_retrieval.py @@ -0,0 +1,295 @@ +from pydantic import BaseModel +from typing import Dict, List, Any, Optional, Tuple +import logging +import numpy as np + +logger = logging.getLogger(__name__) + +class Top10DocumentRetrievalConfigs(BaseModel): + """Configuration for Top-10 Document Retrieval workflow""" + retrieval_count: int = 10 # Number of documents to retrieve + similarity_threshold: float = 0.6 # Minimum similarity score + ranking_method: str = "cosine_similarity" # Options: cosine_similarity, dot_product, euclidean + use_filter: bool = False # Whether to filter results + filter_criteria: Dict[str, Any] = {} + use_reranking: bool = False # Whether to use reranking + +class Top10DocumentRetrieval: + """ + Top-10 Document Retrieval system based on mermaid chart in README.md + Performs vector search to find the most relevant documents + """ + + def __init__(self, resources: Dict[str, Any], configs: Top10DocumentRetrievalConfigs): + """ + Initialize with injected dependencies and configuration + + Args: + resources: Dictionary of resources including search services + configs: Configuration for Top-10 Document Retrieval + """ + self.resources = resources + self.configs = configs + + # Extract needed services from resources + self.encoder_service = resources.get("encoder_service") + self.similarity_search_service = resources.get("similarity_search_service") + self.document_storage = resources.get("document_storage_service") + + logger.info("Top10DocumentRetrieval initialized with services") + + def execute(self, + input_data_point: str, + documents: List[Any] = None, + document_vectors: List[Any] = None + ) -> dict[str, Any]: + """ + Execute the document retrieval flow based on the mermaid chart + + Args: + input_data_point: The query or information request + documents: Optional list of documents to search + document_vectors: Optional list of document vectors to search + + Returns: + Dictionary of documents containing potentially relevant documents, along with potentially relevant metadata. + """ + logger.info(f"Starting top-10 document retrieval for: {input_data_point}") + + # Step 1: Encode the query + encoded_query = self._encode_query(input_data_point) + + # Step 2: Get vector embeddings and document IDs from storage if not provided + if documents is None or document_vectors is None: + documents, document_vectors = self._get_documents_and_vectors() + + # Step 3: Perform similarity search + similarity_scores, doc_ids = self._similarity_search( + encoded_query, + document_vectors, + [doc.get("id") for doc in documents] + ) + + # Step 4: Rank and sort results + ranked_results = self._rank_and_sort_results(similarity_scores, doc_ids) + + # Step 5: Filter to top-N results + top_doc_ids = self._filter_to_top_n(ranked_results) + + # Step 6: Retrieve potentially relevant documents + potentially_relevant_docs = self._retrieve_relevant_documents(documents, top_doc_ids) + + logger.info(f"Retrieved {len(potentially_relevant_docs)} potentially relevant documents") + return { + "relevant_documents": potentially_relevant_docs, + "scores": {doc_id: score for doc_id, score in ranked_results}, + "top_doc_ids": top_doc_ids + } + + def retrieve_top_documents(self, input_data_point: str, documents: List[Any], document_vectors: List[Any]) -> List[Any]: + """ + Public method to retrieve top documents for an input query + + Args: + input_data_point: The query to search for + documents: Documents to search + document_vectors: Vectors for the documents + + Returns: + List of potentially relevant documents + """ + result = self.control_flow(input_data_point, documents, document_vectors) + return result["relevant_documents"] + + def _encode_query(self, input_data_point: str) -> Any: + """ + Encode the input query into a vector representation + + Args: + input_data_point: The query to encode + + Returns: + Vector representation of the query + """ + logger.debug(f"Encoding query: {input_data_point}") + return self.encoder_service.encode(input_data_point) + + def _get_documents_and_vectors(self) -> Tuple[List[Any], List[Any]]: + """ + Get all documents and their vectors from storage + + Returns: + Tuple of (documents, document_vectors) + """ + logger.debug("Getting documents and vectors from storage") + return self.document_storage.get_documents_and_vectors() + + def _similarity_search(self, encoded_query: Any, document_vectors: List[Any], + doc_ids: List[str]) -> Tuple[List[float], List[str]]: + """ + Perform similarity search between the query and document vectors + + Args: + encoded_query: Vector representation of the query + document_vectors: List of document vector embeddings + doc_ids: List of document IDs corresponding to the vectors + + Returns: + Tuple of (similarity_scores, document_ids) + """ + logger.debug("Performing similarity search") + + # In a real implementation, this would use an efficient vector search + similarity_scores = [] + + for vector in document_vectors: + if self.configs.ranking_method == "cosine_similarity": + score = self._cosine_similarity(encoded_query, vector.get("embedding")) + elif self.configs.ranking_method == "dot_product": + score = self._dot_product(encoded_query, vector.get("embedding")) + elif self.configs.ranking_method == "euclidean": + score = self._euclidean_distance(encoded_query, vector.get("embedding")) + # Convert distance to similarity score (higher is more similar) + score = 1.0 / (1.0 + score) + else: + score = 0.0 + + similarity_scores.append(score) + + # If the similarity search service is available, use it instead + if self.similarity_search_service: + return self.similarity_search_service.search( + encoded_query, document_vectors, doc_ids + ) + + return similarity_scores, doc_ids + + def _rank_and_sort_results(self, similarity_scores: List[float], + doc_ids: List[str]) -> List[Tuple[str, float]]: + """ + Rank and sort results by similarity score + + Args: + similarity_scores: List of similarity scores + doc_ids: List of document IDs + + Returns: + List of (document_id, score) tuples sorted by score + """ + logger.debug("Ranking and sorting results") + + # Create a list of (document_id, score) tuples + result_tuples = list(zip(doc_ids, similarity_scores)) + + # Sort by score in descending order + sorted_results = sorted(result_tuples, key=lambda x: x[1], reverse=True) + + return sorted_results + + def _filter_to_top_n(self, ranked_results: List[Tuple[str, float]]) -> List[str]: + """ + Filter to top N results + + Args: + ranked_results: List of (document_id, score) tuples + + Returns: + List of top N document IDs + """ + logger.debug(f"Filtering to top {self.configs.retrieval_count} results") + + # Apply threshold filter if configured + filtered_results = [] + + if self.configs.use_filter: + for doc_id, score in ranked_results: + if score >= self.configs.similarity_threshold: + filtered_results.append(doc_id) + else: + filtered_results = [doc_id for doc_id, _ in ranked_results] + + # Return top N results + return filtered_results[:self.configs.retrieval_count] + + def _retrieve_relevant_documents(self, documents: List[Any], top_doc_ids: List[str]) -> List[Any]: + """ + Retrieve potentially relevant documents + + Args: + documents: List of all documents + top_doc_ids: List of top document IDs + + Returns: + List of potentially relevant documents + """ + logger.debug("Retrieving potentially relevant documents") + + # Create a map of document ID to document for faster lookup + doc_map = {doc.get("id"): doc for doc in documents} + + # Retrieve documents by ID + relevant_docs = [] + + for doc_id in top_doc_ids: + if doc_id in doc_map: + relevant_docs.append(doc_map[doc_id]) + + return relevant_docs + + def _cosine_similarity(self, vec1: List[float], vec2: List[float]) -> float: + """Calculate cosine similarity between two vectors""" + if not vec1 or not vec2: + return 0.0 + + try: + # Convert to numpy arrays for efficient calculation + vec1_np = np.array(vec1) + vec2_np = np.array(vec2) + + # Calculate dot product + dot = np.dot(vec1_np, vec2_np) + + # Calculate norms + norm1 = np.linalg.norm(vec1_np) + norm2 = np.linalg.norm(vec2_np) + + # Calculate cosine similarity + similarity = dot / (norm1 * norm2) + return float(similarity) + except Exception as e: + logger.error(f"Error calculating cosine similarity: {e}") + return 0.0 + + def _dot_product(self, vec1: List[float], vec2: List[float]) -> float: + """Calculate dot product between two vectors""" + if not vec1 or not vec2: + return 0.0 + + try: + # Convert to numpy arrays for efficient calculation + vec1_np = np.array(vec1) + vec2_np = np.array(vec2) + + # Calculate dot product + dot = np.dot(vec1_np, vec2_np) + return float(dot) + except Exception as e: + logger.error(f"Error calculating dot product: {e}") + return 0.0 + + def _euclidean_distance(self, vec1: List[float], vec2: List[float]) -> float: + """Calculate Euclidean distance between two vectors""" + if not vec1 or not vec2: + return float('inf') + + try: + # Convert to numpy arrays for efficient calculation + vec1_np = np.array(vec1) + vec2_np = np.array(vec2) + + # Calculate Euclidean distance + distance = np.linalg.norm(vec1_np - vec2_np) + return float(distance) + except Exception as e: + logger.error(f"Error calculating Euclidean distance: {e}") + return float('inf') \ No newline at end of file diff --git a/custom_nodes/red_ribbon/socialtoolkit/architecture/variable_codebook.py b/custom_nodes/red_ribbon/socialtoolkit/architecture/variable_codebook.py new file mode 100644 index 00000000..d508c2b2 --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/architecture/variable_codebook.py @@ -0,0 +1,384 @@ +from pydantic import BaseModel, Field +from typing import Dict, List, Any, Optional, Union +import logging +from enum import Enum + +logger = logging.getLogger(__name__) + +class BusinessOwnerAssumptions(BaseModel): + """Assumptions about the business owner""" + has_annual_gross_income: str = "$70,000" + +class BusinessAssumptions(BaseModel): + """Assumptions about the business""" + year_of_operation: str = "second year" + qualifies_for_incentives: bool = False + gross_annual_revenue: str = "$1,000,000" + employees: int = 15 + business_type: str = "general commercial activities (NAICS: 4523)" + +class TaxesAssumptions(BaseModel): + """Assumptions about taxes""" + taxes_paid_period: str = "second year of operation" + +class OtherAssumptions(BaseModel): + """Other assumptions""" + other_assumptions: List[str] = Field(default_factory=list) + +class Assumptions(BaseModel): + """Collection of all assumptions""" + business_owner: Optional[BusinessOwnerAssumptions] = None + business: Optional[BusinessAssumptions] = None + taxes: Optional[TaxesAssumptions] = None + other: Optional[OtherAssumptions] = None + +class PromptDecisionTreeNode(BaseModel): + """Node in the prompt decision tree""" + prompt: str + depends_on: Optional[List[str]] = None + next_prompts: Optional[Dict[str, str]] = None + +class Variable(BaseModel): + """Variable definition in the codebook""" + label: str + item_name: str + description: str + units: str + assumptions: Optional[Assumptions] = None + prompt_decision_tree: Optional[List[PromptDecisionTreeNode]] = None + +class VariableCodebookConfigs(BaseModel): + """Configuration for Variable Codebook""" + variables_path: str = "variables.json" + load_from_file: bool = True + cache_enabled: bool = True + cache_ttl_seconds: int = 3600 + default_assumptions_enabled: bool = True + +class VariableCodebook: + """ + Variable Codebook system based on mermaid class diagram in README.md + Manages variable definitions and their associated assumptions and prompt sequences + """ + + def __init__(self, resources: Dict[str, Any], configs: VariableCodebookConfigs): + """ + Initialize with injected dependencies and configuration + + Args: + resources: Dictionary of resources including storage services + configs: Configuration for Variable Codebook + """ + self.resources = resources + self.configs = configs + + # Extract needed services from resources + self.storage_service = resources.get("storage_service") + self.cache_service = resources.get("cache_service") + + # Initialize variables dictionary + self.variables: Dict[str, Variable] = {} + + # Load variables if configured + if self.configs.load_from_file: + self._load_variables() + + logger.info("VariableCodebook initialized with services") + + def control_flow(self, action: str, **kwargs) -> Dict[str, Any]: + """ + Execute variable codebook operations based on the action + + Args: + action: Operation to perform (get_variable, get_prompt_sequence, etc.) + **kwargs: Operation-specific parameters + + Returns: + Dictionary containing operation results + """ + logger.info(f"Starting variable codebook operation: {action}") + + if action == "get_variable": + return self._get_variable( + variable_name=kwargs.get("variable_name", "") + ) + elif action == "get_prompt_sequence": + return self._get_prompt_sequence( + variable_name=kwargs.get("variable_name", ""), + input_data_point=kwargs.get("input_data_point", "") + ) + elif action == "get_assumptions": + return self._get_assumptions( + variable_name=kwargs.get("variable_name", "") + ) + elif action == "add_variable": + return self._add_variable( + variable=kwargs.get("variable") + ) + elif action == "update_variable": + return self._update_variable( + variable_name=kwargs.get("variable_name", ""), + variable=kwargs.get("variable") + ) + else: + logger.error(f"Unknown action: {action}") + raise ValueError(f"Unknown action: {action}") + + def get_prompt_sequence_for_input(self, input_data_point: str) -> List[str]: + """ + Get prompt sequence for a given input data point + + Args: + input_data_point: The query or information request + + Returns: + List of prompts in the sequence + """ + # Extract variable name from input data point + variable_name = self._extract_variable_from_input(input_data_point) + + # Get prompt sequence for the variable + result = self.control_flow( + "get_prompt_sequence", + variable_name=variable_name, + input_data_point=input_data_point + ) + + return result.get("prompt_sequence", []) + + def _extract_variable_from_input(self, input_data_point: str) -> str: + """ + Extract the variable name from the input data point + + This is a simplified implementation that uses keyword matching. + In a real system, this could use NLP techniques or more sophisticated parsing. + + Args: + input_data_point: The query or information request + + Returns: + Variable name + """ + # Convert to lowercase for case-insensitive matching + input_lower = input_data_point.lower() + + # Define keyword mappings to variable names + keyword_mappings = { + "sales tax": "sales_tax_city", + "tax rate": "sales_tax_city", + "local tax": "sales_tax_city", + "city tax": "sales_tax_city", + "municipal tax": "sales_tax_city", + "property tax": "property_tax", + "income tax": "income_tax" + } + + # Find the first matching keyword + for keyword, variable in keyword_mappings.items(): + if keyword in input_lower: + return variable + + # Default to a generic variable if no match is found + return "generic_tax_information" + + def _get_variable(self, variable_name: str) -> Dict[str, Any]: + """ + Get a variable from the codebook + + Args: + variable_name: Name of the variable + + Returns: + Dictionary containing the variable information + """ + if variable_name in self.variables: + return { + "success": True, + "variable": self.variables[variable_name] + } + else: + logger.warning(f"Variable not found: {variable_name}") + return { + "success": False, + "error": f"Variable not found: {variable_name}" + } + + def _get_prompt_sequence(self, variable_name: str, input_data_point: str) -> Dict[str, Any]: + """ + Get the prompt sequence for a variable + + Args: + variable_name: Name of the variable + input_data_point: The query or information request + + Returns: + Dictionary containing the prompt sequence + """ + # Get the variable + variable_result = self._get_variable(variable_name) + + if not variable_result.get("success", False): + return variable_result + + variable = variable_result.get("variable") + + # Extract the prompt sequence from the variable + if not variable.prompt_decision_tree: + logger.warning(f"No prompt decision tree found for variable: {variable_name}") + return { + "success": False, + "error": f"No prompt decision tree found for variable: {variable_name}" + } + + # Extract prompts from the decision tree + prompts = [node.prompt for node in variable.prompt_decision_tree] + + return { + "success": True, + "prompt_sequence": prompts, + "variable": variable + } + + def _get_assumptions(self, variable_name: str) -> Dict[str, Any]: + """ + Get the assumptions for a variable + + Args: + variable_name: Name of the variable + + Returns: + Dictionary containing the assumptions + """ + # Get the variable + variable_result = self._get_variable(variable_name) + + if not variable_result.get("success", False): + return variable_result + + variable = variable_result.get("variable") + + # Extract the assumptions from the variable + return { + "success": True, + "assumptions": variable.assumptions, + "variable": variable + } + + def _add_variable(self, variable: Variable) -> Dict[str, Any]: + """ + Add a variable to the codebook + + Args: + variable: Variable to add + + Returns: + Dictionary containing the operation result + """ + if variable.item_name in self.variables: + logger.warning(f"Variable already exists: {variable.item_name}") + return { + "success": False, + "error": f"Variable already exists: {variable.item_name}" + } + + # Add the variable + self.variables[variable.item_name] = variable + + # Save to storage if available + if self.storage_service: + self.storage_service.save_variable(variable) + + return { + "success": True, + "variable": variable + } + + def _update_variable(self, variable_name: str, variable: Variable) -> Dict[str, Any]: + """ + Update a variable in the codebook + + Args: + variable_name: Name of the variable to update + variable: Updated variable + + Returns: + Dictionary containing the operation result + """ + if variable_name not in self.variables: + logger.warning(f"Variable not found: {variable_name}") + return { + "success": False, + "error": f"Variable not found: {variable_name}" + } + + # Update the variable + self.variables[variable_name] = variable + + # Save to storage if available + if self.storage_service: + self.storage_service.save_variable(variable) + + return { + "success": True, + "variable": variable + } + + def _load_variables(self) -> None: + """Load variables from storage""" + try: + if self.storage_service: + variables = self.storage_service.load_variables(self.configs.variables_path) + + if variables: + self.variables = {var.item_name: var for var in variables} + logger.info(f"Loaded {len(self.variables)} variables from storage") + else: + logger.warning("No variables found in storage") + self._load_default_variables() + else: + logger.warning("No storage service available, loading default variables") + self._load_default_variables() + except Exception as e: + logger.error(f"Error loading variables: {e}") + self._load_default_variables() + + def _load_default_variables(self) -> None: + """Load default variables""" + if not self.configs.default_assumptions_enabled: + logger.info("Default assumptions disabled, skipping default variable loading") + return + + # Create a sample variable with assumptions and prompt decision tree + sales_tax_variable = Variable( + label="Sales Tax - City", + item_name="sales_tax_city", + description="A tax levied on the sales of all goods and services by the municipal government.", + units="Double (Percent)", + assumptions=Assumptions( + business_owner=BusinessOwnerAssumptions(), + business=BusinessAssumptions(), + taxes=TaxesAssumptions(), + other=OtherAssumptions( + other_assumptions=["Also assume the business has no special tax exemptions."] + ) + ), + prompt_decision_tree=[ + PromptDecisionTreeNode( + prompt="List the name of the tax as given in the document verbatim, as well as its line item." + ), + PromptDecisionTreeNode( + prompt="List the formal definition of the tax verbatim, as well as its line item." + ), + PromptDecisionTreeNode( + prompt="Does this statute apply to all goods or services, or only to specific ones?" + ), + PromptDecisionTreeNode( + prompt="What is the exact percentage rate of the tax?" + ) + ] + ) + + # Add to variables dictionary + self.variables[sales_tax_variable.item_name] = sales_tax_variable + + logger.info("Loaded default variables") \ No newline at end of file diff --git a/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/README.md b/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/README.md new file mode 100644 index 00000000..09793d50 --- /dev/null +++ b/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/README.md @@ -0,0 +1,248 @@ + +# High Level Architecture +```mermaid +flowchart TD + A[URLs to Pre-Approved Document Sources] --> B[Domain URLs] + B --> C[Document Retrieval from Websites] + C --> D[Documents, Document Metadata, & Document Vectors] + D --> E[(Document Storage)] + E --> F[Documents & Document Vectors] + G[Desired Information: Local Sales Tax in Cheyenne, WY] --> H[Input Data Point] + F --> I[Top 10 Document Retrieval] + H --> I + I --> J[Potentially Relevant Documents] + J --> K[Relevance Assessment] + L{Large Language Model: LLM} --> M[LLM API] + M --> K + N[Variable Codebook] --> O[Prompt Sequence] + O --> K + K --> P[Relevant Documents] + P --> Q[Prompt Decision Tree] + M --> Q + Q --> R[Output Data Point] + R --> S[Output Data Point: 6%] +``` + +# Document Retrieval from Websites +```mermaid +flowchart TD + A[Domain URLs] --> B[URL] + B --> C{URL Path Generator} + C -->|Static Webpages| D[Static Webpage Parser] + C -->|Dynamic Webpages| E[Dynamic Webpage Parser] + D --> F[Raw Data] + E --> G[Raw Data] + F --> H[Data Extractor] + G --> H + H --> I[Raw Strings] + I --> J{Document Creator} + J -->|Documents| K[Vector Generator] + J -->|Documents| L[Metadata Generator] + J -->|Documents| N[Document Storage] + K --> M[Document Vectors] + L --> O[Document Metadata] + M --> N + O --> N +``` + +# Document Storage +```mermaid +erDiagram + Sources ||--o{ Documents : contains + Documents ||--o{ Versions : has + Documents ||--o{ Metadatas : has + Documents ||--o{ Contents : has + Versions ||--o{ VersionsContents : has + Contents ||--o{ Vectors : has + + Sources { + string id PK + } + + Documents { + uuid document_id PK + uuid source_id FK + varchar url "Length 2300" + json scraping_config + datetime last_scrape + datetime last_successful_scrape + uuid current_version_id FK "Updated to latest version" + enum status "new, processing, complete, error" + tinyint priority "1-5, with 1 being most important. Default: 5" + varchar document_type "html, pdf, etc." + } + + Versions { + uuid version_id PK + uuid document_id FK + varchar perm_url "Internet Archive, Libgen | Length 2200" + boolean current_version + string version_number + enum status "draft, active, superseded" + text change_summary + datetime effective_date + datetime processed_at + } + + Metadatas { + uuid metadata_id PK + uuid document_id FK + json other_metadata + varchar local_file_path + datetime created_at + datetime updated_at + } + + Contents { + uuid content_id PK + uuid version_id FK + longtext raw_content + longtext processed_content + json structure_data + varchar location_in_doc "Ex: Page numbers in PDF & Docs. Default to NULL" + binary hash "SHA 256 on raw_content, virtual column" + } + + VersionsContents { + uuid version_id FK + uuid content_id FK + datetime created_at + enum source_type "primary, secondary, tertiary" + } + + Vectors { + uuid vector_id PK + uuid content_id FK + embedding vector_embedding + enum embedding_type + } +``` + + +# Top-10 Document Retrieval +```mermaid +flowchart TD + A[Desired Information: Local Sales Tax in Cheyenne, WY] --> B[Input Data Point] + B --> C[Encode Query] + D[(Document Storage)] --> E[Vector Embeddings] + D --> F[Document IDs] + C --> G[Encoded Query] + E --> H[Similarity Search] + F --> H + G --> H + H --> I[Similarity Scores & Document IDs] + I --> J[Rank & Sort Results] + J --> K[Sorted Document IDs] + K --> L[Filter to Top-10 Results] + L --> M[Potentially Relevant Documents IDs] + D --> N[Documents] + N --> O[Pull Relevant Documents] + M --> O + O --> P[Potentially Relevant Documents] + P --> Q[Relevance Assessment] +``` + +# Variable Codebook +```mermaid +classDiagram + class Variable { + +String label: "Sales Tax - City" + +String itemName: "sales_tax_city" + +String description: "A tax levied on the sales of all goods and services by the municipal government." + +String units: "Double (Percent)" + +Map assumptions + +List promptDecisionTree + } + + class Assumptions { + BusinessOwner + Business + Taxes + } + + class BusinessOwnerAssumptions { + +String hasAnnualGrossIncome: "$70,000" + } + + class BusinessAssumptions { + +String yearOfOperation: "second year" + +Boolean qualifiesForIncentives: false + +Number grossAnnualRevenue: "$1,000,000" + +Number employees: 15 + +String businessType: "general commercial activities (NAICS: 4523)" + } + + class TaxesAssumptions { + +String taxesPaidPeriod: "second year of operation" + } + + class OtherAssumptions { + +Strings otherAssumptions: "Also assume..." + } + + class PromptDecisionTree { + +String prompt1: "List the name of the tax as given in the document verbatim, as well as its line item." + +String prompt2: "List the formal definition of the tax verbatim, as well as its line item." + +String prompt3: "Does this statute apply to all goods or services, or only to specific ones?" + +String prompt4: "..." + } + + Variable --> Assumptions + Variable --> PromptDecisionTree + Assumptions --> BusinessOwnerAssumptions + Assumptions --> BusinessAssumptions + Assumptions --> TaxesAssumptions + Assumptions --> OtherAssumptions +``` + +# Relevance Assessment +```mermaid +flowchart TD + A[Top 10 Document Retrieval] --> B[Potentially Relevant Documents] + C[Variable Codebook] --> D[Variable Definition & Description] + E{Large Language Model: LLM} --> F[LLM API] + B --> G[Document Relevance Assessment] + D --> G + G --> H[LLM Hallucination] + F --> H + G --> I[LLM Assessment & Text Citation] + I --> H + H --> J[LLM Assessment] + J --> K[Relevance Scorer] + K --> L[Page Relevance Score] + L --> M{Criteria Threshold Check} + B --> N[Potentially Relevant Documents] + N --> K + M --> O[Page Relevance Score < Criteria Threshold] & P[Page Relevance Score >= Criteria Threshold] + O --> Q[Discarded Documents Pages Pool] + P --> R[Relevant Document Pages Pool] + R --> S[Page Numbers] + A --> T[Potentially Relevant Documents] + T --> U[Cited Page Extractor] + S --> U + U --> V[Relevant Pages] + V --> W[Prompt Decision Tree] +``` + +# Prompt Decision Tree +```mermaid +flowchart TD + A[Relevant Pages] --> B[Concatenate Pages] + B --> C[Concatenated Pages] + D{Large Language Model: LLM} --> E[LLM API] + F[Variable Codebook] --> G[Desired Data Point Codebook Entry & Prompt Sequence] + C --> H[Prompt Decision Tree] + E --> H + G --> H + H --> I[Prompt A: List the name of the tax...] + I --> J[Edge] + J --> K{Prompt E: List the formal definition...} + K --> L[Edge] & M[Edge] + L --> N[Prompt C: Does this statute apply to all goods or services...] + M --> O{Prompt N:...} + N --> P[Final Response] + O --> Q[Final Response] + P --> R[Output Data Point] + Q --> R + S[Errors & Unforeseen Edgecases] --> T[Human Review] +``` diff --git a/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_document_retrieval_from_websites.png b/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_document_retrieval_from_websites.png new file mode 100644 index 0000000000000000000000000000000000000000..44a79bc8ac03d650426e963fe7240b5c668cb106 GIT binary patch literal 31272 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 literal 0 HcmV?d00001 diff --git a/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_document_storage.png b/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_document_storage.png new file mode 100644 index 0000000000000000000000000000000000000000..8b6fd05bbaca3a1337a82f58fc6df7d90d22adc3 GIT binary patch literal 73178 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 literal 0 HcmV?d00001 diff --git a/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_high_level_architecture.png b/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_high_level_architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..ae1dbb552d34634271edb9eb49904056603459c9 GIT binary patch literal 32815 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 GU;Q85J@t+N literal 0 HcmV?d00001 diff --git a/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_prompt_decision_tree.png b/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_prompt_decision_tree.png new file mode 100644 index 0000000000000000000000000000000000000000..6f6cfbed7e5d63ee3439fbc8775af33b72ca75f2 GIT binary patch literal 73099 zcmeGDbz7U?^976+cXxL!1b24{uB8yHP$&{CMT$EVmjW$Npg?hl1_Bf<+Tso=?(Pmx z`uYBzbN)PU;BZ|bBzKtXy=TwtHEY%#tEZ!ehfR(B;>8O*4RvLM7cY?g5swK>WW+n% zDj{2lCnPTeHN_XzBec7S7pM*j+6pgT)Ft6O*q|X^W4WuFdA)dn-}CQ*)bCbm_u|EK zv4*mOk+0>!BZd*_{6Z~WhjZZbb-S+Qw#Igjgu|8=f1IW&p&pV(s@I6RDk>JUf}rLI zV-}eTArTVETLET??fi`#){^JyBlNmlkEyQj**}lp^O{UogIddB*@4rb(`R>g_Xh^t z|9;}#s7M#jc0j6xs0xG|iwY9}Y6=C!-#-N$EfDXZ7NGtApZ|ZZLxJ3dVJVOh)h1x9 z8B@`e^?Zlpe24vvvM5LxOM$QtJt2RJ?%kUVWrbNTiI3*+~lN zV1zTKLL}s2zP?lnlnnoj(dL_18RoQN!9P&=5zimWvlf^O0*iolFz&2fX3RI?eJaUh ziqF`iir&B-?{x932TLe}`ZeXQBKL0yQA8bLP6L`JmeBhA#hvjTt8recsC^A?!<#qlAmrb0BJxMg+6dMn@TU^kTNs5X@U-1Cw%sb!2Aj(HIY zV^bP|ETi(+!8k#vHmq5HntK~AOyuU!CYgG>?AFQ*BEWIdh5bRtONVX>5^c1lSQBJ= zD+a2FN%nNQ^l7h+%MKTNry3rzK7az<%fD{Si2o||Cu+66>kdhU51A*^dm+IdpWG-$w0aAg; zAP!=Okwf;IED%eg4rSBpNni!3{Bzb{8|3vpt5p-c?Tq?$!XMU~=^Lw?aEdoBX|`_y z$3IM4e{w_%mN}Cq-XewsPW?EeCd9}XZ+?keU=A2N1n~L+HN9yRg5I8;5y{ZfX-T&I z=E_%BHU*#T5Uf)zgRPhfOC??)CVpLk>5Ao{?SZ8oODE+sU_KD- z9koYithPRZ#0oDbny*4OgT5KAF&7-~(eL6_DAF=b5pSzZ`V0sg@|xa5y3 zZZ@BDEUAL88qpYu3Ps0&qLKugBJp-v&qv&%7P_=u_9)WA# zW+X%IQ@AoyN>@u6ldD@LOY)g1JbbByK&S<3CQTkln{Q|pzgJdvyJXLAXxWRvg{O0- zO$ef=rgEl!>t;n?M;*ug<@nAV)mMxn4>fI>l7}WEtOoeQQ;~KJ1VJAm0+T9)us4^~ znZ671(i9z)5eqtK&VIj8G(E{Z>+kLCwM_`l$j=l76HIu;h5wQ!05OsY*hyfY zI3W8^y_u8Z)8?uY6m z(0DVX^Zp>C+34dB7~8q*BpKs!N%lu5E)(WsEi8eiZ;0LVWZ`LDs6RH&#DuOEgkgY> z8H3p@tAJST2=Jg7^0;IxNOMZh=)_zR)=N^BeiCbhsi?*u?NO3sc&S-|G6xU_w9EfA z`siCeHDm_`G6{kZ=>m?4b;bZT35O zyVF68pik=Qi2TLqXn~HN(CV4|-v8qO_)l@*#~mZ6-N3}OyW#enLI!w2EjyeMlUIIS zkl%5MEZp}e_HH0FqxT-H03E(j&38lEWxGP^m4MToA@bdTW@w+i^;q*ulpT|_bogs^ ze+s{#I5A{iIg|(pN_JvOQAKCf#|cDAeDS}ry?7*5g!Xfu3MDoq!UHlUnJ##B)j2E8Q`uJWRRydCI z-yk}B`{-g~XyaMWPm2({x3qwB?`#xetlF1MUR_|waiwYdaNJo{vfWOrEmj2}= zQy3;5%VRXex%=*Hyk~sFMo@Y4*RN2Y%#qew$8Ql!f-Pli&MNfZkrRL{!2N~ zKVyijk_xt7*MBeF7SAXgL6v}WgMDpojdFSI*@= zR4JwBwnd0lBknxafg{P_^*)P86U1Qo{?ZCH0f@tik%k4oBlY9=_HHGekN~Zn)Gyk8 zk3)FI4JVD7g7$5WBaaJPo19n2gg#sNBs#qcy~U8lv)yxvX8y`h~ijA4@Yy5JxQkoo*kPTxYMUsfBothhxZCx5~H}Q*$WH_j`DZsg7`AjAgJJb2= zK7Kph^Y!xcG5#Z6s2d8CQY3g`?PFwq3Zt)Smzu(ahQW|F_80gMADZ7Z6GZjHklAbV z4vfbhMLGtl`k4AoqckA<*W#}(^)7NAk3~L;Nw3Zc?mq}0iA4vLkxI0JwEtypG4|SB zN{PwMZ%ZX{h|o%QLu;UhiY;B#mpRpz2ZwjOF8y*qWOh<*(wOnf7{`yn?~kK)f;wJ> zvx!bpZZF-hs)?$po+)EwqkR0Vx!baH%k6eX>w);yWA8tQ{46)-Q#w zWm0w#fOWw5O>od%UPt9EP7V9{_K1+K$n#=f$K&sF zA-lXB&7Av&tCtwu;o)6n3RMb{9+La0vyZ!O!C{Sa2lby-Bhc*{xfQsRv%eH)VVPt1 z7<`M0HLR_BQ+F?P^;~<1@d`DLayZl+L%w+IAg|+IXb#RZuf<}~Q#hw&*MV6yo-C~N zvo*>G@1aS(f&Zs8tmT(zw=KQ4zN^m;F7D+8tXI> z{vh@aJfvPC$NhW(o`f^Hc%ylvSw+?!@q1vLKHncdQ+O^Z=@P`!kxs_Wdid_VhweNzR~x{G)5+C8H}}6y%4*MArBZVI)A5%f-6i+kq2Y}}erO)P{?&Y4J@`6G4rWN}p7{?4t&HgNvu^+Nvk4pCm z-84)+COF0{_`9)=l7S1S5J z)tk{&2|)Dv(Xnd1?w^6Hh;X$LUU3Zx4iB~lG72h4KYO9u`ts zReI|8rW9)*v02XM#`X?X!A0=dGHYY>~o8nOwStJ)H-?lwAJ}v=Eu1Wd8!~9kCA@)$f9ulXfJ>=2rie^|gac!% zH|NT;MR>AfqxF?`=LoZUX8JC-CwJ8OPR(A=@QIsk`d}4t-!Be!RyNKusHviPSZoTZ zAq9mo+2-c*2(QgxVRj6B;4G{UO^Kikm&$KV**sQ4Y{m2*|As|*ILQ&c>9Kg zU&;pg{%8MQk|5W6wWJxk1lsr*s)W=ra))Ktp~CP!(A$4l#wGKRY>}?j`xVD)D%8DN z@aCq;#k#=nP80>J?)&h;RkfgF|ld$6;mme8gtN z=I>3rt3iG)RY5^^K|m77w%?ZZJ=?rbc7aDGoiLz>P(rz=dt(wNKc#N;;L-;ALU&K@ z4F>3d0is}qcl06w+>aDUuy*WuUW~n~S>L=}?Brtq_hcaTPru)!cNLO%4K}D5y~`|b z_*mawf2OddV$%`U_NgtTHYDtmqP1a2dY7f}5%fg@up`9kP5+xW90)MFZp-l|cCsB* zfRuoQiiZ^HhD@?WLhB|`>$%P1tw+medPxwK zTw`rq`WM?~qpMKOk4#nhM}cEzx6X=zxLwYRGwu`YeS9f_V8ua`cQw@;b$5jZQ3iVt zHKOiXYZi#y?`;U4UT+pj^jbgMvx*4f7Ar7!_4ArK+&){C08OmgqkjSnHZR`9HztW4^5LOIY>5r`EPMTba5fTAeGQ`-8zE3D=#X>5ufBd z^(RERA6Q@*BZQXDDVzWPn3sWQjX%O@5l2<-ZcDZPEoCs_*5k&W&6Lo#F zslS@;zM+rLK0|wEy7o3cNfi55DfxY?FaJEw`}^YL;)_#gBR3YZ#wl++Xw-J%Ug9A3soiqHFWz;nrC7K0!BRgICHc0HigTDbV?o_7krJB&3mg!L7(RV+7OQHh=kof^s2lUXw&!+bkgmM1y2th7`@!u<*E z0YYoERYxk_O*g|&QOWh@L-*iff!4=x!UUDE0Ab79PJGQ%y0ZDJde`V|u_wvlmS3i(yHyKKdoL#~N8fS7AIu^jqV zP|P|*G!F<*Oyr6#o*g876rJz!Zg5Ye+7cT&qoJeVC$LGEZ1{nKNR6mat*|V}b(#8= z?SXQ-^1laTU4qb=KJ>2kdaR8B@a`;jl59C_5ez}2%+#-`2#MRG zxroE&>2I+c+3vhwD~qx6&Hor~T*Ffv%-I8wmZ7%R3b3Q(-65fP$oT)Q?P7CgtP$~@ z#U`P*4Gle#J{BGmFW;q-4}Qw~8(v8(N0Qfxx$&2rCleQX6vlu5jPMS!+xAycD=qaY zNncQcfG_`7h-_%ku67=H`i39)k*ftYBG!W1k zQC^kAh7aa1D(W(~J~lz`Sb|9rMOIR|VG)hW@r25H5GHkI27kE6Agf_c3HdK3@8ocE zBWtm|oX?F4wLgb@dISmuUX)S@8Znl3uyx> zsGRr@i6y0^Vg7J)1`yEeqUMC>Ei`{of9ep5I4?rj6=Adiki6Y*|J&kO{mrZw6m1nm z!(6KaeJs%2B%fe|CW)1Bm34RBimyk2gbDoD>Yv@3kAzq2V?#eEVo2Ad;4ECn$Rz7 zF)hCHaB_A=l{qI>!p(XZ^SrfVs_?g=g!|!Jh8&0l5qMd@o9$M_l#lR*bv<83*TvD> zt*5|$qD-|K4!PIB;=cTPcdq0^yXruJcg6Ns^PZkl!sIxZb8(R0$ZAAU$3V@($SlG% zBq>2D9W;~)6iEc$Bdf#V=L5cd8I9_~fIkI@V!YW1`#nzkVShG3?j`g_OML?5>HFET z_};${7 zoF5NT=Y9>3>PmMj$|ospQD$liC#g!GTBwE#17y~Anu(k58|BNh8XIC*lMG!UPgz_CTE86ZiCYsbvTx?kRE0$1}hUAKGctw{~X4O*6d= z{}kb^UdTTU?K729&2Ib3z!Qih4B)k~T?Zh`aVfTsi6DsYob4I)6@!G$bR1g>9~%m< zx64gQfzjNpA?T;3dU>v+3i$JkI-8V$Y06TpORfb=L{L!-)*#j)q*?Ix!XdZyFpkm3 z-7cTHWs>!}A?}e{UzS$;=;h#M`sy$5JC^SIZlod3DW(w-y}jgplyn_;4d+fkq%p#;pWu*^=woff0{gTb(71;t#jD z%DruIST2&PBajx(iQ`2?MB>h;V}y>h3r$ia|vR5qc6}!4X8M9hMa4Q!Ez1&JT3==TA?QbHBk^ zPJcwXzm%GN4&P*06#2p6DvoWXrmlu5|0?f7Msc`Yp?pZ~6IR2OiagGk4g!F8QK7sN ztHI{`MrUBChcDE9N5$?6aYX zSRZsLBW-pF3o7uO@WQI`(B*+IAeLig`sGa+N-P`R`N~ozi;_KGcDB%C>>^8_MG5a@ zOJ4-rWbLH1_E;;Vmle%e6GO&o#j{XRdcy`p{JZn%vaoTmov^~5QYa5uRc%`MaT_|V z#!3*RLj!5UdRqVC(SiaL|BouZO1G1e_BWylZ?q;fg|`ipz9l}9V!zSSI#I{a7~1^x z5VdxEH+L6LE##HCE#7^1(|Y4IXi1Iye3c@4T5(!hlQSCoVgFHtSvXOIF8s=-vv4Z> z6}ALUQCPsGpnB#7r8+F_h$8{V302}y5RN97sx*p^MUAaEGQ>P|_BeBF9A*^29oT#L zYkqSc>I^o;H~L%M1aBV$$rwFi%rLy_HKS#a_)?Pf95}g*q{F6jv$Fy%2+*SPv?%T4 z?!lg(>X}}>k8~pplG9V@lz;J4?WR=bqs+>_Xp7z1^`GEpj(a(qf)lCv{Wc2KXV_8A zp3Ppq*R-{y{e ziQkT6tnAVLkCpeAg9v)VDU*wP*X84}#Z~h|95{I+3c1mRF{(;vg*=d-FB%yG;?-@^ zJvOLVjS{$NHTz^d0>t0jXWMz~yh3UGF>IGPWyAGHT|0~JPA^xS4#6bSM2addV>=_q zCdM=kEYCdSZAB&u=1a(T>m%Qp$%16nKgB5LK#U9*v_F*W>Llm2B}wz($G6HkKfiuz z8becJVcbO#BaqL-iF@5G5mDP;h4ElJ@< z391~r28RYTK#b`nlNo{8y7C*_n&LU75kvgScbTpj%d!D0CwSdzcAoRfW9o$D6moP7 zawNybTWE%>*@C(v(Z@!8AoL)t>Kf2y`{t^e?Rz-(>nOCY>k9I3--)V`I&@1obWV)B z`Ap^vUa{%@I;~^*U7DT$(uE0kBx*>JT(OTLo-BYYf+y1ZXmQtg7mY@}X%K;I5UBjE zd|kj@rec6=pOBdW3uLT$nRX6iLb{9hTa_d4zTv^8RHkN1yg%o5a#j^3CB>N{=V`_H zV(=R|h{jmEq@2&+>N+|}@d29rXhCg3v=YT~q$tBPQ{;q0nMMl9rQ|C@cVbQwPfT?I zCbNjQOllGa5Y(;B$*qRAw`CA5jpw4D{|G@T7q`W3V!To6Fk7}9)_fmyJSBYYb#@e9 zT32c8KuPf|)4184oRpA)7k1U(yuV=wVJBZ4)XlG-bRt=B?gN0V%`D^mEEf$craQ|j zF3P@BzWG+}R{FuaV#U$NO1I5JGSK7nJD2_+xIu--ODv2uzDsdq@)*hZe4o%n9 zM!v2pp{#Rba4P9)ivl3aE4axR^UY)HZp434b7dhr{MNpGgtDW$!Bf5Eq8N_!<0}ir z169PT2Mq>+J}7#Qbt?M1ijnmELtwO~K(Aw1c8NBY3ti2#t8-0v_B|-d_L_Rrn zBz0so=Tc{<>+AgU(^*Hp>PfLv^4{lLp}y?|g@lvPipa9AB?`%Gil9u&*xS8^}!Rt)ouN1?*f~`3GSacC{r2i83X*_m%T%!6M`abyn^Y%8w zk4HvFo>E^U{pWPqfC2C8gB1$2j?f-Hf`0A3E&|*j{gcT^RmRUzbb{eR=(WQ)#|XAB zKr%oN*@|uY3eiKrqW1aBL?hO{{6ReTQaPW>#^O%m>kn*=t#R$Ozs?-x%t1Sefxl5b z4Bsm+W6%v@@KBm|TOy;P#G>6&?#j(S-O9;565ODtqL0Np#Byx>95Yu~E2aO2&mJX< zj{y9~Pj#CNjMmI@^u?63f`0_Pg);{9HQO2OBaFz(L-X>@5CncQiUI(+CB-R*durpMQE}Tz*Zx?M z8x_=j#m4{gfVOiX%&b;+(Gti!?L2FuU%gWFttsBY$H$qMXmO)15^rLWXaiS+0W@;fPz81OrgYCm=hatVBn)x{48^m{f*8$fzyT0m{&-Z!Hk9@&T6zbRoZz937 zl9SYT;ycF!hw`&nI>_OQ)TlpDd=OfhFvt0gx%d(4P+Q*W*R&tJ)%!qwg}o?7cbOu= zx6ehLt8xDxS{~*@%Aj#t{SddW;qFcn=^NOzSd3A(T6KIcGN?^C~urBYSZf zdR=oJ-GN||5$9jnVweJbuY|Q{;-W6X@nDQ>f_vK9Zh!oPP-QBu6~kQ=4GBBnu?D5# zD}qCX=TNs8=bBQvRkRq$1E^6qHZ!M1cw0w%%{EBpZl^VPwE1MS`%5^ZcB+s|xk36AJSVJ=)CJNm{Z~H@Uk81A5-oED*T7deu6;5(ltga0ySm1SS#)@H~fn7sYZ7qqWWLlpL%2O+>{e$5!a2x?;4mE6gl{I2s(DJMVg|W*^Dw z3D=UF26c8Em@cQ{Cn7Y)4i)o$Iy}?w<2o~WF@4j{=;$fxgoYYK7h9{UhcT6fZHD3g zPW{u_9CR7f7u%=yF|m^qw-emOo}xX*o+aDJL7IVYj#2pV;o<51)7Yn;A*E_uDWreg zyeN7iM#tdm`dn;;uyUKDb-RK7HZ9N*2sxXFVi#pyloT^m&^!GF&Y zk5d)OgbDwmS$A6IRgt$cUXr~S5j5Le1dsg1!j^p3Q*Es7fEfU1w7vm;Zgl_U|H_Bb z2=fp>QvXFd`UuV;YxUP~@BEx*(F8~+eY%p=aZ*<@cW0X(ez1)KKUXO)=2e6>rL0m` zreG`tO^}CLwE)?Vj+};dI9nQfm>K7j;}71LtQ3eggJ0~iX%N=`o%IN(p_;)mh$a0& z@~}4o`gsG8g8f}QoI~cLQ^pS(6PJU^HK@5nEppV1ckIb*cKojeUiW%z33k`_@{H91 z+8w?p?YIwa_PP^z915iKU3u79dmN!1C0p##&Zc;0MpdRPQMU-{heE~$apm1`S_Tm9 zF-DuP_=p`DjZ7In5CE63r|60LDHR6^k!!kN=<7IUG1+A9!K11f+6GhUy00XI0xEyR)SX@22?<_EN4{20K;v#Y~h zKZ>bN;j4rt@NU&xP}6>b^Y#r#W)FYM!u|XpkZC!jRWH~h-6BDHcx}gaz1NAy3{aOJ zc@;a(_6IPc4$hI*MEm4XoKS>_^`eC0d7sbU{xRf7f(SBR0&~|B_)23>{c&W~-t$@+ z`Ht}$i#cWfg?*2HXjQ0x?)6je?d0p9P2}&$^;y!7a2X|=Bfk%vr<&1PE|40bx1jr= zhW{vNvhocQXt7f)8o;U2&rqk1@~jc$(^1hW#nPzqFObp?^_`;CA%^DqJ8FjrWw=46BerCE0szXO-pF9x-)C-pAQ^)1id z^ZY;$E@RhM$XN2^&CJk)07t-nOsz5+R`a}62zHQ1q#70{NrNMWAgKYeHsD*9UKFgc z=3(srSrv|eFin0MW7oJQ*@grYXkx1m9hR~OqU9}9w@~Y!7iwJKR`Lfd{QX6rZ*Ice zS`36EBZy2U8lTJ!K!>JW0tzFSVRE|@hT%F`)4GcrnKYDEdH?2cR^L#1D8d=sX{;8$=%IZwhEm8d{<0B zj?d@(Z(!SXlmiUm-xh5V)Z3=<_DoU9%QU&D`S@0MeX<9N-o*YsouC2VgR9s!T*B2iG!cG;|0YZ)zFdKnMHn`wLtePBia0uIcl`vOpal=1LSn)U? z(K`CH`{?py@L%H{;^Vy|IDL8jKKLl;rl4V%1)KliY3WbRgy~@|x0Dn^W;)C63hHjl z4%2#1DPj)q~56f>hq+V%Tk0jC2`A7Ah2kA%!mpfB2; z$=aPEN{$Sfr4k1roj}V7rB!Iw69U`G>nR{P5{8Pugu7fM{e~m8ry09n; zfZEO_X#M00qP$)$eHZr`u)9jRF0dh`nIeabXviwj+G`KY^FG3T?#(O7*SmkdS+aBS zb-O8OjjrT-o!v)OJ~xONbMzKoAD*zBtTYz}ocM}pVkEtlPSR&jX){oN#`L@u`3-*e z;y+Y-ZO|-BIXgRylmMh4oX} z>F?^Zo2NFvAsy77-uvczylQq(YRENV|8k^4!lGKv_k_HJB-)RVpT{n=Hl-e~f}rV` zG)aObrFhUBjHC~^tEK}ct9;Y!ED)6cB5i{2&a}CSF9gB{VFl&Mf2X0DPnviXB!3UI zgGx;`Pm}E2speZnj>iK7whG5Nwsdc1Z?f65%B5an16>{9L&LD1EW?GgW>{80WtM*8 zo{-o-?g~eFnc8bHJr<)WPOp-=@&anI2L?;MynLm!tpJ zRN>6*2SgRzO`v~U%E?*ueJ{=mY9@P(ovc=+@*T^nlm9PNJ|KDw0zi!c2m?dn=lmcA zv9o<#LbrrV-gBm1lichv-a>n*oqC`BvTMDXLg#uDhI*#>FL_g4w(z76tampTr#p3y z+x{cvI-1OaQgcwx25d^NmpA8#E~>x?GXOHtpBQ=izi&c+QB;98(X>#}N+ARvwG9!E z-7(kM$;h?JH9r(*Vd#l??q>y?nd*Ga^(XaqYA%13BS7$h1`@D!GvrTUAw`X+QFZSn z)?NtH6s_;BZ#8S#oL8Z1`Gg#UK}VwDihUY}w3nbriSl1UvB$kIRDdnnnkaw2??tPp z-TO&kh6=e)EHY11feXGx$c7FZmYj$VQjc5~$!>kl)Scq?=%-~~uQSL|5R^%KOp5Ln zH%u}7f?BUOHP>!qz~1}seqXHyFuxr5)i*L!*vCcDS*ReHW1Xerd8kGc#!vd6lZN>b z3e;4XKj>?-_4j*o!fkNufj8eyMqDaf@JW~Yz}`KfpD{sgpENU`V&B^sTz$B<$2@eU znX%2IB&CRGxN`AnJ*e)nb-4J(_&QRsHqra3K^`F1d8*3#F^2MAK?j6T1Hz=4cN0zh z6>BJJ>i^rtEOne9I*rVJPPkQQk-61By^01D7|J`Liw55sUjD;T%~XE$ z?QL3{T%(ZiTOM|&)!c`b0XbVM#k!45QGBA=e3c|+Ke7*dcl!fhhGGT|*H+hT*E6=0 zao9&vdhn4_rq+!0EAale!u*^QO{{|O{-U1YMv068OhOnh3cR}d;L22;eMwasvMZSM z7P+L7ViBJX{52Q3TdH^Z*Azj;yk#BMK7InV*~yWCI&tySpX3SKj}~Q=%=nD=>Aw4D zJDM~=oZ-X2Bf~u-EWZF-zpH30Dr~BOmT%P>hHQoJd>7S#r?<_%s@QGIF`Dy*RIWfB>v{MqA8=Qq${f!E0bLf)1dBBsZlRj)cYEtPH@*YM zguF#Vihddl0*k+Hgry~G`8*A}ua)18g5MR;wW7A5U3f+y8>r9halw+}Wd|jE5{!{fn!`B5(!i}A}rT&7&e)=c3>sS6Sbyb4;jwP#p z0O6x@ge3HzUuX=z1JzBl5&d^V4YAaR-y6RUGR};+9xe@#7zVzDXyCIm0wEs6E$%kN zU2cChar!<9B;|E973>PiLFgQprt$taaOn*wZi*miD+N%ns6Ql>HXmzBnh)+sM_V_@ ze8#t1A6c3+%43b`16}?Xjz>-}1c`Iwj*F!<9Y*0G@Br+R>oQd+&32o`9@ftxr#-DcqJ2QqOr0-h=|Gysqg+Ta1A%mX*1MfsMGRF>I;i^E}oR+?n zF89HjnvTcs*#zOn%m@vt-QjVA`5zL*XAm0R|ND$ngm1Kj3anx+2e4}` zxRW97GpuQcXiru!xQZzLzf)KpYw0e_4ggG*UQ;fytyHWfm2R37tOw!U|2$b zNBd#6h*x(zH#4`R$5Uh>WcdU;Gl<$)sF#VgEeFpYMTJ?OvvOL~1;>;80_u z98GH^<~cU+;NWUsZllh1TigB7OK);cL3{Lzsd6sO73f6nVc(Yzq%q3@5V*J__E&@+ ztJiSyv&d{IvLGR>BJ|fr{NFqbnUc~|KD9rJKmR?iZynX#NtV(Dy2)~l2EEoa)?q-< zmS#arw~~4JoFy}60oISRN^J|r-HPA$iE$xP)q=oTlCiA-#^R2`Xf+asv$|jegBO-EIL-}n&q&HloXzEizs&dSjN<{ zLn=8PExw28CsdSvvz(E(Se7weln4(XdJk$yXg`PMks_)=jO6MW|9{n!{m)M}jLaV* zeA}fFRoCU2?@T;4?l#1p2R<&=7lzCIm`FoHc>=+UoOF)OJu`{?9@GAA|Q*W4fC&lDb3xHm~X4 ziJ%!&*?YJ~X9yuRzag9CLwqY@`jC8&4kpsw*N4Rx?XMy-|+AMFpcaIM`teQO+H>tpuz7x z-4CpF*{OybOBoOG*a*LQNu5b$4OpLfKPq-H67EI~b0}jElpVw5fgTl}=?a?9%9uV6 zMgq*Be6A0}2-Q=V%I@C5`#~l!)m@Zs5%V&p(GknFY%2mR;o7YyS}aHP*`sF-H0L+M zevD7_b*)7eOhD5_a)mBs&JzM7HuhTII<;<5-)&`+t4TT7a0@I55qx|tX|X7vk7C#r zr&pEjh{Qgvc;x$VvXJ?~p39E$sS-r93^N&UyGq%+y6MIa8atFq1#`{w-u^Uy(4j*A z7hJ-9Xa(N7MR%O84)bl`9uurQhg;tBgv0P#5t-ZfEYtAwCc5?F%fMTa_Q(X5X^__? zXwvx4b$cL0+4I30BS{$=|HV(N-iSpTL@+ZV~&6{1g0%+I#qJt z9IBFA_QdRu4u!iE{Qxi4oAHWEY=4HHZ3W-gbbtkPVWx7o+~X=)nSsNiW+fL;H0>nq z`MH_OT)7PSv-l#Qusb{@|8Sll|(*kX7>c#0n(=XqchtBX;iG;9_|6)9DYZRd z2-tgSGVeEL4bYW^6*bKAomw7k^0Q>15WIZdhmGS&k`$d)dT`pd7%(wxp?H7M@Km?W zg@sT4{jZo6J4V)?WON?SSGRqPb#Ij&dUxIC#}n7c=(hJe?Q8dbk(q`{MWS=`!LRB4 zLky2Crkg6T_IRTHnmJq)wU0{s6RidwVFnOZfL5(e`*w`VhbzxkkJ$3gAP znu*_N*+%%znv95HqbPSwNLX%JM0VNWnx|7WJkE9f`3ZC;@8sj%m>TM{mOFCWMJp$o zkw61IJv{+C%)3xOu+Gb~Jz0WA&;4!uU5_a?wmwk1*MrTjdopC62o^`tB)QD&J96`a zv)mo8uY=9|SvvpJxmJ`P51I-chM&9rz5MlA!{yfI&%&Q-Ym!SA<9hIS+Kzop@d2U_$_i9J8Wqa-b?jt$ow z%ki}v&V9b$iD=VUnl_i%W+oUuj+4p`v^0HkvGiG=Hw=Z1n5Gscaqg*o{|WFjIKP?@ zpm5c0t!>aZP{c;Z5}7}hEZ+h%iDg&BrM|C14ktb;TK4mRw#n7pMJ2v+H&NLyJa9Kl z^D5JyF^AadsL-1blK*J^n?<_E2%t!}T=sm{{Fa?tthU#1A*FIXj9$_DHl}dsSW^K*-Dno(Gm=RXYh5vwB zR!_71tcB9?!Q~rjce^Y)1^%V&b1TltISVp@{^6*24ynxuQL9^*M7JAIhEWWAo^a5qTa?eaeutT5?iqw zJi(g+o*f3Ja+0RY63fCJE#cMp+FT0Id6+EX8&FE|0h zB*YFeUsD<9J^i^jm6Q?2Py8>G-o@h(nlg?~HR>9p&`tI}%7G?}RzFLwk zD094Xx)&}Q=ymTGE=zXAP%WTaqc4a=cb1ItE9l1Hg=i`Hfhg)yaqtwKi?Sm#eyfBE z@*xS}c!&{IQVI*|Cue2`2yGt>#(ArkV%2~l8!2P!BuupH-*>?Zk9#|e2K@EVj0_g7SE4Dthe?Mi}HQ(bqJ>SpU9{Z_f z99q3Hqy6p9H-#_kb39PcEO0bHX;k{whV(uBoF6+O`K!19&IguhCTUIT;we@;te##L z9{CJChaX?Fl)pIFDGc$j9un~;m#0wIaA?T^NdY|0HX`ai7l3M-Vvh+RbHt?2>oM0Gq9#IYFmgq9p4D!3hPdy}0O2q{yfr>|L9a<$jRoP$PYIy|V< z{5M!G{P1q@L6wWYQ@e&|qdDC{$77G(&^VuA<;{jj=g}HLmqnkw-rk3;>^qH%ku-1o zCqhRHNyI%Y4^MlW%dN@S-xcZdh;_$!U)FGIKuzVGND9!21!a3k>1tg1=SuJ|KDu6b z)udg&wt^YST*(AH)CK+)D#wN(-wFwzv;Z%eSgcT~Gl>{eT|8Cq$BXzd5`YYdyOY_i z)X^p$6SRC{!5Z6O5#4;S90?$ob-*LnHqXTS+V~Q;)9SA1TWd$@o95;>nCPYK;{?;~ zD4V(MM6=i}kkh%dSp>S19BYQ4NKA@wjO=dFCO$RYLk3}&yr-!g4$#s?zEBs7=&YR7 ztFIG@mN%`x8!t(rm&O+f(*#NBL_G|~uTZ~x<4)t_hBpQkQw#8=^Yu`tQXf~)=9KT# zyrKlr4@vsRy>3-9L{w(MsKS8B(7s|0^$9X)@=a6p8y=ag->T!hUt1rM$rFIY1O>3s z@2y1+jW&=Uezb@a>fj}~xLp2Qd&jpziTjbufyryH4|l+_?||a=n#KbDQ}9z^Ildl+ z{)EheIye|o|Iwme-PuQD)_uBD+1SBneBw+cU-7#2!_dJSGXDGSy-$z}3NaC@4q}o( zXn9DHyMaXGr0KZSYbk!Ci3RO<8#tk$jBaw_BL)P_Mu6hocvA41BDdF?VtLN>1Sl1* zNtCG>3O*g$;M=H3FrN@Ok-XMXkE!V)B9N*{mvZwT^2ZpuXV326{?acW(O$d)wDqlS z=@59inclGft2MlEIy^0*a8kRckPIF!!s6xD=dh0vrD@(OUyZkZ4oYya)9Ti75SzIm z$oO$hO1>mPe&BF?v`d+sb^5ln4P_zES4j5ytxGxBy0W%jeE+D)+--aRLyWzM{Ot_{ z^vpP)$(9>_i$=iA@<5kFTSw4=kZM&p`If(nZ|r?qP2I{!7hhD;KvR)1bmNHa?n|lr zk|=gj0&-$M`WfX}nSTjfuXIz-2f1t=hD~^RfXT0pn8dKXqPLthkE2lO>gtl=MFAH} zlhCF|rOiWl%QoKAAUh{38w(8h>Mz&1zVmR}L0U#4K=cVq!~W1`WbVxEj^Qf`Me4Am zr8MwbB4A*F_srK@Wp(9+-GqH$nywD@DUSQ;!89Rps+i2}#%i1}pDx8qj^l{1#Mww6 z#W%!;IOch>nz9>Pwwni=Ue)~2)t_gKT-=BTm);G+dUSVtQU8r z$ojyf`2Udgl>t?CTh}TgA_xj1-KC`Dp^@(H2I-b=j*`+10@B^x9J;%kLmv9jo!@?* z8}GgM;}1XBd$VG$vF4g8Q0^iCdmq^u-( zA+r0en4box8rzIOq>&B?@t^@$7J}keFT~Y4zK-xs$__}UhDA7%zdH%`iJ&1*YbR#5 zsjih(->SI{N?IdB_f8=fi+lW>Z@#x$J*t=rBjz$Nk1`45K?^kI!{2XA@}3ylIo+5| zC>~ewNsk5Gk+>Gde zN_`!PZ86(3nzWZq^M(DvC;ODfybY`0NS!HMT8yo7i%($<8_xsYEO9$ok)dquyOZ>$ z^l_R}k~XOgw5f`yLa9cau2O%*2B+SxEg|sq7%;wxCa)eE<&g_oEc2{|v~W?+>E7$B z!gh~^-ozJ(I80)>D!ak-l{aXL%x7GNt6P(8aYb7~Yol&PDsBSHXaIeD;3Jl9%9%&p z1)!Oe4SZ`i2Y97ykEE+t`>icT2po1QfOv(vd$cSK!Q?IQ+vf`jx65VNDF%m+85xpE@IJ!Z5`R zNy$ApaO4Ly`ZcJdZMyZEy=a1n)X?iA z-B~zJIm&*#PMG0jWq4@INggtd^lWQ~9T?Q^XL!`%Yp+dErY87#5`qtSN@)^SZAe9Q z)^rr{sEPRKJ=S6MdW&NneeD}v`%@pf>Nh&c4Yhy7>axvyy(mYXQBVqKpqd*SCXbxsJ`XZ72t-kTUvv1-vDBNh1L z&dPV7q;?;5y`&K7*%anGw^NtSCp7AG@8wq;T=RtR@cl0i-ulhOmJqTmB)xhy;7&~> zT4af+2bp1C;bzfT*21(YWT2v@&S};X1f6Iq>}sG(EMMnItOazmQ;N9N`4V8299HL~ z*l*t1HT|*NyqTyNU?`M%^a6s9FA(t5p5D}Ho;$x+G2k>L)o3)VE3WwUCn`0*Ltul~ zVz02t_zD@UY})-kevz8Ou#LR1H_PFt*j1Jsjs|I;T!o91OL9{~#>QSa++E_2*%E)- zEM8q+wgbr(EX+`B`HGvc5)E>Z?UY_^*0^jg`t z#}1ke(VhN~ZMxE|$)pbD)>Vn|AiMqL?^`uEf6!z-*aRbaep&gIgm4LO2h#Ik7 zi9PhKEx(IpUMJGSWZHRzYE9h=gvfB;Z3^aSVqt#^Ux;tgKt@W52w3WGeIo0eoaSBa zx=9Ze!`5R}b-GG$MB8fV<9fuUF@E>&Cu}uXf~dk4(BQd_1Yr zLY7z|&Vzr*$s1S1b>?w(;#)<%U1i+q#0B);)%?4c4{4@xYD*KB4+01oKvECcZ6q_}woJjMt-0SEyAyiZ6J*|^jZ+91>GQQTmsKFj)R$jp~6y93F++f3`8Rb53B z#ob%~=;8h))H?-R!2z)0$KSHlJ~bis(!2KwF0*yeASF#YftGMRCI$($oHpvvX(oB- z{8be5-9XbFc)Dw<`YO)pGQmkcA)z`ZUTWQtxN~aMf?#NtQy$8zKF)hQPDN*hx3-Z3 z(`zp~U3X&&Ct{NRExwq>rZ|fBrBoGnD8I>PeMsUt>DYPg+CZ?UbwAr z;JLW{<8pelNQ3q8JJsksMcz^-nb~zU^S=b#A3aKTgSiT z1Nu)ZNe@xtE;GyPlqPv5jm2f9mr7dh10L?W(^Qtf>h(UE(e05HgosNtp=dP*>+62| z5Go$}@k*AxmCx8=&KztZHTjj_Zkc(f5K@*|w(HmQk)IYH1^;f#x~HAdBKS5?Qd56? zIcJ$15$i@F(3r4N^G$}vgcf4RF9|>4p!lF3iG_WFQrl*)w%z0QEVUP2opQWG^hB;= z6a4kHWjn(8H>R11a?34LLkY!rCApWRUqP>Lk0D6q09vzuPcI(p;b~=8y;mFp1f5vBe0+0#mkCEWcrhx3&ad+v?s)%_f`bY4cIMnWreKR#NRg>)B7ToPDY{ID2)N za>wF+N*nS5mAzzTsDmCJDbKHReA<|@v~`hO_e(vc`Q|)0BqCxT(!s)T7e+W@S`(q> zbg71_d{ba?z>R_7K+DavKizrD12$ZvPu5_!S}etQ{B+j{Is)IPfmbNZ-@7pG`=mr> zR_4bRSKIyYmALoajXHOILO>Ic7{*jtKEktzMkRRhVp1!K=+%xJp`7cy?zGH+Jh#Ug zzTz|@ohPFnf6B-F=Ha15DHRnthkYWax+xzV?x+hoIxA+A_lVX75z!^A7g(J0FemBh zu*=ew>Os0kb91-~CZ(?W)7xYfUK=%vz@vu~y{G#+J=D%q{9yObWxRiTwSV2whIj%X z0E0p7xC8bY3o)|LgFlNc5hoT9;}zj2(t5e~ENJV1_KdgeJT83sbOoTfNLGIsHmUB4 z3W;STh9y9im*;?%ZQzZX+9mhRPUwhk@0evGvO&CuYl+uLV@QAFAMfw*{JfL^ik?7qaK%|z&^Y>;gV|cYg=~I+#k8wsBL4D)P)6M4IOR~y@uDocy8*`u|U>y7}Ml9EH}({&yHQMq(I zlv8hIS!oKYH?HR;J=jIMH8DLgkSDW@INV@Usd|Ft#E4hA=VO<~`<8XZ!r7xRC+AqZ zd>0y-xiH>PS0aZ%7NL1?70zWh1cS<3>oJ~;g)S-4#9!XYwG6e|%P)2G?ptUmXkpt8 z)E2dt-z3f4Uho&|v<5gd$?ibZT|`Qx2*VJDKL?2!(H%CYq&0h;`1$?}S`PZcGFV-> z73#&V>Wny-_6dJxK2b7i;Lp{&M}370VnyVepd-ncQ`Fqb zwjuhb)IxnG*#`$4;iV}XC@ZFZFq&T=HNys)=9$z^v775+yi}gB+vsf3-Bm$UOQ}l+ zgvD=FVk$2s-J&N22>`hw_Wzn`>7PBEd;-@P@0(v^jL9=LbA7q4Us@VjI43Ob8f7fm zB@?^&=^@e5EuQewXWkeAD+ zDlhlOcY_;GQJy!(&uWIa_ej#}y-GTMs!5?z#nqxOGb-= z1{jkXgBKc4_mWbhbGK?RuR1=mPi-qt@fTUr?-6{W%$?yc$On(lDNI0h#+Fi7Ce&sY z9vdsLG#N-4r~^9cMvL_08~+S!&DwIGB`=_8HHBz$pW$);$|GpC_RyU^F0Q3~vi5*3 z+K7i3#2B=Q$%aZ6A?7u+oL#}=4pN2ETZjKe(@}4iI57y##_Ux;jE1~9f(K?1Ph2$e&J$QTH#lQ zf^-+TpV5lq?J(}*6uTkCM9l zJG?iNRMGCSo5$<*kb;m2(7Bhuu}VS6K!Z{}z4m&>fk@Zf?qbwD#YKlSoK9Rz{rhHJok_EVSul9E$M;qyVCbIz z&BKZ+1Nd0YV+-|!3h^`e$PtuMLB%`!iP=h2AOyS!RqD7l(l&3@??- zxwOj}-O(DxonOgunFmA}4+_W%vbh>8VRGbz+QpZ|LFINlIJ$f*ET9$k@1xq9veK}& zwJ)G?VoucX74Hd<>LdJU{;ybY(Ng{51w)mk?m}UFy-bQ|c|N6`Wr_sq%#Pgh&aMeU zmew?*!t{-ETfDu65TnooCkZXeJ=&Uw!F2t#`D)$^FnSY5c(!#tMq#D;sX0eAqXIn| zsnFe7y}zwT5!Dv;mV4>#;e6qSrKM$IxtjP?8?@^%-R`@|@5E|_`;jp8S8_75%BD0+;&oNS|V6-Z*&@D*^yEVV7Xx`su4)+mU<+mCk;jHQTIK+Sh6S z{C7lH^B!_=(e<_NXu0$?XQ>G)!e+r5;g{(Rc6YQ$TFj+gNs03sdxaJRoKEYq7C)|@ z(>tJRZSP1?TD$ohObAY36!yGnVn3eKX^h>WsMQh?kO{MdgO7=1Tis87mEMp_iMd?) zVZ&?>U%BDYrtKFu6Pvj7&G52-+B9^;wO87vc+U@GLh^)$Lx+c#m;PYt@qk&>=Ot?J zR{jE$@_{fEPCa@1_NvB9BrN*sHE*}U&fq$?ni^ObjL{PB5Ujkmcv4;olTaxVIqsw{ z3{p-*sH|)Q*?-xSa6U;czRxXg?pYyYiTHh+ot;^D2-^?N1iJdY?7YOw5iMcF_~0eK ziAZR2TzvV;ly+|i?Y*dZ_ra#GWiNbq*h$9AFikm5x?1_#QX)ouv7>S4O<%1w#X}!0|^%HQwPf%f>=-znYxlk~N)^^s-MS zjU|_^Kas-(OHFxbgI8H;S!T?uBGm@Fx_rtWqu8kn^uMmY9LK|>M}B68XH1Md zFSNJd@}Rxz#Sef^pP$Do$=uo(y59~i++7Cpep7&ay#VZX&?F8;Ot!Tcj-S6rn18VQ z#A>YLD?&(4nIfbNYaLj0A=fq4t1#E;kUcguvsp^b{J5@~mK)Rn!ekkPf2cc;y^@O- z&9iL03(>kQ65H0KGCc}BSoS74F&XYlHvi3fW#U^};--B`TjHRMV%Su8RD zOs9Btw_Xh$>SZ zgmjjA^@)}HI!>TnLgr(ZePZoXKdtMv3!!bTm07*137rLAMX`H!lca!N8t$f$CQ(h% zUayfBeX)&4ylT*)>DT7Co!yNhJC|TR)~onvUEaZWe}!tOz8qc@#;2O{u`e`GT2nWHK$;GRI)?O#>b;M&7GuozwTHp<=JoL zC8sAb`=y`;d7bETCbcqkJh$OyeNgo_)u6(E(rFozzI~d2J^U8Sznju|&{eO{oRKie zilW5A8VIy`=)qQ5D{PLaEIe*WkqR};O0o^h-OU=^tO^S~+PF4J@e-hO#i{GqIGBl^ z59dYU788tXH(`B-1#&jCVao3q1NIq4I0C4JG-k1Gs^Lv zl#c+1Bze4D3?0*Y%Gm$%R|p)PQ;kpM;$E<$MmlE|g8?qZGl%Tmm1(!uNw-e{RTQKC z8Zpknp$xrgd3jkBycl%#5m2D$cpdu+Z#)Y8wIm94xV*3WKXZ$bvxo)u<&*a^=oDFf zE*Pm)n5QM7qautwYur*Pueq1a;Pp9u7099mb!5#>tHt_&v8Be3b6(80Jz^(>{9b@b zXFJ3go!B+x{=OBgMSB#lp)mQ|*pPyjgu=o-<5)y&AD0ngbS>6HwW@`%A~)D(zhS1NSopGyMRFRLg->O9I$@9YQzp2p zpMOYP?fk3YdJFtpE@?|V)f>T&rjs^lOp7@t?mTNd1=U3`!ZNAUG&xC!73zZKm5t5i z!B^{KnOp*Dd%6K0w*(vnAL0qjOE++@4sv~CW5bK`&Pa`&6C;aY!&gUne*VO4iWoEX z@)sN|+D_Yy>(DyIBj_)*YUbl6XR5jRB}S^_`(2@0E(6 ziOa!AR_V=Q??LA zZwF`|n!6IeyP);)N(NXdRfrDST!vL9n(2X6aklx}B{Kn!j}y>}z>`~dfzSPM8*IE@ zIdI7KK^Ob6xVx!ZYBk1kb?3FPp_sWESmN%hlj&ql=!PWOX=BpB9dXUluLv$9aHg5} zqw4DWeP4y`vb!e4z!Nu>3_CEE&GO*l1!KrjYc8-gcc#>rCZj1h_p@I~z#(}G9-Zp5 zdDdUhv<^Eh?ky^m(k6 zkIt+~YYeK_{(N@jeyP(@NoM(ESTzE$X$AsiRaigN=34%`(`G1zxUEIbr7kbl+C+yI z_k*L>3s!GAVXp^j^7 z^R$f6Gc5ky*??&(PEbamZ7Lv$Or^A=ZJRfQ=svp>KThCN6oUt46Dv5Nyj31+MAC=MJ zy1N(^7lPMi;2Y#N@rtr*x>P=%Z_u{wiHXNp>cZVrKxadm?O#_&d8p_&rfQmSDdo@y z)%{vOjkp08F~IU@|D!TG#bJl(Z3bAfd#ZUvf;YR@Jb^{;i22IkdoSj>@uxX z7`K&`$Cq;b+WW#~zSiG<-=gif18JC3{4NMn$QV<^Jx;P8rn z*~p|87Q$lOLm*p) z;Az>@3E|@91^<%+eOd=!t1Aj3ZyoKd?2_k6y+aGhd_U=zSnRODzH*B^$wbOf?G@ED zice;)&(oM|8#Q1(%bCthx6T^vDe_nXr8SEjwdIoYdbF+JNmEA9egM4{oqNl+ttp52 z{2yD}zDBU37~7?8cZ`14GJj=7m3R^opKIJ|+1=nRKurFo{VFh}>XgCN!s^Dmlc<%p zAA6%_^QD_JJo=*PCckA)4N7P8IIXYx$LsYEui*W#PLiBV#Eq zpYCwB=6eE76TEdzK2Yi6;Vo!=@wS)f4&T^i;y%t<&{C0#G@?pRuR0ccRez1ik+%Rl zd9V=3ug}<4Pb%gWrtI3P)nrYJkDoT&;P(}UG?lHjyv;URWm!RIRs1p~bMKRN$=EDq zo$d9(d|Lb>v-XOjJ?F@`I#?pgE{HLQlA{5);=yXu_0#R+{eAM!sJ)C`>;wWhf*_Ei z^(|gP0m+Rs5Z_{=ffO60!=W)q+Y?nIxhqWy_3f4+G=(p;WwOwCPzwlZin&rpNMiHWnQ!0>Pan?F3IA*TVGgwhGCP72>)b8%!n~n6bA!)W7Yv;f=54o( z+YK8o#O7T;;`fYmU^?4MwA2Wa8*mt)sXSca1QWKj7Z;7{8pYOZLg0h6Wp2yRs9AN7 zqV$UVlDg`g3u8A4=gxO_<_}}~-ZIAS&d|>2g=X0aFJZz5|C+e6J$(4Op2O<004fSF z*7~nDKB`@!s=W=JK?|Qo3&*&+uSQpX+jgujbM(wn3kDI&v4&6*BE)5Dc?~qKyk|oa zrQvdyY6`G?)mwNgTIlhLmg{pC8}FCduPRT1C~(M_pa#6OahXNF@w%mCBttU4;X5}K6XVdtRjIS% zwFnfE5RJ&0ft>-FCG8JGrq_h(SIeC8(+9(gPD8AehZ#~=euia%r3eoi?3Uuj47-U@ zlk#GZU-y_~E$z_v>n2M8KQA?dd2Z5Y1^HfZ!9954RzBpMHI@Wxl(9eWpjb zpS_qX=w35POcXM*`tVo9gM_yt&`7bgnn~od~-%zGb16k#~WmF!ESW(g3{Qjj-l>M`=Xcrc?8tWCnF@2}=(rO-vT|P>iG$^1zv3^ul5X^yf95h zq0-z$%IuP{KPSV(^ByPOlgw&JUVaTyORk*K)Pl;=0y4N@034SDeSS3w)G`3l%D9+m zZ|TS3CkWj|hi?-G&gIoc$(aQ>T`SGjH|1P;?h!TIqzzRE^<@+u!^o9FKo5x1bs3t5k!XqiaBfV_1e=uB-EU2=UELd~%I^~(-CfhZk>$%eE z(R=jSjC}&NEXR*hd~d6zYv}xblHj`la!7(=?+yEX3`XWG%7cZ^+;2zq&}MNZRz9wo zcIT#ahzvSi?_hr2d45f3zf0kThi07_o_x2qW~o&sYDO3DiD#B*q4634s0%@(+G=Nx zPEm9J3Og%8qorvC&toWBhB{6Q{V61JC2(o6k=PDb))azQP^0cs{OunCznh;=xNY;( z)-;w%?y*#_ae$jYG&60gzoZF(5C~bTW4;b>DgCE(${YG!?^+Y8~^$SZLNh)T*WVNa%I*ob8D~)s}ThF zFMe-W88H7L)?0ZayZqs~Z&&@Zv)$t1po{>m>WO@y;t?RE`d3d#trpa(tva+yk0CN! zlicq*0!$sEpz%*OHj%uF&~Jc{0Z<+&1NQ;SLlMs3jn8?1 z9P#o=GZ(FQj}b-IsB-g91eR+tW*cJeVO~;W0K(f z^{Brn&B%!Ow}Yhf<7LvVl#i;cH!!y4Y9f7+9$IQHv-9})(A)z+^o8)ZdQ3`*!%>l> zEUxZX6J7xu*g;4P&-B;PPr_H&bryMR+>TLy(M;y%Tr~ihCo0exU0Se?mWU9BjSnv970UE0H3=&M5RPX0A2QgR^lz z?0y;D=J3`GLNJx;zQSrNjuN!>nWP~x9Tr^^7_d+RqVe0R@2Pr6Dwr~zSO zEMMO~Gscj_KjG-CN6iB)sSP=7{vd`n?GZAxN0`1E_S4DlH`k4B7tt>u2MdaBxwbY0 zqec?pW4?m-xW(V}uQc14Yd3xR&ckHdswNdHw@!X#e}7TGZuSYpmN+R9bo&F{Xk z##cBoTRO}mzGsx9#yxY*Z_DsNe0->PieVbpxM)*DZAF40klM!FY}u9)iyLz98KYCW zwi#k|md21-c^)eGEDeQ)0VczerE+u5u+BF_^D69)_TBcVW3(AUf-FX|>M8qhEa5G- zH2mSHryo7fc2{ok^78ajD&uxQbv*Lw`|kVCjCr!md1!D|)C{IBMgi_bIYuTXW$?l6 zR`1EgMDEGK!gW}g2@t>SygGE8tJ$XUP{KIkYswnKm!H1jO4lf~d7FVWRzLN_1~F7A z+iHTM#5_13=EPLwNVzyz3KeMBj?1;NA{^B>m)aT%SE_YE8RK$Qv;gnvChteH<3`_2 z7Ho;AB4NzTc9oP8p1v+={DgW zn){((CrdRNIXGdU&o*w^n?gM-P&17+=_j|l!tBJt_kI~}8uwJK`ISsZiUty#_eA-* zWJT!L@p>OY%CTGV37d*Cw-%=Z&?PU0EH{o2DG;)p_&9($7Pa}5c&6C`U zsa~rrZdw}B-R;ed4#Yi<`Eiknh2?B(IC)}XqOg!=F0!$aYmQ-n6_pAg5qklt&I7{3 zns6M>Sh83Muku2csnR~lEUl&0w{zLSxBHWqCXK~RxrvA0&JN3<4UMibZOe)1>8(6I z+<~m-+6D&pc6X64z3wjQUspmPgj6sX3=13ES1d0tuf2D5WN&W|XqJzU&(@a7F@du8 z!!4UKJ`N5JA>rHCufMRf+gMq>oE6;Y?CcyF8L^xx{@EiVEuBvAMgY>#&@lGl(?`+v z*e`De0!3m<&_e=VSz1`QySt|o;QgG@*Ug_98++C%Pnz~2-QgR)I0~2J&RDJW;^X60 zYnfJ^tfJy6(8%(wa`z)BgqDuZFV63IKJv#vXZ?vy3ZnNK55QE*0W0W>kKIb|(s`fN zRn=~ATYqmb#YLrzwjPUJvMtT5edFV%)t#5P=Qfqv=^xf*Q7I`YeSMN^bm5)-eM?*0 zvg~XMQquPyKfcP^pDo*7Ta%EGcrGIFqS17eh?JC6M@Q#VY(hd=aWU(cFLTXqEcp2N z^&gGsC@C*yTOYAZUg8REjF~7aE1Q^58T}z5B7#Dp5D26<%eX-m5jsgn{%klbP0%N;dI@d8-A4apWfx*eaeAVje>dubY zF>5Ha(FtX5YGy{z-NM)y(Spb0l8z%{g0;V%iHQkhv-D#v8D#6zEznk5TkCST^c?K_ z8=ZjT``*;&zKs5h{@%#7qc~bMpqz;(D-RDr{0pf-r)LcvKN=c1i{Y4x99&$2Gg7J8 zKAzfms#*E@;&O86%ueb|IQ8Gx1T8EIlady?L$KSs%K0iPDuBflS+BI!rJnOId&sv- z=vmrqvzm?BwSVe2)r>(mrndPmt$k-l7Gr#xI_Fq$B`vkJ^tFHKd*}W6C*xPSsHY0X zeatRL(6U@IygE4Zw=wTgD=+E3JD1rJc~tr)9i7@V3fFtS)C3Q ziy%tjal_z|td@H7PFGudX`?s7fP;+eg}wImV0-)X&$-pr)e#X9IXRSczqD~*Y(cc+`(&0e7?$|>+GAAb|Nn>Os zC4ICn*E$2s<<$p#kj?_+0P_14l$5+x zMWFKrOkN#4=k(*p2ZDGsHx`Pk*!eH2wt(yila+z3XrNx|n@zJv?%BAs%#ve8uTl8z z=5h)qE-RU~2&iMaznG z^nsJ)`8l^abiLTxCe^~i#8gsKV+3$Z;TR;%#>R%2BE)rff8ziGf%2bOAeEV#n5e3# zyhTH6Y-~K7uR@AlT3C4F&OlF(=;f2zk3xpDS)A_q4(#Q{EA4Ym_$DJaGn0&tjFJ*j zloTPL$Dr<6wE2WIP7&unmVMH+#Zu1mpd+j8hs30fNlGH6Q73BRemQMDkTc1pzCe;Ni|qn z`vJ)gK25F>{X+=o+^{p>AHu@ihwjlT2ZzBsR?Sdbycm`$mTUiUihm*`aQD!&G<3Zr z{$QnbDQ&p!Sg|-|X}NBvrm@&l_Lx%tctb@^(WQha+jT~@csO*~oJ3gatMQ2iT(v`# zT)(^&r#b6fLX_dKpk$#n=pL9mUe5~X_W#<70YCDNiJJ|?#>%bDje`6A3|2t4-A_Hx zwNYB?EtlPzs6~DBMutx%jfR6m2aEmg^47}Za!GvS{@|2fyWC(WWwMHSeh7O2q(^!l zIuWL3QD;wFD^DaFbW#Fn`2M8p1gl%c`@(6KBbH^VNR+_V%P`3!$ehh?LcL9OXNojv+LSiZERkFq{AXa1KapOT$A=u&N>%zGsEwEc z2@&^kpwAtQ7@0~-guC&9#@YDg`hRTqESNOe_jUg7N2|jc8iJq=?UL)KTO)y!H781x zV!67Bve5T`>RX)2;7IGN$2uAP1T_WN0h5T~EKYe;Axl(;AtS7*$!WMY-XK68`g*LM z^`Fiez?jKo0)g11x!$}*^XAk6+c$E3+soqy*>9CzT1zcM zHQTeW_f`PvbAtc#BT{lqVoO1+P?6^4{MO&DSKf(FT`7cyyZmxS#cAN&@v-ku$3>!m zItX~t?w@!Fq)!ZAOG@-?DiBPV@9Db9$OIJb+t_ia*4jDAWmrI=0<1?W`Li=xFhZ;i zgi7@~>vRS1asO|89SI#K&o*?Ol8iW@Y`Ln@6aV&C^IH&33AP4$M| zTdch(KhK#_?sIS8kPi5LB~*ezd*5Qz9V(>}7@>OY08H4woD-n*X!op65o&Zy>!UIs zuNdhDXH@lbKd-Zo(tqTfi6|UGzEPpSt7?Cgg!Jn zkHLn~Jgbk063crI%{(KU>t?g$U5MOGZ@3P=vg77N>ZeXo`huG#AmakTKM@Bn;pe(k z7>cMupJ)5V<{2^n{e2$sY;lxAJj9;(p4tT-q`hG1UyS{QB>DE8G-_Ob*0UXr%RTa& z^E_dLEtGtTsfI_?q2X}_V)d_Y8S*b5);y;M0D7JYT(=up+3xw z00P?o9j&^HJD(eiHR35tL`h;FG!k=Y6>YYo3^r?tX&4e(%!t!IjBZ&!y?YnW zlUCD7e%?A`8^FaMeBjT;e}HlK^swJrqB8aj^4@&Cghw8)=%yWfv(nmefXAuA%_Hay zE&7C!l5b!4%V^0o*-`pB{H5=2l}Z$jOX5cbVGFgfAn+Th`!NDhQW_Vgt_t$>=UCu7L zx-;YGBkLLV`FxvaXErXEhT}|FVRF!K`VyKkzE&U6I@Y#lKAXM17LHt8!u{@<)ks== ztm)?TrCPA33W8nvvbpo=Gad4van*Ni@}hwwtjid`Kk0g`*(3PM7xi#n1Ny(42t470ZPx%xfjxh(Leg%=lXAMXKA75WC zXWAkzAVAtb?S5ji3ywV!AL9~{d4BXOjS|b*HK2gEP#&W9f=sztfXfx7hpqg>afqUa zc7}bKIs<%Ml+7zDA7!=b$o0A*rI~U>Tdzv(eY6^^NyKQQBe)`I&IfNgO~sb~0DYG( zdwlcZS>z7*{uq;@_^H8!x6FgYjm;Uc$CjlcMz#gTvgP4eVOPq9y>K5$))V&hct!km zQyVRnC(yGCLy`0Z80~pCI-8iCRmWTL znps*4WU)WKyrC(*-#%1*WXQP1_|F~UFDv6@sDt#*c-1n0zRD23SH=q|MdXkpJ>v|l zVfiILm8;D;pj^3PVE$8mjaRVD7R(T_rwst!ovWMGU0Ozu?F zf^2)|c4(K@m)j%o6VcSg(TW#(RbMtwBu|>iA4Q!$JCFrlg$7q}S|gPmm6z>$*oCB~ zU`8J0sPSn7qEBIlu{_%-sa}CpU4KuUln3geUS9fVFHZbug>uH~S_%Bh?+&UC9({HO zFoV&rk6fR_TH=r}{84eFk#TwIvd~#k<~bv>X8EuE^?Aj88f1D$VU!lV%{*6veiS65=%LI&;Pz;{#Qk`_kwpLMqkM;3o6fp2 z-ZgSIZH#Ba@ZLM4Op-hRabBHn5MPN)=rq&Y-QMbPy0&gWpWCSRGrXj?W?Mivrvx%8 z$iG1K?U?N=q)+YjchVnc^PSI#YCSt#BDBYdZRlh<_YjEUf2t(FOKaUPws8kV&DxN?ns@5;ZPK;9DR5gt-;S=Hp8*-vGea7wI}!<*XW2; z``(Ynd3}KY+W8?a1!?Hbz@`(*=G7Z)emkeC8NNP87evbMbM+W*<%N&n(&cAODC>EX z1}X-;aYrBRxm_P-Z->E;yV$yQ&$^2f4rT&Leu{1|3;)}HcoodZ#^CRN=KzghK&3U} zp&n@vL>BkgZpmhTo$U2wfQFBqxara5B_O|T!a&j671t?66T^laXMls}ckWVw_`|d2 z3!OhRHge|6Xk{F#epJ!^S*g}E+6~;z-q>4t!ABG+>XI)iFiNLi&%aZ+X>?tTD${>O z#389&@4izZ167t&bp=O>VN-i?nrY)9;Uxey&=mpyD*ak=BU-wFL(<4=jDg!SHC3cbO8)F^ALO28+r6W-h?_%iAY*NS+_nXjurI`Ly2FV0CuQr&*`=+ zOx|TLf#Rbuz$I@&N<%kA4H8KWQI|Lk?RrC3AYFLY!dwv`>?@os^(H~}G0wS9Numx8 zC^&v!(f*G|qlR~d{`I$c0ZP;;u#Nto1BLpb8pIH_>1CbTJM`bq#W%#z5KrK|^`D*6 zC)uDe#eSjeKZJmn@PE!Y?x&sQdXR(4A=YzAkVCgzc5qs=B+b*X?}U8Vc|GbnX-E<3 zf1~GEjh#fENB6oC#fY}rXn_e!-FCHu8dx*yF+aNA>UzeqrZ;X+t_b)d#r(=++e0v}vtgOw3#Y0rH&<$&jsUI9SW@c-=3xs`TYlL$s$*+YuUHc)Wo-5dTv zgZ-swcxHrZ=8cY`v0#dNAGRfu5FrD!M00etJvM<`w2GLZS?KfWdXTM`(OEd1>B&cehM79+cV3Xgk4r>z%Lz;Qx5N zQGSnw0s6%}eahE5Gwo2h|FEfaQ^2*Q(&cIzo{FFB5!uk74;)^D2YODYD%&uX8`W{0 z$K(&mWlkj5$UNQ;Ho^lR02i8Or9Yv?)1{<%FLf@Y5M6R}g2+J~bDD%De$-X8dF`tz zR+8fF4&($CD2n=DQ@U91X0JwEv6E;wS8oQf*yLFSz($31AMr#~7n8fAe!WsF?5Zkh z0Up$ZdJ$*4Eky~v*U(mFePqrqx7xb2G>Uy{uiN){T>e61$G(AWZj5GW`lWQ>0i!0+ zxQjf~W~-2wj+)3<8Z}lx72=4v1Kc6~=LS1=5vSBOSzte3@<-e@l)o#}bfjWMgY>K$ z4;L%^A<)IuuQ*O=B|WpLlO@&_)KQz(rqTku!tlCLr!4yclHP}B4kLCBI^}S; zm7iIwri5+{nwT)I;@1p!eXP_49N0QIH_0mIa~475@eg*v2}CUV|I>yVyP&JaZK>2@ zeKzj;hw|3%U7Qt|1;HAOE`fhA_}%^=abNuqWz#im0ZOV!ODNLa(h`DncL@^GE^N>t z0!nvxcjriN z(^^=m@}ywR$cmx~YGWXl`Godz&}Q=6(Ce`!Ncw zyft-v*f}%kg*x@dJex|r-o3k4q1|5=T-$+*e)dkYS?^8CJsj4j8m!cm8ni5TLK)vF z1LX2oOXpM`YygF${m&N~a6do!|M$xfx6sB(k-X4lz0Ine01cMYYl9zdZ!8)I>n_g# z!?EU#icUgL)p^)oJlvRU@uAj>qF&4NL(Aw-j|UvDc)oNE_Vn|)DjyUz!9w=NjNN8# zv~lbwJ2|=Y*g&hj1vUf+C$4AWOm{*85W@^*k+2oAR_mY;AuaBEfEr6ZZ z?A?><)SRBX3^c^VOppHkX#LI(&S@%iSgKY}xIeN(Z}z`Fo7h2*6sEr)R!1I7n!6gQ zVREo*(*Fy&*7vPfyUPmwUwT=%`WT{~V+TcJ{UgN$?q+lF@w1-}zh9gVRYME;{gnXc z-><$Ld}?H(pu?TW(B(D1%|A<%{tH>4iCr3ak9TL8+ zHG=H>cYQ?u>#L^x0pN;AscZItGX|-C^cLg0K{yT(I`e5eMN_+kA9MVC<5CRYzNRJK zAQo{8W#pw==n5SdZ*R4^vMf9MI>XH|;ddPLZVgU;|8=r#!H(vMLCWb$Np=+dDKsdw zuV00<^=n${%|!CV_#<36!aghHO$5pA>gv!#E$ERNK@6W(G@nLHZS@2gPqD98RTmia z@9OfzZ)f4C){LXMh!Bsox~AH)>O^@JJ-o7)vJ5tq^c%#CHrq_rI}%GKga4uxEp`M5 zV{ab3%vZa{Q%h6>{s;yf0=5Y0kKzMa78*ymu`rw%2u>9Ah^Y23s_Ho0pGn|+sE!y+ z{LdxDJ^qKLN#kayO05^`6GP*K<++E>mPt98T&|IWg{1Re&mJTFHqNn~nK!o^lU`q{$O#hGKkrExH9Nyd*^S(<=bPt#CtH zt3j1rS_<1wDPq)DTaZqgh_}cO>rSd0iC_57sSTge^-ognia>bU*q(Q^wh5kmNB*vK zYPL4n(M9u|Hl(9Ht?j=c%Z)5qkJm%Eg{LMPMW|_5ENxkBgHK%gp^sX;uTL!N!;%I50Wj!uIw739I=4Df`k0Te;dHm?669thE?!VR)V|n?3 zQRrcdon4QuO`oj|gVT)8@Lb|`&Rr?2Iq;Jju$f4YLSs1jL)f?FudV04W&~Msu|_?`#RTu z5!T5l*kIt5rK^&T^p5nw?G;-V0u~&CWW-9?JvRA|XBq}^z`4DT@+~1rZaIgRI z``%q2)W7R72iNDfc3B8S^3|`RGts{W94VClP%+Uv%idrZ z;5<>9o8sqFm-x-t{%cLSchEY!z4D7u31oe^l!|eahs%an&Vvc{|AC4o>(`IL-(CBy@_wSa0<;xuQ(ho-Qqw9w> z|M&7iQ>_8Wy`NozcOqfF=G~!v3Sc$b|8Yq{?Q!IGalJz+Z?4Ul-ItcJ_Up@WyYFFR z|7-gS+!Zm;&6RTp{EzacHVKw5MMe1(7=V-Cp)aCo1P9DE~MLTBG9&KYwH6S0V6 z_1NMIVkI;I;g|=|2HFAlP7t%5GW>9wH+RcST2z+E=b4GQRZ%IsiIAfl%JPA2;(gp? zCiSML6{>%HF(zS|7BvnP8lA%KqR({0eEpF8f5Q`W(GO{RN7&t^Wo1GGV5;u?Np(K;Qi>QGPS1nk>-zw-F=7K)6VG&HU>d`0vl$>tnPZd&MNK= z51~Re@)&<0R3ykBE5E_9=q5*k&*51Z9T+b(&b#Ck02me?9@pBC%aOE7L#NKt-?B2_0Z`)%U>${7l^BaQuf$&bUp2-A?YzA|O1f1*!hrin~eg!2v z?egiOl!!oKMSwBPhw6#Jggf)5X|6zcZSPP@+KFcQ7HKuP7;rSBLj#Xwn6tHHWn zLPREhc>7_COa5qX_<&3Ohi3#SBkgIWPWJi{M)ijg2!z2|Y54@rg9L%6ZJRM#e{muQ zbGTklyf#gVG2H|A2~vcH(lDp$i+A~A`Doo>ak=I1kh~8fqwj?rd-`5#JQ#@t0uEWX zj~`BZ{dNZS2#KxN#MM1o-vrA^d556_efYDTo)Ms5-irn;ur)vn5+LexIuF9^KDG2g zFJIsSx90cp-`!!IKoYg^FXX!!y4u1@BJAd%D1MrRRKhNc#K?yn&bqQN2utIBll@`Rw2V6WOQ29ba7qmUK43G>-8&+CWZuna%WXXvsgKvd zDsW;->FY_!iC^!Je@yaaSCw-yRu3+X%7uZ8g?rlfdEogz8GnD1OS(Goc~~~r!=&tGCQs}tGJjclZw6( z3q4R(nd8zI6dGbbC@E+t&1x#GYoheptLPWGqe?#ffzA0uIN3cKh+vm^H-?~$DScX& z0tl*_&+vxof`D=WhiJhNIdc_wJ%B?U5x15if=^t*KDa%ua~j9N>W9JVP`s#`V=ouE zxx3>pvMYbp`ViBux`;-r-tS_~uWk-#ZS6cBAl;d5&0Zuvt1B$2wFim4CcjHyaMz4H z?CK~AiWdz#YSouK9~8%^;?h2@yhzRUtBWW?>&6X!p0iHEnlL^J}`ESrwPW3fgAuLaTE+M1}5ewi~Z^uJwCSj@Pjr<8J)FPukqBW zoJmQyT(q=e@$qdk-&1Xza&+=RyDt%9vtX6IaBTnbVP}W4EaX# zAhOILO5C&ist(wgE|XIic3X|b8He$Du*%S$0FXrG(>wl3(dyr)D=v`Nr``js+m?PM0QSCgW&AfN()@{13vswz?X-d4a>^0A`kws-6fklkMO^6*8!&K6O1=7X*-I*G&j;0z@*kw!gf z0go9GWyDN^$L?qP9^M$p^~rq8#RN>%KQk4A-x<@;xk>qS3>x6M3z~)3cuM0!MM3!Zon49exR?k@$GY| zJ=YgL(j)hD6Yd}Sdi^OmK0mrC*kWU|69-}WXgnsR^_kWVx#e%9Oz2+0kM) zbqKu1B2{uG@W(wNAQyljw};t#+t2AjGOB; zL9X*k+aI*G6_t9vn?^+XZBOaJR1H=x>=DJ=^^fS&T}#$AL4M^XqdrIQDs}q@nVX0E zk$9y>FY_$7oSyY+A1?=u)wMae?IAQy!cCV6&n~+85|G?d*Us z7YRZuiqEkMAz2*rY@0P8$6tGPbB%`U%Bo5Jdsi4-zV&!+NBJjDu(iIPxgDrnFait| zD0o8f-2}>%c=}P+g9+_T?7`!6)!}zkD)3&iRQuVB29STULNaBL2CRwz9I~SCQ1J^h zh&joge1JdAb$R_%D|>0Df69_vC=rqgr@6Wns=16fp$c_2qRZ4n{{lrZ^bkIQM)y zKQ0y65srvaxuB(frMV*x(nOhUH{I4@QQ)I|@jg!yv7IL?rbOSS@qE)O>Z{ z-gicOGoE}vrrDis#quXjR&^EC-E}QiWi(;7>{Y~6BNYiJ0O$j`-Z`jJ|C=EM^DA?`YYCv?dhB@Tw zy4RsRi4(T7^kt%`lP>nPpJkKZ>SM~+6wRBxi5vr^XyuIB3wBJeo!fF!xj&BVTaQTa z1hI}0G+H)zb~v=f6qB8P>MN~^g&jtNu{H3#qYFSDyppV10> z%vBjTc@2lVjscb7SXl5=aYDxqnq*`?M7&*_?PfJ|ZT=}0Q(JLsCZ}3FW-Ya4-F>xy zxh6W;v9QR?3L9Ob$@f|d%R$HW#j*c^1%ZZ}lZqr`QY{&R)M@(Z(^YBr>R<*qm zA4EKP_$b7JW@XB`9abnPJMD@|MrOnfBdUcEjgHNBG1cqoN6v`XW94O4*5;jVFMV9x z8a}faQy5^hGHRlk9~)7d<?m8H`TrNd-k*jLvB(mPpLn z+|{MAEA-uq2)Uh6W|0@PrT$o1`?fFQ?s8(FNSx%Xf~3wvP^_XL64OG~=X+mundDw@ zO}0T+`yuw@+Ow~W5Ef!`QaW8?#+@zS1qYM3I<-9F@t8(G;bpz(vu@YVDvMAm@v*z# zt-M5t>`l*v{zB@5zRnBJGK_DA03z`L1zJNcy@7cU8$0XoG$Jjaak3P)Dzt|fPIGrS zx-UZr{c)+GdBNX`ivXvHUC6MGdI>88M}8oVo?Ish0Ly5xWrE}Be%G-jg+&A1y^5$( z8_d$SpbVeD48O(5-p5Qfv*V};*2Sq{vu(s^Br(u{jS=Xz^-4?th6TT*Esf2^0bsyN zAgTSGA_>&eHw}2}R8&w%6r(rHAEu=OVk=#@?1?qVmjpsh|A6>~VmSDfY*3LNXW$yx z@c~k`2KQYxdT`LpoYwgG?&6_OT%`qINy9Lzi%}gkoDw`U_qbY#*0zw|jGLb7NZ;*% zjRf!HSh-@z3ZPs2<-Dybu}`ZiZpd@Y^0-GEF4f?-`DSe69R0Ig<~iM$h4h8tn3Q4E zBa`7DP7p06(AozajvglnOw@FEbhC2yFHC;-pEt0S7@_?+IBHIVJ${33UX!Bkv~VE5 z+A6V!^?du1jnJ5bgv6M~aiGCIu+T8|rSo)`x?bBio^rDnYYT^8e@uEs67>sP)4QsH zcJ~f(r7)+;+x`LwF4M4Ud*ux~g`X6Lf` zV>tF0cD$B4Piaii<<*}FOLbcK zbajy#*E98v?=Kwq4|cfN^vEpM$k6?}UFLF9f`yl@s;rYW zY(PW#?+7);ERd*g0zC%nt9zEhMC&bsOw|iQC!la6jH4zvqc`C>d7a1&Cc*mwUf~d z+RVMQ3?y0BfsalKCj7Y}o!ovggO#b;N{Sd|Fh-T+Qhz-=zVP zh~>$5jTcb6t4`5kHk{_djRIV54b>|CMORKupKUtBLw8cC4lCTDE(LcsR7%85z9|W8 z>Gg#6DPJ=)R&awXU~#eyv%ja?4yVa{6@yZ1RDwa!xBHiPV_uxfT)M}GPl;hT&f}MN zeGwrPa)V1_oBDn~)Q^~N#Njihak;*Z-gi=tBc*(A=REj~eehU!Xfvb$|4ergE+y4( zm+~d_agnw*1UFGvSLRp1({5Hdfd$Cd4sEq}sWaP+PS@@({vQq8@D)W%-S;jMTC~#2 zgEG>OcZ>SF7>CK;cdU)u%>w2sXQ&D>J`xzCCpm<;3l+*67Rc99wODIA@KP(?;tUmwo z1%C?vp$gE+1W2s!{WQ#iHoBYSKe=Q})u|=*qi)${HrFB*I%|ITcn)gla{cFHTO|wX!Zdj7kS)o!yRh6Uj_J8fc|9dM#|4*6r`%Hwvsr0{9GMJH|+F<15xa zu|ZZaA^Zo1>X&HW&YEYmEubZVS6d^MK&Y-nuHtM#-i8@AkinCvFes`kI9JKiU8Ea% zuB3+&r4HRc|5^OVPssdwL2cq8H;NboXr`(>wjI}8I9kiD46k!_c3bXpJ>j(?`TJcLAz5vhBaNGgt4lGmtZ5 z3*k%Qz8ax#lO0J7RlGd?!Cx0;tAA#dRQ`7h_%(K&!}#8QK39kyZDdI3Mf--^Rn5}t z^Is0D(>`8p)q%B9FYQ>!83}C}^qQD5X<&Vq4z-z`c&&1sEC(Xge)wbrwcOK~Neh4G zBYEtQ7&vY%Re$(y^UJHY+cXBHRyAOLPYUc+M}EiM6mKo`P~#V+Any5x95eKqqg&eV zzhFZu}FPin}=NRc*K zqWw^QM`TL-##4^Mm%DhHp!tuVH8S8!>5cAEP5k;_jCrvL$?>aYvkt{XfCv>_QrKu) z^Oq&aC<~5ac2BeE{p7$?H@~hrlko@QF3JPb;Yg;|UUF--<@99x|n=U>~#K z0i8X8;zW7NLo>Jq@Ye`jzvF0DU_?1E;$p(%>(V9%`2WjOK*%| z!M*eXJ%?w?nk)(|KXPv&D=3{_Wd+uHe;?$W?Lhlf91%rGt}ttcNbXCn9nfw=K1AtV zN&g`|>Zco%#T-K{nzcsg&M7EYq{CGTF}CTwAS^Y)DtQjQn!?k%y+W|JEt$}ZZIjo< zyC&%afF}glSyvgv6-O!h%C3v+yTB@(mb>ld zHSnB(38D0N$#`X@d(Ug@Um-lWcCrH-VmY>g;y|}=_dKDVXgcg1HL}3m!qzQVa8jOT zCAAOS{mWdaA8t%;-}97g9n6T8peU70$(3U?s6t5&ydl-<6%hL_Fw{o(ODd`Nu+Et% z!;G)Qh~a(w$KgvLqa3)15B~5knZ_uY#=_CTJHx)B46;ObNo1Dp{M6c}S;)qKoI98w zt|$b~8w+|GKY1TFjstX-6kEcz&fBz0|9yQJm(g~YcimD@pZc}Ph@>8sew=AgOhWdg(4Tp z^J&eShwEZM(A%#Q3)zaS;p=)ZkFhScEL5XC0&QnHaIQM`t=AQb_Xv_FLQ3=d*nar^uswF35!Ut$KF-NIH-fQ*K%vh-+;HTCh29pqAjbrQrI z>iJ?64Lr;?yv2?0bs=3@7f)XX9ifPB%W|;__odulbHu??jMr>RbV5nf;*tji=yiRt z^RaWOKIkyOG=B8+&E?Y&>0nvKwx_CXPpCv6a=8U)sxpAbWeQD?J?9tfzv|T=awZ;s zc0RNGzDz>MJtT;I=Y)Ce9TMxP{gLr?=Fh1Q6i%<8Y)c%72T!NvDjDkX(WRwpeddA#@DX5 z(Z3pgAJ>R|lUh-UeyX7RpnXp;q*XEqb1I~_SW7s8c746edWm_VNsO-vQ|g&o&Rn)U zl-s~q>qT5IRp}$CPtIX;Wj%Ry?L`}$r=K&-eUl$;sPMD@Dv2rfk7dVnd)|ABO^%NU z!Z)X5_3>LUh|`E8iQL=2OvI(K$^Lc1z&OnXmLJP>?6WQv!&p3-bvYq&Nl@4KS|pJA z6iPkcbn(=U+KT$tm2ZDp`&)e%O%pS!&}iyjNi7gj;ztL( zus%)ic2vaXN3jel%fmRKmAelvj!G&Owq8u2`vglOCa&gXJbQVoC*jVRw0&REs3;7%q*+zScZf`UA()I2lu*Eg_Bf47#gXfLo z_1D8w+h2G-PG)N0dAecVc0rpw+O31GIj;~;yGn42F`3)QGN&ZptBsSr*4Tp@>=XY; z50x9KiH7N~bh}S!g7XY7HEi~%Edk^!E~oi*E1XkcEz50Pg@euW-ybIGxS-KmY^3J?`gburo;whh{ zFNto)^$OALHSb`LCyx_zjDepuXy2E9PTYa1S@e!_?aX^(VP4y&2+3=Hw~cmDFVQvS zCB{{su-BJqvHhj; za*TZ4Gg7noCe5@Rdaj@g>b`^Xt0b&PcBQRrmJnAcCeQ+@_ojIMHs$U8v`AIlv29N@ z$*ghzJvN7H4OP2>iX$+KM0*p5+Ss8-tj?{(C*SNu%BneD%j{e1I*(KbFJ$KCZz8ia zd-0|_%}mZ4sxse8Xb}SrCo7;4yr66RzMOG~H9%*8RzC?Oy}hHTtt@T0%mBK! z^RTLaYUxiF)p%_Y5D^nKUz1+|m&JGt;ZpLVU77M%_tkGqpCr&;e%5Rv{05ZMj5g}F z$aJ?g`4^#jZOkE`Z*0*Mof=uzWLmbKo6_VX z1NM`ex;^<=Y2FxX&GQ%XN(^;bSKbrBt?IO1c?sLrZ2Ly5T3G>O9?)xfSCe0CtWw!M z1PE1v?^PxV9wees^puM!`m}bFBO%`1DQ3pN7VFr(ZQr53RTQL7#4j$&USqOIO_G6irw&}yc&2yTvl&5g!7gCd zb^lJ2NAwu*2mGZEwU==brXPCn!#@{NZ2OH-eGo(@ufEK#?6?7FQ&Y|oJG&~QdT+UDNBFF@6>wbnb)^y2+H1F#ki}fgVjT_yv2O= zn_BCrvbr1?TL!f5kQ7RrUo+C22Y#x$z&-LoVxA!kydFQiEWg`jH)AeaF)SCF-*w5k=oWIt`3}X6OcOfmt5tgl~`XJoS z@a|~-_3Ek*ZrT`fnik+Y%7@}Ag>`}nGqc8iH4jpo5?xGjS0GCjTKf)5R7( zl|lQYuc@f1ezy%^FF0!Kz4lRab#fod{Z*ZWzm5a&>`C6LDCUKK;N%U?(jmktr z3ZAq!SanuP3Xh9n+{%#`p?NOhVR7&JTlQcHiBT3sGF=5Y`qQ!0_LGWOV%ow;U516q z+oaKWv_PGS^&G9Xpe{Sndt6j4OT;Zrh3geO>^j4Mg5CSLH+T5TiFo{T9}&a|i}GGH zs~fd%a%Xy!KeYO@{E7Yviv4ccP+GKdR@vrDx7mv{cYx{lVoj!(F=1|aAQfDne0!eP z8tTT4-P1H13_t^%>&0oY%IN?y{-_-yTtTXyiPEUx!MQ=du{M^*4{_UcC^R{ zbDvoydEVMqss>r=Neg%%bS$Wp|K}bM#rXR@U=l}gO|8$Q+`m^%#egvdNffj5d33I- z#hEn!rsPfm{65Ps)(cNs8gmbP2uqQ%N}$XX3GjSAp7YKbi|s<=-|DgLs+Q0o%D0C6 z_&ya&9KH!+>aSFyu;XSB?3pUWHl1kYo=O#G{pKAJd&#hDh`-D@7l6f%x5c2(&LBA9 znTvG-cDQ`ZPtn^P!&gf|E4~`w-io(YxtI8MF)7puwvV}Pt|}%HNQ!l}q8;z{yhxMu z<$1|IX_uZePDi#yUSaxAn$yq2Ts|!iI&#xOkj;^-y0AvG<)FlQo2Vyjl?h@8{QKm{YbU17aX8Svdl|L$U_#L!o%uscEWwW$mh^W?DJ9c=$B6BN0-Y+ zH7T=Yt5=Z~Ba(Bbi@{Q6W&wpU3egGIfpNXq$Cp;|YYU>EK_on~cZ2NIM@_@9_6M!> zwM&U0`VMME=HoIx8C;`a?EQ45N)=-t4@2q;3;(@|Tbi7&b6;N5VBG%uvRLLNcS$*C zLbVu9O0iZltt8RUS0=XJC&x8LqWFuzokmjqb!Zmy8PEp;^&c?CbZcidjvanF?!`Pn zJcBy~y2)40^=n)(9W&Bpy*cy$V#S~kF-o+ny$7`NF5PREMVgT&#$GT#KdlV%{?*T! zytMGKdsq}};8F)Nl=O>q>CU8`h?#yggSm--Ot)08CsJLbmVbuvFx2L!YSMY+XZQ#0 z<_&YDtLpFs1_(OFUFSxLdpJSn=d{G;T9)Yi*UX&9L2$_~h{Q{QE%8V!(Nn*l z9m$b-^bLLg%A(+>(ziuX`LlNswt0>7i(PPBN8HpQgTlkg=1`kaV+s{t%d;Lyh3Knd z)bpQPTxwuK*oS6K)1<1F7O(P-Qoq)K8NS{p$`7@h-25WCDaZW}y3<|=o9TzMS~ZA& zXX-iACu~V*3Ij+#u{O;ytv4r{3v#)N2ERzJkiAk4U(7(`(%Ojx51*ILX;xF8-y0Aq&h$ZEWhmYh#HNQ7EUbH>49UuF}eqkuL&&%m4Q`^FaLeF^8~Z^Tp@R zTSbOxyF2Ea%NZeieU-_TmCBy6OE8xi?g++c{nfs`0WCbd)rg3T9cGkgVMz?4+29pI zE;C!vBYHx&}6niNCvBz(j)%R$Z&4Hx0cbrIN`;&^Sh;^JNx&p2d={(%|*YQ z7=87AGe*a6bIc@w8?WTN%_dPb?Go==aGQ=HKDDmi<0l^>9{YTUCxwmQ&l&@!hm$H8gs)oI2(-w2u{PS1!&cP0n3;RH8sV7L1=0z?o6qJG z?+HteYJJGfWo;XnP+>RgiJ0;|kLgs98m$|0^+gDs)FfBgHRUdBGS>APxfJ)PFVUzz zTH~2ryDn`^>N{k83v%v9Z%MokdLY$9w& z(G$YdTYp6!dgUiPqAm*tj*5JVLXpumjhvsAh+~s1A6OG&PB-k3ws!AGUzg2jql2xD zW|JJ3T4(z0`q=_Vh)7hHI=1kkkfkYYE9hcGz?zB2+E_q*{&TD0d8LI@l<4)^HDjr2 zQ0PxJhuFDfoQ})be)H%b7ic}|7AKNl3iq!|%a%iBX)6iWv5Mws)3yp!)mR(4VKs{E zopl7r4Bj5!7+PY@71@OTYlC??a94z-s<`NbFQ8(DF~G?ZN6_BzRe$g87ct}Dvyhb* zlAR%i-Z0qkd9Bxas4D#9Okp1r<4Ua^J{X&?q&xh>@v6ZSGxc4RTi1V(+=w(UP?w_R zmxx$a;d$$GL3r5Xnlu^YtBkNpqWbaA?h#!49C5SS8&O*|KB9sBE7c%E=stmip_n3G zj=(YxX>3x=9^OK^c99D+BCjky0k{6u_*ZcTA#b4puLRsUV%dd@j$<~_IE;>rcr>_h zwBx>*E71n@H)qG{@ih0<6i=6uWw{_4RA3$qVjE_$84QtEnFUFDXazZ#ezDWcHdjxF z>IQpQHOqqY?aYJi#A~D+f)#B7zM<&bsq1yaNjAQi4NCL1DAMI?Q^V!i@UED~$d;1_ z1DHmGO4;cxhk|8P1R`>i!wM^Q;sCWPJC74#Gx?-sOp$(~C!gy_@rWFgdSE_Pt|U#a z7{+NbN5L)~_MYOmPGr^?DdDJ9u7(xem|NM>hT~stRcpBk>=^gL;OLUPT8#;ie?cU= zRx~kQFIyV~7*_mF6-YUpEBm&bi<3q}EW9!)OjCo&2cA3GEW9%g^>bO;fPZd^p zjp&;|L_vk|%0+JM56;%j#;oXKH?uUADYGIqU(+V)o?d0f<6P*RK?29N>w15X5dE9U-3;9<1k{$cxeo+8@)f%3B{cAg*hyuGD-^zS)XpT**Z zb5ZV-rH6VP$#62PODOP@oqfGW_Qq8#@R9tB>nIft*NSCR^EioNZ+)tJ$@`PS=`<}Q z0>nhMU!`9Oy1~UnewfT$!x?N_< zHCNWtMS$*ZT1y^rFmrV6aa?NjB8$e2S5Z^hw>EA0^4R9;I#~!3QB-jelBqAH**LEF zyhrnTAhhLT-pDf*Q0q&Rd%(8%!Rz`Wf?DfGl!mwK2dTR;B0V1y`o~_c;74Hbi!&Nb zC$R^4AXY!xmBYz%0rCqm`YQqHiD$`$AjgBxI1K1zqVZlRPH;v{RawmWvD>K$o|b)% zcUc`KgZ1xDNg}jCHTjo~Uy~DdeeZ-&nDks`jqi9l#B2$S*M|L?dxhG1lR^r9n~;!l z5^z{{$w~>eiShQ0x`xITZN*%w-hKw?Cuv?O>9!eV)F0>Pq9;1OES$$o!He~@XM0QR z8eWQ$na`r#*f;oA5gZ5=5m%BRK~L+Kq1BO!R=(ZkV2Z-_h}+NRFFCd`SPg&jG3ZSF z^!XT)g4vL9P_g;F@#1^aomDiy2Li67%RHF%MM+BymRI9<0i_v2ZX8y$;!{*oiTF1N|Isfp&x! z#0uD)eBMF?AN`j-VdU(D<_*zRX9y4l5$sBDS&&eo{%U;|(yH$lgDDs)VaY^LCh?3} zoU7y&%k#(q^Dp{89wB=1fgAkdT;!8-fn{)5VTG0~1YEe6tZ$MK0Zh7okb^)6t}B@R zn;-N{N?Eznhx+>H|5&KEu2tqiF;g@3o!seyw7%5`EKOG7Q_~D9Q4!wWcdO!`%DjOj z>NJG8Zyn)i)-DO(=%)TJSaz}s1$Bq}XeOpHnW5JnXGJ?X@~LK~#mTxH_Lm_$79TGC zr5|?d^qq)@n-vlqe_uBr@72M7QO`?kWdhid-sH1zAjUN6s}rYpPJc+|ECoc@z=BW;nbyzX?<+x}*{U)njvT-${&pTMLQG)5wEMA8xs+uzm4 zO>~f;I~6B86+MNFFy>FgmW{P)cfbI>-n&lNPwihBF51n`rX{N_?Kv>%mu=w-eH4t57b%e$no zIB`YE*m$Ue4A<<>tO;6>Up@*L=YP$yb>ESsvpeMl(88d+(AwV(0%MU z9iT$p+X0{dQXtZ-{bN`MZN98FLz)-v_iC-Rw%mW)OgleG2fNBJ1zDe^ZvIZY{%zaW zrEEEPHeCD~iHlEq*$FU{sWV|*s0Xw3jqy_O|}2{3PN6$4U^+?Ga%-^ZV&>=<@A57;NcG-M-{xXu+LOu zwvRRl+kgbg_&?4#X=bOcLFLxD_}M7PlE?<31W>kC{;yvpKBkjRD?*ki`}|P3)2^}{ z-i{5__x;bXm!tdO>Rn!-%xyIn|7M2|bd<&X6%dyW1knF+AK8U?*Lq*5o)zkiviK1K zk@$asll|q5VT8FsxDQMd4*&sp-KvJqPTFOoP(Rb4v=;M{2on*Co4=dEPM=bMUR75H%O9L%rY0X_i`|7T@5(w)wL-cbe4ohSVy49okMb8XxJ5W4<% zPni^9c1-621_+xyZAb!ymN{vIkW$5qMDm~UJ)g>$3>=b6?D}QAR#P5)rak}i%E_G5 zJWOnf6DZ0CxEUqHWnv4!fXbfUje#%$*3S56C$ap`fV$&Qwn+SZ5#=FCuVI#aJA09@ zojvc+DgW6KCkso`J2*Z{l5wzDQAvB0(0M zt3ALK(*C|eee;}^p?h$}*kP8nNn1LUe1{ug68gLAo=N3sR9y?s3s(z=Vs{zqqhh)` zE|Pu74bYJi2Atd>***Lk1z9v}9hX21AHNZq&*`@t*cXs3ILjxIsD_Oinzg;`7FNpb z`X}QPhkpCj9C2(n=n|hgzDsYQ2+;#X&&{q)x?I8i?>h1N21H_TPf#;2I@kI?Gs5Jv zR&@Mf2%hbt$R!E*XufI^mN)$D%%uTt-vM3zQqF1N19nw`$FTu5$p0c$r<9?AU9c8Kn^wFFtlDya z8*m6|Rdt-~gZYW>xG#TsC2T;2&{xsyC@Sf3J#!Iw*+<+fdV}KFN;`=S2P{^v!^%_W;E?!w7Q=Gd#1H*05(>}C{> zl?v~k_meivX=&y0ZbYP)(;MJ86g)Y1u1&2kd{XVoFC7=%4m8Tk4kWq3;hxz8Ff@6- zzk7Lueq_siyxY>$-=%wSGNJ_C)q->Vs84k6dwFdli-A}TI1@M}&zn;sNk}O{k(C$8 zqe8^vQ)*-tm%PGcYtggx1ZlJ6z+O=#wLTfURgiqbE`Rl;G8T0j^xp7pbpual_;VyjVdzvd7Ck z9C6k{a)ORI*T;{T3TC{K$QPa9O0>^l08F>%0E++dahs{T%*+T_lTSx_yr842tp({` zGh_{;Avw2r!_*;(kR`Emt<4x&dkdoTI98^}hVub#MQU^|s+;kuE)D%QHh_(xvb*Yd zg+_7a=eH8@zy`bdG3T0ke&T$Q9%I%pO((duLD+UINeX)vC_DZiLW(;88_l+NFK*In z?6^asM~-OH84YNKe%%7g8Ng=d4hLM@G06H+W+Iv?k^`B#z`B6R>p$pA5`k)%Dzfp= zB!nF&%PWq=`U~U;!iTp-p@Q7Nog9EaWF=w^7cX&}umg3o|87;>#mLZvfFUB%$F9R; zsY{F{G!-9dK87?KF?e}L`B?rcM=e`~G7nt()WodUbfpjJ95mei0jOa9hbPRcDA}Jc zg)ri4o{jc%k%@S+489#cN5!#5)l)MYWau5)vidc{$>T~U5V6PQob}qLREWqVsow85 zFiZ0_6?G=l6=_>~f_a&@&2aikfAJwbezqHb6xuloL@^$+AYEo4mTXLpQ0bI=nsDNO zp8!6CwU2?>QA>RhmsxGj*(sHq3v1S}`$3WcGG+AgYq$j3dXkV=r~veQ z7vmR>9(<;u|6T>BIW)@hNC@yZ|I2HthTZuBqv=G7U=U(Eq$>RKEb*m>E8Gyq%W9T= zDVBA9+{t82dqaGJj7WFq^h|Y}jY^c>7x$*Nb;ctO1Bau%Fv=0L%^H*eL{L>QQdEAz zC>h7Ds4Ab_OqU+%dTsou5tVW8y&D!PEr76Z=tmFF3>_nEvZwq&>My#5=mBDl=2;CgX5xzPa{C3ievZr`yZ?`!wBcpqkOOk&Bb|0Q+WY zf(H0X662xy_kMW_NtgNA%_7IQX1(i0<=gHc?~#CbKqC74jG^A-oZD$irw|u@xO$I( zdkchb6lS0EAwqt|clo>lxMDISP@AOkM`Wy_;cAr$?Y~dE3DOx9qfs!FB2s-0eVl8_ zJuHtv-|NZl5zz>6M6jqqX+6W{YL5l1i7Ghj1rjw6nw#4#+k=k(VGFQN!@G@{(-p#} zEd~~RhtTF_?hw_4mJ4r;C_5581TJLU49u7{)lNC3&i4b1nmYL}cRruvEw zNRoMYn@X>jt3s?MhlLA;>(-DC1$t7+jE7SXkttwVe^KV=Qk6PRmDS_?e6X)PU5~Met^Xm?d>@vKhuU`g4fePyV*-!!e`jz2S!#yI3b#Zo)f-dD)W({B;z-u zwMX_Z|t<9L^xfIk4L($V`02@@&;{lK} z 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

p`+!|=Y8Z9g8-(Pym2~ukf@|pjAeW7 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 L^nLa_m2dwC6L3fI literal 0 HcmV?d00001 diff --git a/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_top10_document_retrieval.png b/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_top10_document_retrieval.png new file mode 100644 index 0000000000000000000000000000000000000000..3cdeda5741d9733a03cfd1805a3d49c9aaee27bd GIT binary patch literal 27079 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 E7b6zoQUCw| literal 0 HcmV?d00001 diff --git a/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_variable_code_book_sample_page.png b/custom_nodes/red_ribbon/socialtoolkit/mermaid_charts/socialtoolkit_variable_code_book_sample_page.png new file mode 100644 index 0000000000000000000000000000000000000000..86d307e368aa1aac8704248864d2d86cbc447012 GIT binary patch literal 52509 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

>1%% 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 tuple['Document', 'Metadata', 'Vectors']: + return self._document_retrieval_from_websites.execute(domain_urls) + + def document_storage(self): + return self._document_storage.execute() + + def llm_service(self): + pass + + def control_flow(self): + pass + + +# Main function that can be called when using this as a script +def main(): + """Main function for Socialtoolkit module""" + configs = Configs() + resources = { + "document_retrieval_from_websites": DocumentRetrievalFromWebsites(resources, configs), + "document_storage": DocumentStorage(resources, configs), + "llm_service": LLMService(resources, configs), + "socialtoolkit": Socialtoolkit(resources, configs), + "codebook": Codebook(resources, configs) + } + + + print("Social Toolkit module loaded successfully") + print("Available tools:") + print("- SocialToolkitNode: Node for ComfyUI integration") + print("- SocialToolkitAPI: API for programmatic access") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/custom_nodes/red_ribbon/utils/__init__.py b/custom_nodes/red_ribbon/utils/__init__.py new file mode 100644 index 00000000..0cda8e9f --- /dev/null +++ b/custom_nodes/red_ribbon/utils/__init__.py @@ -0,0 +1,58 @@ +""" +Utility functions for Red Ribbon custom nodes +""" + +def merge_node_mappings(mappings_list): + """ + Merge multiple node class mappings into one + + Args: + mappings_list: List of (NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS) tuples + + Returns: + tuple: Combined (NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS) + """ + combined_class_mappings = {} + combined_display_mappings = {} + + for class_mapping, display_mapping in mappings_list: + combined_class_mappings.update(class_mapping) + if display_mapping: + combined_display_mappings.update(display_mapping) + + return combined_class_mappings, combined_display_mappings + +class UtilityNode: + """Node with utility functions for Red Ribbon""" + + @classmethod + def INPUT_TYPES(cls): + return { + "required": { + "mode": (["debug", "info", "log"], {"default": "info"}), + "message": ("STRING", {"multiline": True}), + }, + } + + RETURN_TYPES = ("STRING",) + FUNCTION = "log" + CATEGORY = "Red Ribbon/Utils" + + def log(self, mode, message): + # Log the message according to the specified mode + formatted = f"[{mode.upper()}] {message}" + print(formatted) + return (formatted,) + +# Dictionary of nodes to be imported by main.py +NODE_CLASS_MAPPINGS = { + "UtilityNode": UtilityNode +} + +# Add display names for the nodes +NODE_DISPLAY_NAME_MAPPINGS = { + "UtilityNode": "Red Ribbon Utility" +} + +def utils(): + return NODE_CLASS_MAPPINGS, NODE_DISPLAY_NAME_MAPPINGS \ No newline at end of file diff --git a/custom_nodes/red_ribbon/utils/utils.py b/custom_nodes/red_ribbon/utils/utils.py new file mode 100644 index 00000000..1b6b1c9f --- /dev/null +++ b/custom_nodes/red_ribbon/utils/utils.py @@ -0,0 +1,39 @@ +""" +Utils - Main entrance file for Red Ribbon utility functions +""" + +from . import UtilityNode, merge_node_mappings + +class UtilsAPI: + """API for accessing utility functionality from other modules""" + + @staticmethod + def log_message(mode, message): + """Log a message with the specified mode + + Args: + mode (str): Log mode (debug, info, log) + message (str): The message to log + + Returns: + str: Formatted log message + """ + formatted = f"[{mode.upper()}] {message}" + print(formatted) + return formatted + + @staticmethod + def combine_mappings(mappings_list): + """Wrapper for merge_node_mappings function""" + return merge_node_mappings(mappings_list) + +# Main function that can be called when using this as a script +def main(): + print("Red Ribbon Utils module loaded successfully") + print("Available tools:") + print("- UtilityNode: Node for ComfyUI integration") + print("- UtilsAPI: API for programmatic access") + print("- merge_node_mappings: Function for merging node mappings") + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/install.sh b/install.sh new file mode 100644 index 00000000..7b184272 --- /dev/null +++ b/install.sh @@ -0,0 +1,41 @@ +#!/bin/bash + +echo "Setting up the environment..." + +# Check if Python is installed +if ! command -v python3 &> /dev/null +then + echo "Python is not installed. Please install Python 3.7 or later and add it to your PATH." + exit 1 +fi + +# Check if the virtual environment already exists +if [ -d "venv" ]; then + echo "Virtual environment already exists. Skipping creation." +else + # Create a virtual environment if it doesn't exist + echo "Creating a virtual environment..." + python3 -m venv venv +fi + +# Activate the virtual environment +echo "Activating the virtual environment 'venv'..." +source venv/bin/activate + + +# Install required packages from requirements.txt +if [[ -f "requirements.txt" ]]; then + echo "Installing required packages..." + pip install -r requirements.txt +else + echo "requirements.txt not found. Skipping package installation." +fi + +if [[ -f "requirements_custom_nodes.txt" ]]; then + echo "Installing packages for custom nodes..." + pip install -r requirements_custom_nodes.txt +else + echo "requirements_custom_nodes.txt not found. Skipping package installation for custom nodes." +fi + +echo "Setup complete!" diff --git a/requirements_custom_nodes.txt b/requirements_custom_nodes.txt new file mode 100644 index 00000000..b9e59a6f --- /dev/null +++ b/requirements_custom_nodes.txt @@ -0,0 +1,52 @@ +# torch +# torchsde +# torchvision +# torchaudio +# numpy>=1.25.0 +# einops +# transformers>=4.28.1 +# tokenizers>=0.13.3 +# sentencepiece +# safetensors>=0.4.2 +# aiohttp>=3.11.8 +# yarl>=1.18.0 +# pyyaml +# Pillow +# scipy +# tqdm +# psutil + +# Custom node depdencies +tiktoken +duckdb +beautifulsoup4 +html2text +huggingface_hub +openai +pandas +pyarrow +pydantic +pytest +pytest-asyncio +requests +anthropic +aiofiles +cohere +httpx +rasterio +ComfyUI-EasyNodes +mysql-connector-python +networkx +autoscraper +backoff +playwright +PyPDF2 +pytest-playwright +matplotlib + +# non essential dependencies: +kornia>=0.7.1 +spandrel +soundfile +av + diff --git a/start.sh b/start.sh new file mode 100644 index 00000000..4fe28acf --- /dev/null +++ b/start.sh @@ -0,0 +1,22 @@ +#!/bin/bash + +# Echo to indicate start of the program +echo "STARTING PROGRAM..." + +# Activate the virtual environment +source venv/bin/activate + +# Echo to indicate the start of the Python script +echo "*** BEGIN PROGRAM ***" + +# Run the Python script +python main.py # main.py + +# Echo to indicate the end of the Python script +echo "*** END PROGRAM ***" + +# Deactivate the virtual environment +deactivate + +# Echo to indicate program completion +echo "PROGRAM EXECUTION COMPLETE."