awschain 0.1.0__tar.gz

awschain-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Kamen Sharlandjiev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

awschain-0.1.0/MANIFEST.in

@@ -0,0 +1,9 @@
+include README.md
+include requirements.txt
+recursive-include src *.py
+recursive-include src/awschain *.py
+recursive-include src/awschain/handlers *.py
+global-exclude __pycache__
+global-exclude *.py[cod]
+include src/awschain/__init__.py
+include src/awschain/handlers/__init__.py

awschain-0.1.0/PKG-INFO

@@ -0,0 +1,128 @@
+Metadata-Version: 2.1
+Name: awschain
+Version: 0.1.0
+Summary: A framework for chaining AWS services using the chain of responsibility pattern
+Home-page: https://github.com/ksharlandjiev/awschain
+Author: Kamen Sharlandjiev
+Author-email: ksharlandjiev@gmail.com
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: boto3
+Requires-Dist: python-dotenv
+
+
+# awschain
+
+`awschain` is a Python package that provides a flexible and extensible implementation of the **Chain of Responsibility** design pattern. It allows users to chain together multiple processing steps in a sequence of handlers, making it easier to create dynamic and modular processing pipelines. This package is ideal for scenarios where various operations need to be applied in sequence, such as file processing, API interactions, and data transformations.
+
+## Features
+
+- **Chain of Responsibility Pattern**: Easily define processing chains with different handlers performing specialized tasks.
+- **Modular and Extensible**: Customize the chain by adding or removing handlers as needed.
+- **Predefined Handlers**: A set of built-in handlers is provided for common tasks.
+- **Dynamic Handler Discovery**: Automatically identify and instantiate handlers using the Factory pattern.
+- **Seamless Integration**: Designed to integrate with larger applications, particularly when task delegation and flexible processing pipelines are required.
+
+## Installation
+
+You can install `awschain` directly from PyPI:
+
+```bash
+pip install awschain
+```
+
+## Usage
+
+## Example Use Case
+
+Let’s say you want to process files by first reading their content, performing a summarization using Generative AI, and then writing the results to another location. You can achieve this by defining a chain with three handlers: `LocalFileReaderHandler`, `PromptHandler`, `AmazonBedrockHandler`, and `LocalFileWriterHandler`.
+
+```python
+from awschain import HandlerFactory, ConfigLoader
+
+# Load config
+ConfigLoader.load_config("/path/to/config.yaml")
+
+# Create the handlers
+reader = HandlerFactory.get_handler("LocalFileReaderHandler")
+prompt_handler = HandlerFactory.get_handler("PromptHandler")
+transformer = HandlerFactory.get_handler("AmazonBedrockHandler")
+writer = HandlerFactory.get_handler("LocalFileWriterHandler")
+
+# Set up the chain
+reader.set_next(prompt_handler).set_next(transformer).set_next(writer)
+
+# Please store your prompt in your root of your project in prompts folder. Example: prompts/default_prompt.txt
+
+# Define the request
+request = {"file_path": "example.txt", "write_file_path": "output.txt", "prompt": "default_prompt"}
+
+# Execute the chain
+reader.handle(request)
+```
+
+### Built-in Handlers
+
+`awschain` comes with several predefined handlers that can be used right out of the box. Examples include:
+
+Readers:
+- **LocalFileReaderHandler**: Handles local audio, video, and text files for processing.
+- **S3ReaderHandler**: Manages the reading and downloading of S3 objects (files) from Amazon S3.
+= **HTTPHandler**: Generic HTTP handler that allows you to fetch HTML data from http(s) endpoints. It uses BeautifulSoup to clean HTML tags.
+
+- **PDFReaderHandler**: Extracts text from PDF documents for summarization.
+- **MicrosoftExcelReaderHandler**: Extract text from Microsoft Excel documents.
+- **MicrosoftWordReaderHandler**: Extract text from Microsoft Word documents.
+- **QuipReaderHandler**: Extract text from Quip document.
+- **YouTubeReaderHandler**: Downloads videos from YouTube URLs and extracts audio.
+
+Processors:
+- **AmazonBedrockHandler**: Summarizes text content using Amazon Bedrock.
+- **AmazonBedrockChatHandler**: Used to perform interactive chat with Amazon Bedrock using the messages API.
+- **AmazonComprehendInsightsHandler**: Extract valuable insights from your data using Amazon Comprehend NLP capabilities.
+- **AmazonComprehendPIIHandler**, **AmazonComprehendPIITokenizeHandler** and **AmazonComprehendPIIUntokenizeHandler**: Used to detect, tokenize and untokenize PII data in your text retaining the context and allowing downstream services such as Bedrock to process the data without PII.
+- **AmazonTranscriptionHandler**: Transcribes audio files into text using Amazon Transcribe.
+- **AmazonTextractHandler**: Extracts text from images such as .jpg, .png, .tiff
+- **HTMLCleanerHandler**: Used to clean HTML tags when consuming web page / HTML documents.
+- **PromptHandler**: Uses a minimalistic prompt framework - all your prompts can be stored in the prompts/ folder and you can select which prompt to use when invoking the main.py.
+
+Writers:
+- **S3WriterHandler**: Manages the uploading of of S3 objects (files) to Amazon S3.
+- **LocalFileWriterHandler**: Writes output into a local file.
+- **ClipboardWriterHandler**: Writes output into clipboard.
+
+You can also create your own custom handlers by extending the base `Handler` class.
+
+## Extending awschain
+
+If you need to add custom functionality, you can extend the framework by writing custom handlers and integrating them into the chain.
+
+To create a custom handler, simply subclass the `AbstractHandler` class and implement the `handle` method:
+
+```python
+from awschainhandlers.abstract_handler import AbstractHandler
+
+class CustomHandler(AbstractHandler):
+    def handle(self, request):
+        # Process the request
+        if request.get("custom"):
+            print("Handling custom request.")
+        # Pass to the next handler in the chain if applicable
+        return super().handle(request)
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to open an issue or submit a pull request if you have ideas to improve `awschain`.
+
+## License
+
+`awschain` is licensed under the MIT License.

awschain-0.1.0/README.md

@@ -0,0 +1,108 @@
+
+# awschain
+
+`awschain` is a Python package that provides a flexible and extensible implementation of the **Chain of Responsibility** design pattern. It allows users to chain together multiple processing steps in a sequence of handlers, making it easier to create dynamic and modular processing pipelines. This package is ideal for scenarios where various operations need to be applied in sequence, such as file processing, API interactions, and data transformations.
+
+## Features
+
+- **Chain of Responsibility Pattern**: Easily define processing chains with different handlers performing specialized tasks.
+- **Modular and Extensible**: Customize the chain by adding or removing handlers as needed.
+- **Predefined Handlers**: A set of built-in handlers is provided for common tasks.
+- **Dynamic Handler Discovery**: Automatically identify and instantiate handlers using the Factory pattern.
+- **Seamless Integration**: Designed to integrate with larger applications, particularly when task delegation and flexible processing pipelines are required.
+
+## Installation
+
+You can install `awschain` directly from PyPI:
+
+```bash
+pip install awschain
+```
+
+## Usage
+
+## Example Use Case
+
+Let’s say you want to process files by first reading their content, performing a summarization using Generative AI, and then writing the results to another location. You can achieve this by defining a chain with three handlers: `LocalFileReaderHandler`, `PromptHandler`, `AmazonBedrockHandler`, and `LocalFileWriterHandler`.
+
+```python
+from awschain import HandlerFactory, ConfigLoader
+
+# Load config
+ConfigLoader.load_config("/path/to/config.yaml")
+
+# Create the handlers
+reader = HandlerFactory.get_handler("LocalFileReaderHandler")
+prompt_handler = HandlerFactory.get_handler("PromptHandler")
+transformer = HandlerFactory.get_handler("AmazonBedrockHandler")
+writer = HandlerFactory.get_handler("LocalFileWriterHandler")
+
+# Set up the chain
+reader.set_next(prompt_handler).set_next(transformer).set_next(writer)
+
+# Please store your prompt in your root of your project in prompts folder. Example: prompts/default_prompt.txt
+
+# Define the request
+request = {"file_path": "example.txt", "write_file_path": "output.txt", "prompt": "default_prompt"}
+
+# Execute the chain
+reader.handle(request)
+```
+
+### Built-in Handlers
+
+`awschain` comes with several predefined handlers that can be used right out of the box. Examples include:
+
+Readers:
+- **LocalFileReaderHandler**: Handles local audio, video, and text files for processing.
+- **S3ReaderHandler**: Manages the reading and downloading of S3 objects (files) from Amazon S3.
+= **HTTPHandler**: Generic HTTP handler that allows you to fetch HTML data from http(s) endpoints. It uses BeautifulSoup to clean HTML tags.
+
+- **PDFReaderHandler**: Extracts text from PDF documents for summarization.
+- **MicrosoftExcelReaderHandler**: Extract text from Microsoft Excel documents.
+- **MicrosoftWordReaderHandler**: Extract text from Microsoft Word documents.
+- **QuipReaderHandler**: Extract text from Quip document.
+- **YouTubeReaderHandler**: Downloads videos from YouTube URLs and extracts audio.
+
+Processors:
+- **AmazonBedrockHandler**: Summarizes text content using Amazon Bedrock.
+- **AmazonBedrockChatHandler**: Used to perform interactive chat with Amazon Bedrock using the messages API.
+- **AmazonComprehendInsightsHandler**: Extract valuable insights from your data using Amazon Comprehend NLP capabilities.
+- **AmazonComprehendPIIHandler**, **AmazonComprehendPIITokenizeHandler** and **AmazonComprehendPIIUntokenizeHandler**: Used to detect, tokenize and untokenize PII data in your text retaining the context and allowing downstream services such as Bedrock to process the data without PII.
+- **AmazonTranscriptionHandler**: Transcribes audio files into text using Amazon Transcribe.
+- **AmazonTextractHandler**: Extracts text from images such as .jpg, .png, .tiff
+- **HTMLCleanerHandler**: Used to clean HTML tags when consuming web page / HTML documents.
+- **PromptHandler**: Uses a minimalistic prompt framework - all your prompts can be stored in the prompts/ folder and you can select which prompt to use when invoking the main.py.
+
+Writers:
+- **S3WriterHandler**: Manages the uploading of of S3 objects (files) to Amazon S3.
+- **LocalFileWriterHandler**: Writes output into a local file.
+- **ClipboardWriterHandler**: Writes output into clipboard.
+
+You can also create your own custom handlers by extending the base `Handler` class.
+
+## Extending awschain
+
+If you need to add custom functionality, you can extend the framework by writing custom handlers and integrating them into the chain.
+
+To create a custom handler, simply subclass the `AbstractHandler` class and implement the `handle` method:
+
+```python
+from awschainhandlers.abstract_handler import AbstractHandler
+
+class CustomHandler(AbstractHandler):
+    def handle(self, request):
+        # Process the request
+        if request.get("custom"):
+            print("Handling custom request.")
+        # Pass to the next handler in the chain if applicable
+        return super().handle(request)
+```
+
+## Contributing
+
+Contributions are welcome! Feel free to open an issue or submit a pull request if you have ideas to improve `awschain`.
+
+## License
+
+`awschain` is licensed under the MIT License.

awschain-0.1.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

awschain-0.1.0/requirements.txt

@@ -0,0 +1,3 @@
+requests
+boto3
+python-dotenv

awschain-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

awschain-0.1.0/setup.py

@@ -0,0 +1,39 @@
+import os
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+# Conditionally load requirements.txt if it exists
+if os.path.exists("requirements.txt"):
+    with open("requirements.txt", "r", encoding="utf-8") as f:
+        requirements = f.read().splitlines()
+else:
+    requirements = []
+
+setup(
+    name="awschain",
+    version="0.1.0",
+    author="Kamen Sharlandjiev",
+    author_email="ksharlandjiev@gmail.com",
+    description="A framework for chaining AWS services using the chain of responsibility pattern",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/ksharlandjiev/awschain",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    include_package_data=True,
+    package_data={"awschain": ["**/*.py"]},
+    zip_safe=False,
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+    ],
+    python_requires=">=3.7",
+    install_requires=requirements,  # Optional if requirements.txt doesn't exist
+    test_suite='tests',
+)

awschain-0.1.0/src/awschain/__init__.py

@@ -0,0 +1,4 @@
+from .handlers.handler_factory import HandlerFactory
+from .utils.config_loader import ConfigLoader
+
+__all__ = ['HandlerFactory', 'ConfigLoader']

awschain-0.1.0/src/awschain/example.py

@@ -0,0 +1,240 @@
+#!/opt/anaconda3/bin/python
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+import json
+import os
+import sys
+from typing import Any
+from dotenv import load_dotenv
+from handlers.handler_factory import HandlerFactory
+from .utils.config_loader import ConfigLoader
+import argparse
+
+# Load configuration
+ConfigLoader.load_config('config.yaml')
+
+# Load environment variables from .env file
+load_dotenv()
+
+def determine_input_type(file_path):
+    if "youtube" in file_path or "youtu.be" in file_path:
+        return "youtube_url"
+    elif file_path.startswith(('http')):
+        return "http"    
+    elif file_path.startswith(('s3://')):
+        return "s3"  
+    elif file_path.startswith(('quip://')):
+        return "quip"   
+    elif file_path.endswith(('.mp3', '.mp4', '.m4a', '.wav', '.flac', '.mov', '.avi')):
+        return "multimedia_file"
+    elif file_path.endswith('.pdf'):
+        return "pdf"
+    elif file_path.endswith('.docx'):
+        return "microsoft_word"
+    elif file_path.endswith(('.xlsx','.xlsm','.xltx','.xltm')):
+        return "microsoft_excel"
+    elif file_path.endswith('.pptx'):
+        return "microsoft_pp"
+    elif file_path.endswith(('.jpg', '.jpeg', '.png', '.tiff')):
+        return "image_file"    
+    elif file_path.endswith(('.txt', '.json')):
+        return "text_or_json"
+    else:
+        # Assume text
+        return "text_or_json"
+
+def construct_chain(input_type, args):
+    
+    
+    # Use if-elif-else to construct the appropriate chain. In Python 3.10 we could use match statement.
+    if input_type == "youtube_url":
+        youtube_handler = HandlerFactory.get_handler("YouTubeReaderHandler")
+        s3writer_handler = HandlerFactory.get_handler("AmazonS3WriterHandler")
+        transcription_handler = HandlerFactory.get_handler("AmazonTranscriptionHandler")
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")
+        
+        chain = youtube_handler
+        current_handler = youtube_handler.set_next(s3writer_handler).set_next(transcription_handler).set_next(local_file_writer_handler)
+    elif input_type == "multimedia_file":
+        s3writer_handler = HandlerFactory.get_handler("AmazonS3WriterHandler")
+        transcription_handler = HandlerFactory.get_handler("AmazonTranscriptionHandler")
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")
+
+        chain = s3writer_handler
+        current_handler = s3writer_handler.set_next(transcription_handler).set_next(local_file_writer_handler)
+
+    elif input_type == "multimedia_file_whisper":
+        transcription_handler = HandlerFactory.get_handler("OpenAIWhisperTranscriptionHandler")
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")
+
+        chain = transcription_handler
+        current_handler = transcription_handler.set_next(local_file_writer_handler)        
+    elif input_type == "image_file":
+        local_file_reader_handler = HandlerFactory.get_handler("LocalFileReaderHandler")
+        textract_handler = HandlerFactory.get_handler("AmazonTextractHandler")
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")
+        chain = local_file_reader_handler
+        current_handler = local_file_reader_handler.set_next(textract_handler).set_next(local_file_writer_handler)       
+    elif input_type == "pdf":
+        pdf_handler = HandlerFactory.get_handler("PDFReaderHandler")
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")
+
+        chain = pdf_handler
+        current_handler = pdf_handler.set_next(local_file_writer_handler)
+
+    elif input_type == "http":
+        http_handler = HandlerFactory.get_handler("HTTPHandler")
+        http_clean_handler = HandlerFactory.get_handler("HTMLCleanerHandler")      
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")  
+
+        chain = http_handler
+        current_handler = http_handler.set_next(http_clean_handler).set_next(local_file_writer_handler)
+    elif input_type == "text_or_json":
+        local_file_reader_handler = HandlerFactory.get_handler("LocalFileReaderHandler")
+
+        chain = local_file_reader_handler
+        current_handler = local_file_reader_handler
+    elif input_type == "s3":
+        s3reader_handler = HandlerFactory.get_handler("AmazonS3ReaderHandler")
+        # local_file_reader_handler = HandlerFactory.get_handler("LocalFileReaderHandler")
+        current_handler = chain = s3reader_handler        
+
+    elif input_type == "quip":
+        quip_reader_handler = HandlerFactory.get_handler("QuipReaderHandler")
+        http_clean_handler = HandlerFactory.get_handler("HTMLCleanerHandler")
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")
+
+        chain = quip_reader_handler
+        current_handler = quip_reader_handler.set_next(http_clean_handler).set_next(local_file_writer_handler)
+    elif input_type == "microsoft_word":
+        msword_handler = HandlerFactory.get_handler("MicrosoftWordReaderHandler")
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")
+        chain = msword_handler
+        current_handler = msword_handler.set_next(local_file_writer_handler)
+    
+    elif input_type == "microsoft_excel":
+        xls_hanlder = HandlerFactory.get_handler("MicrosoftExcelReaderHandler")
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")
+        chain = xls_hanlder
+        current_handler = xls_hanlder.set_next(local_file_writer_handler)
+    elif input_type == "microsoft_pp":
+        pp_handler = HandlerFactory.get_handler("MicrosoftPowerPointReaderHandler")
+        local_file_writer_handler = HandlerFactory.get_handler("LocalFileWriterHandler")
+        chain = pp_handler
+        current_handler = pp_handler.set_next(local_file_writer_handler)
+    else:
+        # For unsupported types, default to just summarization_handler
+        print("Unsupported file type.", input_type)
+        sys.exit(1)
+    
+    # Anonymize data?
+    anonymize = args.anonymize in (True, 'true', '1')
+    if anonymize: 
+        anonymize_handler = HandlerFactory.get_handler("AmazonComprehendPIITokenizeHandler")
+        current_handler = current_handler.set_next(anonymize_handler)
+
+    # Add the prompt and bedrock handlers.
+    prompt_handler = HandlerFactory.get_handler("PromptHandler")
+    bedrock_handler = HandlerFactory.get_handler("AmazonBedrockHandler")    
+        
+    # Determinate when / if we need to call summarization or Chat and in what order.
+    
+    if args.chat and args.chat != None: 
+        chat_handler = HandlerFactory.get_handler("AmazonBedrockChatHandler")
+        print("Enable chat", args)
+        if args.chat == 'sum_first':
+            current_handler = current_handler.set_next(prompt_handler).set_next(bedrock_handler).set_next(chat_handler)
+
+        elif args.chat == 'chat_only': 
+            current_handler = current_handler.set_next(chat_handler)
+            
+        else: 
+            current_handler = current_handler.set_next(chat_handler)
+            current_handler = current_handler.set_next(prompt_handler).set_next(bedrock_handler)
+    else: 
+        current_handler = current_handler.set_next(prompt_handler).set_next(bedrock_handler)
+    
+    # Finally, if we have tokenized the content, let's untokenize
+    if anonymize:
+        unanonymize_handler = HandlerFactory.get_handler("AmazonComprehendPIIUntokenizeHandler")
+        current_handler = current_handler.set_next(unanonymize_handler)
+
+    # Copy to clipboard?
+    clipboard = os.getenv('CLIPBOARD_COPY', 'false').lower() in ('true', '1', 't')
+    if clipboard:         
+        clipboard_handler = HandlerFactory.get_handler("ClipboardWriterHandler")
+        current_handler = current_handler.set_next(clipboard_handler)
+        print("\n\n  ================================================\n   The summary will be copied to your clipboard.\n  ================================================\n")    
+        
+    return chain
+
+def process_file(file_path, args):
+    print(f"Processing: {file_path}")
+    input_type = determine_input_type(file_path)
+    
+    handler_chain = construct_chain(input_type, args)
+
+    # Prepare the output filename with the current date and time
+    current_time = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+    local_dir = os.getenv('DIR_STORAGE', './downloads')
+    output_file = f"{local_dir}/output_{os.path.basename(file_path)}_{current_time}.txt"
+    
+    
+    request = {
+        "type": input_type,
+        "path": file_path,
+        "prompt_file_name": args.prompt_file_name,
+        "text": "",
+        "write_file_path": output_file,
+        "extract_media": True
+    }
+
+    result = handler_chain.handle(request)
+    return result
+
+
+def main():
+ # Initialize the argument parser
+    parser = argparse.ArgumentParser(description='Process input files or URLs.')
+
+    # Required positional argument for the file/URL to process
+    parser.add_argument('path', type=str, help='The path to the file, folder or URL to be processed.')
+
+    # Optional positional argument for the prompt file name, with a default value
+    parser.add_argument('prompt_file_name', nargs='?', default='default_prompt', help='The name of the prompt file. Defaults to "default_prompt" if not specified.')
+
+    # Optional flag to specify the use of a interactive chat handler
+    parser.add_argument("--chat", type=str, default=None, choices=[None, 'sum_first', 'chat_first', 'chat_only'],  help="Choose 'sum_first', 'chat_first' to summarize before chat or direct chat interaction with your original text. Select 'chat_only' if you only want to query your original text")
+
+    # Optional flag to turn off anonymization
+    parser.add_argument("--anonymize", type=str, default=True, help="Anonymize customer names before sending to the model. By default this is set to true.")
+
+    # Optional argument for config file path
+    parser.add_argument("--config", type=str, help="Path to the config file. If not provided, will search for config.yaml in the current directory and its parents.")
+
+    # Parse the command-line arguments
+    args = parser.parse_args()
+
+    # Load configuration
+    from awschain.utils.config_loader import ConfigLoader
+    ConfigLoader.load_config(args.config)
+
+    # Handler discovery
+    HandlerFactory.discover_handlers()
+ 
+    if os.path.isdir(args.path):
+        max_processes = int(ConfigLoader.get_config('MAX_PARALLEL_PROCESSES', 1))
+        with ThreadPoolExecutor(max_workers=max_processes) as executor:
+            futures = [executor.submit(process_file, os.path.join(args.path, f), args) for f in os.listdir(args.path) if os.path.isfile(os.path.join(args.path, f))]
+            for future in as_completed(futures):
+                result = future.result()
+    else:
+        result = process_file(args.path, args)
+
+    if result.get("text", None):
+        print(result.get("text"))
+    else:
+        print(json.dumps(result, indent=2))
+
+if __name__ == "__main__":
+    main()

awschain-0.1.0/src/awschain/handlers/__init__.py

@@ -0,0 +1,5 @@
+from .handler_factory import HandlerFactory
+from .abstract_handler import AbstractHandler
+from .base_handler import BaseHandler
+
+__all__ = ['HandlerFactory', 'AbstractHandler', 'BaseHandler']

awschain-0.1.0/src/awschain/handlers/abstract_handler.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+from abc import abstractmethod
+from typing import Any
+from .base_handler import BaseHandler
+
+class AbstractHandler(BaseHandler):
+    """
+    The default chaining behavior can be implemented inside a base handler
+    class.
+    """
+
+    _next_handler: Handler = None
+
+    def set_next(self, handler: Handler) -> Handler:
+        self._next_handler = handler
+        # Returning a handler from here will let us link handlers in a
+        # convenient way like this:
+        # local_file_handler.set_next(prompt_handler).set_next(summarization_handler)
+        return handler
+
+    @abstractmethod
+    def handle(self, request: dict) -> dict:
+        if self._next_handler:
+            return self._next_handler.handle(request)
+
+        return request

awschain-0.1.0/src/awschain/handlers/base_handler.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import Optional
+
+class BaseHandler(ABC):
+    """
+    The Handler interface declares a method for building the chain of handlers.
+    It also declares a method for executing a request.
+    """
+
+    @abstractmethod
+    def set_next(self, handler: Handler) -> Handler:
+        pass
+
+    @abstractmethod
+    def handle(self, request) -> Optional[dict]:
+        pass