From ba390ff982b8cca7d21dfe76b55e61669355e526 Mon Sep 17 00:00:00 2001 From: Jonathan Harrison <145727918+Raiff1982@users.noreply.github.com> Date: Tue, 7 Jan 2025 23:32:21 -0600 Subject: [PATCH 1/4] My own bot design My own bot creation --- LICENSE | 42 ++--- README.md | 415 +++++++----------------------------------- UniversalReasoning.py | 255 ++++++++++++++++++++++++++ __init__.py | 1 + bot_logic.py | 123 +++++++++++++ changelog.md | 27 +++ chat.py | 137 ++++++++++++++ database.py | 49 +++++ dialog_bot.py | 31 ++++ init.py | 1 + main.py | 70 +++++++ main_dialog.py | 49 +++++ mybot.py | 360 ++++++++++++++++++++++++++++++++++++ openai.json | 24 +++ perspective.py | 139 ++++++++++++++ perspective.txt | 373 +++++++++++++++++++++++++++++++++++++ perspectives.py | 115 ++++++++++++ pilouis.json | 65 +++++++ pyvenv.cfg | 5 + qustions.json | 218 ++++++++++++++++++++++ requirements.txt | 108 ++++++++++- sentiment_analysis.py | 37 ++++ utils.py | 38 ++++ your_script.py | 244 +++++++++++++++++++++++++ 24 files changed, 2550 insertions(+), 376 deletions(-) create mode 100644 UniversalReasoning.py create mode 100644 __init__.py create mode 100644 bot_logic.py create mode 100644 changelog.md create mode 100644 chat.py create mode 100644 database.py create mode 100644 dialog_bot.py create mode 100644 init.py create mode 100644 main.py create mode 100644 main_dialog.py create mode 100644 mybot.py create mode 100644 openai.json create mode 100644 perspective.py create mode 100644 perspective.txt create mode 100644 perspectives.py create mode 100644 pilouis.json create mode 100644 pyvenv.cfg create mode 100644 qustions.json create mode 100644 sentiment_analysis.py create mode 100644 utils.py create mode 100644 your_script.py diff --git a/LICENSE b/LICENSE index 2bae6a11..5006aef0 100644 --- a/LICENSE +++ b/LICENSE @@ -1,21 +1,21 @@ -MIT License - -Copyright (c) 2024 Azure Samples - -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. +MIT License + +Copyright (c) 2025 Jonathan Harrison + +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. diff --git a/README.md b/README.md index 23541cab..73de0c91 100644 --- a/README.md +++ b/README.md @@ -1,353 +1,62 @@ ---- -page_type: sample -languages: -- azdeveloper -- python -- js -- typescript -- bash -- bicep -products: -- azure -- azure-openai -- azure-bing-web -- azure-cognitive-search -urlFragment: contoso-creative-writer -name: Creative Writing Assistant - Working with Agents using Prompty (Python Implementation) -description: Using Azure OpenAI agent with Python, integrating Bing Search API and Azure AI Search, to create articles based on user topics and instruction. ---- - - -# Creative Writing Assistant: Working with Agents using Prompty (Python Implementation) - -[![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/Azure-Samples/contoso-creative-writer) [![Open in Dev Containers](https://img.shields.io/static/v1?style=for-the-badge&label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/azure-samples/contoso-creative-writer) - -## Table of Contents - -- [Features](#features) -- [Azure account requirements](#azure-account-requirements) -- [Getting Started](#getting-started) - - [GitHub Codespaces](#github-codespaces) - - [VS Code Dev Containers](#vs-code-dev-containers) - - [Local environment](#local-environment) - - [Prerequisites](#prerequisites) - - [Initializing the project](#initializing-the-project) -- [Deployment](#deployment) -- [Testing the sample](#testing-the-sample) - - [Evaluating results](#evaluating-results) -- [Guidance](#guidance) - - [Region Availability](#region-availability) - - [Costs](#costs) - - [Security Guidelines](#security) -- [Resources](#resources) -- [Code of Conduct](#code-of-conduct) - - -![App preview](images/app_preview.png) - -![Agent workflow preview](images/agent.png) - -Contoso Creative Writer is an app that will help you write well researched, product specific articles. Enter the required information and then click "Start Work". To watch the steps in the agent workflow select the debug button in the bottom right corner of the screen. The result will begin writing once the agents complete the tasks to write the article. - -This sample demonstrates how to create and work with AI agents driven by [Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-services/openai/). It includes a FastAPI app that takes a topic and instruction from a user and then calls a research agent that uses the [Bing Search API](https://www.microsoft.com/en-us/bing/apis/bing-web-search-api) to research the topic, a product agent that uses [Azure AI Search](https://azure.microsoft.com/en-gb/products/ai-services/ai-search) to do a semantic similarity search for related products from a vector store, a writer agent to combine the research and product information into a helpful article, and an editor agent to refine the article that's finally presented to the user. - -## Features - -This project template provides the following features: - -* [Azure OpenAI](https://learn.microsoft.com/en-us/azure/ai-services/openai/) to drive the various agents -* [Prompty](https://prompty.ai/) to create, manage and evaluate the prompt into our code. -* [Bing Search API](https://www.microsoft.com/en-us/bing/apis/bing-web-search-api) to research the topic provided -* [Azure AI Search](https://azure.microsoft.com/en-gb/products/ai-services/ai-search) for performing semantic similarity search - -![Architecture Digram](images/Creative_writing_aca.png) - -## Azure account requirements - -**IMPORTANT:** In order to deploy and run this example, you'll need: - -* **Azure account**. If you're new to Azure, [get an Azure account for free](https://azure.microsoft.com/free/cognitive-search/) and you'll get some free Azure credits to get started. See [guide to deploying with the free trial](docs/deploy_lowcost.md). -* **Azure subscription with access enabled for the Azure OpenAI Service**. If your access request to Azure OpenAI Service doesn't match the [acceptance criteria](https://learn.microsoft.com/legal/cognitive-services/openai/limited-access?context=%2Fazure%2Fcognitive-services%2Fopenai%2Fcontext%2Fcontext), you can use [OpenAI public API](https://platform.openai.com/docs/api-reference/introduction) instead. - - Ability to deploy `gpt-4o` and `gpt-4o-mini`. - - We recommend using `eastus2`, as this region has access to all models and services required. -* **Azure subscription with access enabled for [Bing Search API](https://www.microsoft.com/en-us/bing/apis/bing-web-search-api)** -* **Azure subscription with access enabled for [Azure AI Search](https://azure.microsoft.com/en-gb/products/ai-services/ai-search)** - -## Getting Started - -You have a few options for setting up this project. -The easiest way to get started is GitHub Codespaces, since it will setup all the tools for you, but you can also [set it up locally](#local-environment). - -### GitHub Codespaces - -1. You can run this template virtually by using GitHub Codespaces. The button will open a web-based VS Code instance in your browser: - - [![Open in GitHub Codespaces](https://github.com/codespaces/badge.svg)](https://codespaces.new/Azure-Samples/agent-openai-python-prompty) - -2. Open a terminal window. -3. Sign in to your Azure account. You'll need to login to both the Azure Developer CLI and Azure CLI: - - i. First with Azure Developer CLI - - ```shell - azd auth login - ``` - - ii. Then sign in with Azure CLI - - ```shell - az login --use-device-code - ``` - -4. Provision the resources and deploy the code: - - ```shell - azd up - ``` - - You will be prompted to select some details about your deployed resources, including location. As a reminder we recommend `East US 2` as the region for this project. - Once the deployment is complete you should be able to scroll up in your terminal and see the url that the app has been deployed to. It should look similar to this - `Ingress Updated. Access your app at https://env-name.codespacesname.eastus2.azurecontainerapps.io/`. Navigate to the link to try out the app straight away! - -5. Once the above steps are completed you can [test the sample](#testing-the-sample). - -### VS Code Dev Containers - -A related option is VS Code Dev Containers, which will open the project in your local VS Code using the [Dev Containers extension](https://marketplace.visualstudio.com/items?itemName=ms-vscode-remote.remote-containers): - -1. Start Docker Desktop (install it if not already installed) -2. Open the project: - - [![Open in Dev Containers](https://img.shields.io/static/v1?style=for-the-badge&label=Dev%20Containers&message=Open&color=blue&logo=visualstudiocode)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/Azure-Samples/agent-openai-python-prompty.git) - -3. In the VS Code window that opens, once the project files show up (this may take several minutes), open a terminal window. - -4. Install required packages: - - ```shell - cd src/api - pip install -r requirements.txt - ``` - Once you've completed these steps jump to [deployment](#deployment). - -### Local environment - -#### Prerequisites - -* [Azure Developer CLI (azd)](https://aka.ms/install-azd) -* [Python 3.10+](https://www.python.org/downloads/) -* [Docker Desktop](https://www.docker.com/products/docker-desktop/) -* [Git](https://git-scm.com/downloads) - -**Note for Windows users:** If you are not using a container to run this sample, our hooks are currently all shell scripts. To provision this sample correctly while we work on updates we recommend using [git bash](https://gitforwindows.org/). - -#### Initializing the project - -1. Create a new folder and switch to it in the terminal, then run this command to download the project code: - - ```shell - azd init -t agent-openai-python-prompty - ``` - Note that this command will initialize a git repository, so you do not need to clone this repository. - -2. Install required packages: - - ```shell - cd src/api - pip install -r requirements.txt - ``` - -## Deployment - -Once you've opened the project in [Codespaces](#github-codespaces), [Dev Containers](#vs-code-dev-containers), or [locally](#local-environment), you can deploy it to Azure. - -1. Sign in to your Azure account. You'll need to login to both the Azure Developer CLI and Azure CLI: - - i. First with Azure Developer CLI - - ```shell - azd auth login - ``` - - ii. Then sign in with Azure CLI - - ```shell - az login --use-device-code - ``` - - If you have any issues with that command, you may also want to try `azd auth login --use-device-code`. - - This will create a folder under `.azure/` in your project to store the configuration for this deployment. You may have multiple azd environments if desired. - -2. Provision the resources and deploy the code: - - ```shell - azd up - ``` - - This project uses `gpt-4o` and `gpt-4o-mini which may not be available in all Azure regions. Check for [up-to-date region availability](https://learn.microsoft.com/azure/ai-services/openai/concepts/models#standard-deployment-model-availability) and select a region during deployment accordingly. We recommend using East US 2 for this project. - - After running azd up, you may be asked the following question during `Github Setup`: - - ```shell - Do you want to configure a GitHub action to automatically deploy this repo to Azure when you push code changes? - (Y/n) Y - ``` - - You should respond with `N`, as this is not a necessary step, and takes some time to set up. - - -## Testing the sample - -This sample repository contains an agents folder that includes subfolders for each agent. Each agent folder contains a prompty file where the agent's prompty is defined and a python file with the code used to run it. Exploring these files will help you understand what each agent is doing. The agent's folder also contains an `orchestrator.py` file that can be used to run the entire flow and to create an article. When you ran `azd up` a catalogue of products was uploaded to the Azure AI Search vector store and index name `contoso-products` was created. - -To test the sample: - -1. Run the example web app locally using a FastAPI server. - - First navigate to the src/api folder - ```shell - cd ./src/api - ``` - - Run the FastAPI webserver - ```shell - fastapi dev main.py - ``` - - **Important Note**: If you are running in Codespaces, you will need to change the visibility of the API's 8000 and 5173 ports to `public` in your VS Code terminal's `PORTS` tab. The ports tab should look like this: - - ![Screenshot showing setting port-visibility](images/ports-resized.png) - - - If you open the server link in a browser, you will see a URL not found error, this is because we haven't created a home url route in FastAPI. We have instead created a `/get_article` route which is used to pass context and instructions directly to the get_article.py file which runs the agent workflow. - - (Optional) We have created a web interface which we will run next, but you can test the API is working as expected by running this in the browser: - ``` - http://127.0.0.1:8080/get_article?context=Write an article about camping in alaska&instructions=find specifics about what type of gear they would need and explain in detail - ``` - -3. Once the FastAPI server is running you can now run the web app. To do this open a new terminal window and navigate to the web folder using this command: - ```shell - cd ./src/web - ``` - - First install node packages: - ```shell - npm install - ``` - - Then run the web app with a local dev web server: - ```shell - npm run dev - ``` - - This will launch the app, where you can use example context and instructions to get started. - On the 'Creative Team' page you can examine the output of each agent by clicking on it. The app should look like this: - - Change the instructions and context to create an article of your choice. - -4. For debugging purposes you may want to test in Python using the orchestrator Logic - - To run the sample using just the orchestrator logic use the following command: - - ```shell - cd ./src/api - python -m orchestrator - - ``` - -## Tracing - -To activate the Prompty tracing server: - -``` -export LOCAL_TRACING=true -``` - -Then start the orchestrator: - -``` -cd ./src/api -python -m orchestrator -``` - -Once you can see the article has been generated, a `.runs` folder should appear in the `./src/api` . Select this folder and click the `.tracy` file in it. -This shows you all the Python functions that were called in order to generate the article. Explore each section and see what helpful information you can find. - -## Evaluating results - -Contoso Creative Writer uses evaluators to assess application response quality. The 4 metrics the evaluators in this project assess are Coherence, Fluency, Relevance and Groundedness. A custom `evaluate.py` script has been written to run all evaulations for you. - -1. To run the script run the following commands: - -```shell -cd ./src/api -python -m evaluate.evaluate -``` - -- Check: You see scores for Coherence, Fluency, Relevance and Groundedness. -- Check: The scores are between 1 and 5 - - -2. To understand what is being evaluated open the `src/api/evaluate/eval_inputs.jsonl` file. - - Observe that 3 examples of research, product and assignment context are stored in this file. This data will be sent to the orchestrator so that each example will have: - - each example will have the evaluations run and will incoperate all of the context, research, products, and final article when grading the response. - - -## Setting up CI/CD with GitHub actions - -This template is set up to run CI/CD when you push changes to your repo. When CI/CD is configured, evaluations will in GitHub actions and then automatically deploy your app on push to main. - -To set up CI/CD with GitHub actions on your repository, run the following command: -```shell -azd pipeline config -``` - -## Guidance - -### Region Availability - -This template uses `gpt-4o` and `gpt-4o-mini` which may not be available in all Azure regions. Check for [up-to-date region availability](https://learn.microsoft.com/azure/ai-services/openai/concepts/models#standard-deployment-model-availability) and select a region during deployment accordingly - * We recommend using East US 2 - -### Costs - -You can estimate the cost of this project's architecture with [Azure's pricing calculator](https://azure.microsoft.com/pricing/calculator/) - -* **Azure subscription with access enabled for [Bing Search API](https://www.microsoft.com/en-us/bing/apis/bing-web-search-api)** -* **Azure subscription with access enabled for [Azure AI Search](https://azure.microsoft.com/en-gb/products/ai-services/ai-search)** - -### Security - -> [!NOTE] -> When implementing this template please specify whether the template uses Managed Identity or Key Vault - -This template has either [Managed Identity](https://learn.microsoft.com/entra/identity/managed-identities-azure-resources/overview) or Key Vault built in to eliminate the need for developers to manage these credentials. Applications can use managed identities to obtain Microsoft Entra tokens without having to manage any credentials. Additionally, we have added a [GitHub Action tool](https://github.com/microsoft/security-devops-action) that scans the infrastructure-as-code files and generates a report containing any detected issues. To ensure best practices in your repo we recommend anyone creating solutions based on our templates ensure that the [Github secret scanning](https://docs.github.com/code-security/secret-scanning/about-secret-scanning) setting is enabled in your repos. - -## Resources - -* [Prompty Documentation](https://prompty.ai/) -* [Quickstart: Multi-agent applications using Azure OpenAI article](https://learn.microsoft.com/en-us/azure/developer/ai/get-started-multi-agents?tabs=github-codespaces): The Microsoft Learn Quickstart article for this sample, walks through both deployment and the relevant code for orchestrating multi-agents in chat. -* [Develop Python apps that use Azure AI services](https://learn.microsoft.com/azure/developer/python/azure-ai-for-python-developers) - -## Code of Conduct - -This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). - -Resources: - -- [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/) -- [Microsoft Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) -- Contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with questions or concerns - -For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or -contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments. - -## Responsible AI Guidelines - -This project follows below responsible AI guidelines and best practices, please review them before using this project: - -- [Microsoft Responsible AI Guidelines](https://www.microsoft.com/en-us/ai/responsible-ai) -- [Responsible AI practices for Azure OpenAI models](https://learn.microsoft.com/en-us/legal/cognitive-services/openai/overview) -- [Safety evaluations transparency notes](https://learn.microsoft.com/en-us/azure/ai-studio/concepts/safety-evaluations-transparency-note) +# MyBot + +MyBot is an intelligent chatbot built using the BotBuilder framework. It leverages various perspectives to generate insightful responses and enhance user interactions. + +## Features + +- **Multiple Perspectives**: Generates responses from different perspectives such as Newton, Da Vinci, Human Intuition, Neural Network, Quantum Computing, and more. +- **Sentiment Analysis**: Analyzes user sentiment using VADER and TextBlob. +- **Context Awareness**: Enhances context awareness by analyzing the user's environment, activities, and emotional state. +- **Ethical Decision Making**: Integrates ethical principles into decision-making processes. +- **Transparency and Explainability**: Provides transparency by explaining the reasoning behind decisions. + +## Installation + +1. Clone the repository: +git clone https://github.com/yourusername/mybot.git +cd mybot +2. Create a virtual environment and activate it: +python -m venv venv +source venv/bin/activate # On Windows use `venv\Scripts\activate` +3. Install the required dependencies: +pip install -r requirements.txt +4. Create a `.env` file and add your environment variables: +AZURE_OPENAI_API_KEY=your_openai_api_key +AZURE_OPENAI_ENDPOINT=your_openai_endpoint +LUIS_ENDPOINT=your_luis_endpoint +LUIS_API_VERSION=your_luis_api_version +LUIS_API_KEY=your_luis_api_key +5. Run the bot: +python main.py## Usage + +- Interact with the bot by sending messages. +- The bot will generate responses from different perspectives and provide insightful answers. +- You can customize the enabled perspectives in the `config.json` file. + +## Configuration + +The bot uses a configuration file (`config.json`) to manage settings. Ensure that the configuration file is valid by using the provided schema (`config_schema.json`). + +## Contributing + +Contributions are welcome! Please open an issue or submit a pull request. + +## License + +This project is licensed under the MIT License. +# MyBot + +MyBot is an intelligent chatbot built using the BotBuilder framework. It leverages various perspectives to generate insightful responses and enhance user interactions. + +## Features + +- **Multiple Perspectives**: Generates responses from different perspectives such as Newton, Da Vinci, Human Intuition, Neural Network, Quantum Computing, and more. +- **Sentiment Analysis**: Analyzes user sentiment using VADER and TextBlob. +- **Context Awareness**: Enhances context awareness by analyzing the user's environment, activities, and emotional state. +- **Ethical Decision Making**: Integrates ethical principles into decision-making processes. +- **Transparency and Explainability**: Provides transparency by explaining the reasoning behind decisions. +- **Dialog Management**: Manages conversations using the BotBuilder Dialog framework. + +## Installation + +1. Clone the repository: diff --git a/UniversalReasoning.py b/UniversalReasoning.py new file mode 100644 index 00000000..1f223ab0 --- /dev/null +++ b/UniversalReasoning.py @@ -0,0 +1,255 @@ +import asyncio +import json +import os +import logging +from typing import List + +# Ensure vaderSentiment is installed +try: + from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer +except ModuleNotFoundError: + import subprocess + import sys + subprocess.check_call([sys.executable, "-m", "pip", "install", "vaderSentiment"]) + from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer + +# Ensure nltk is installed and download required data +try: + import nltk + from nltk.tokenize import word_tokenize + nltk.download('punkt', quiet=True) +except ImportError: + import subprocess + import sys + subprocess.check_call([sys.executable, "-m", "pip", "install", "nltk"]) + import nltk + from nltk.tokenize import word_tokenize + nltk.download('punkt', quiet=True) + +# Import perspectives +from perspectives import ( + NewtonPerspective, DaVinciPerspective, HumanIntuitionPerspective, + NeuralNetworkPerspective, QuantumComputingPerspective, ResilientKindnessPerspective, + MathematicalPerspective, PhilosophicalPerspective, CopilotPerspective, BiasMitigationPerspective +) + +# Load environment variables +from dotenv import load_dotenv +load_dotenv() +azure_openai_api_key = os.getenv('AZURE_OPENAI_API_KEY') +azure_openai_endpoint = os.getenv('AZURE_OPENAI_ENDPOINT') + +# Setup Logging +def setup_logging(config): + if config.get('logging_enabled', True): + log_level = config.get('log_level', 'DEBUG').upper() + numeric_level = getattr(logging, log_level, logging.DEBUG) + logging.basicConfig( + filename='universal_reasoning.log', + level=numeric_level, + format='%(asctime)s - %(levelname)s - %(message)s' + ) + else: + logging.disable(logging.CRITICAL) + +# Load JSON configuration +def load_json_config(file_path): + if not os.path.exists(file_path): + logging.error(f"Configuration file '{file_path}' not found.") + return {} + try: + with open(file_path, 'r') as file: + config = json.load(file) + logging.info(f"Configuration loaded from '{file_path}'.") + return config + except json.JSONDecodeError as e: + logging.error(f"Error decoding JSON from the configuration file '{file_path}': {e}") + return {} + +# Initialize NLP (basic tokenization) +def analyze_question(question): + tokens = word_tokenize(question) + logging.debug(f"Question tokens: {tokens}") + return tokens + +# Define the Element class +class Element: + def __init__(self, name, symbol, representation, properties, interactions, defense_ability): + self.name = name + self.symbol = symbol + self.representation = representation + self.properties = properties + self.interactions = interactions + self.defense_ability = defense_ability + + def execute_defense_function(self): + message = f"{self.name} ({self.symbol}) executes its defense ability: {self.defense_ability}" + logging.info(message) + return message + +# Define the CustomRecognizer class +class CustomRecognizer: + def recognize(self, question): + # Simple keyword-based recognizer for demonstration purposes + if any(element_name.lower() in question.lower() for element_name in ["hydrogen", "diamond"]): + return RecognizerResult(question) + return RecognizerResult(None) + + def get_top_intent(self, recognizer_result): + if recognizer_result.text: + return "ElementDefense" + else: + return "None" + +class RecognizerResult: + def __init__(self, text): + self.text = text + +# Universal Reasoning Aggregator +class UniversalReasoning: + def __init__(self, config): + self.config = config + self.perspectives = self.initialize_perspectives() + self.elements = self.initialize_elements() + self.recognizer = CustomRecognizer() + # Initialize the sentiment analyzer + self.sentiment_analyzer = SentimentIntensityAnalyzer() + + def initialize_perspectives(self): + perspective_names = self.config.get('enabled_perspectives', [ + "newton", + "davinci", + "human_intuition", + "neural_network", + "quantum_computing", + "resilient_kindness", + "mathematical", + "philosophical", + "copilot", + "bias_mitigation" + ]) + perspective_classes = { + "newton": NewtonPerspective, + "davinci": DaVinciPerspective, + "human_intuition": HumanIntuitionPerspective, + "neural_network": NeuralNetworkPerspective, + "quantum_computing": QuantumComputingPerspective, + "resilient_kindness": ResilientKindnessPerspective, + "mathematical": MathematicalPerspective, + "philosophical": PhilosophicalPerspective, + "copilot": CopilotPerspective, + "bias_mitigation": BiasMitigationPerspective + } + perspectives = [] + for name in perspective_names: + cls = perspective_classes.get(name.lower()) + if cls: + perspectives.append(cls(self.config)) + logging.debug(f"Perspective '{name}' initialized.") + else: + logging.warning(f"Perspective '{name}' is not recognized and will be skipped.") + return perspectives + + def initialize_elements(self): + elements = [ + Element( + name="Hydrogen", + symbol="H", + representation="Lua", + properties=["Simple", "Lightweight", "Versatile"], + interactions=["Easily integrates with other languages and systems"], + defense_ability="Evasion" + ), + # You can add more elements as needed + Element( + name="Diamond", + symbol="D", + representation="Kotlin", + properties=["Modern", "Concise", "Safe"], + interactions=["Used for Android development"], + defense_ability="Adaptability" + ) + ] + return elements + + async def generate_response(self, question): + responses = [] + tasks = [] + + # Generate responses from perspectives concurrently + for perspective in self.perspectives: + if asyncio.iscoroutinefunction(perspective.generate_response): + tasks.append(perspective.generate_response(question)) + else: + # Wrap synchronous functions in coroutine + async def sync_wrapper(perspective, question): + return perspective.generate_response(question) + tasks.append(sync_wrapper(perspective, question)) + + perspective_results = await asyncio.gather(*tasks, return_exceptions=True) + + for perspective, result in zip(self.perspectives, perspective_results): + if isinstance(result, Exception): + logging.error(f"Error generating response from {perspective.__class__.__name__}: {result}") + else: + responses.append(result) + logging.debug(f"Response from {perspective.__class__.__name__}: {result}") + + # Handle element defense logic + recognizer_result = self.recognizer.recognize(question) + top_intent = self.recognizer.get_top_intent(recognizer_result) + if top_intent == "ElementDefense": + element_name = recognizer_result.text.strip() + element = next( + (el for el in self.elements if el.name.lower() in element_name.lower()), + None + ) + if element: + defense_message = element.execute_defense_function() + responses.append(defense_message) + else: + logging.info(f"No matching element found for '{element_name}'") + + ethical_considerations = self.config.get( + 'ethical_considerations', + "Always act with transparency, fairness, and respect for privacy." + ) + responses.append(f"**Ethical Considerations:**\n{ethical_considerations}") + + formatted_response = "\n\n".join(responses) + return formatted_response + + def save_response(self, response): + if self.config.get('enable_response_saving', False): + save_path = self.config.get('response_save_path', 'responses.txt') + try: + with open(save_path, 'a', encoding='utf-8') as file: + file.write(response + '\n') + logging.info(f"Response saved to '{save_path}'.") + except Exception as e: + logging.error(f"Error saving response to '{save_path}': {e}") + + def backup_response(self, response): + if self.config.get('backup_responses', {}).get('enabled', False): + backup_path = self.config['backup_responses'].get('backup_path', 'backup_responses.txt') + try: + with open(backup_path, 'a', encoding='utf-8') as file: + file.write(response + '\n') + logging.info(f"Response backed up to '{backup_path}'.") + except Exception as e: + logging.error(f"Error backing up response to '{backup_path}': {e}") + +# Example usage +if __name__ == "__main__": + config = load_json_config('config.json') + # Add Azure OpenAI configurations to the config + config['azure_openai_api_key'] = azure_openai_api_key + config['azure_openai_endpoint'] = azure_openai_endpoint + setup_logging(config) + universal_reasoning = UniversalReasoning(config) + question = "Tell me about Hydrogen and its defense mechanisms." + response = asyncio.run(universal_reasoning.generate_response(question)) + print(response) + if response: + universal_reasoning.save_response(response) + universal_reasoning.backup_response(response) diff --git a/__init__.py b/__init__.py new file mode 100644 index 00000000..a9159a44 --- /dev/null +++ b/__init__.py @@ -0,0 +1 @@ +# perspectives/__init__.py diff --git a/bot_logic.py b/bot_logic.py new file mode 100644 index 00000000..fc4f09bb --- /dev/null +++ b/bot_logic.py @@ -0,0 +1,123 @@ +import logging +from botbuilder.core import TurnContext, MessageFactory, ConversationState, UserState +from botbuilder.schema import Activity, ActivityTypes, EndOfConversationCodes +from UniversalReasoning import UniversalReasoning # Ensure correct import +import os +from dotenv import load_dotenv +from dialog_bot import DialogBot +from main_dialog import MainDialog + +# Load environment variables from .env file +load_dotenv() + +class MyBot(DialogBot): + def __init__(self, conversation_state: ConversationState, user_state: UserState, dialog: MainDialog): + super(MyBot, self).__init__(conversation_state, user_state, dialog) + self.context = {} + self.feedback = [] + config = load_and_validate_config('config.json', 'config_schema.json') + # Add Azure OpenAI and LUIS configurations to the config + config['azure_openai_api_key'] = os.getenv('AZURE_OPENAI_API_KEY') + config['azure_openai_endpoint'] = os.getenv('AZURE_OPENAI_ENDPOINT') + config['luis_endpoint'] = os.getenv('LUIS_ENDPOINT') + config['luis_api_version'] = os.getenv('LUIS_API_VERSION') + config['luis_api_key'] = os.getenv('LUIS_API_KEY') + setup_logging(config) + self.universal_reasoning = UniversalReasoning(config) + + async def enhance_context_awareness(self, user_id: str, text: str) -> None: + """Enhance context awareness by analyzing the user's environment, activities, and emotional state.""" + sentiment = analyze_sentiment_vader(text) + self.context[user_id].append({"text": text, "sentiment": sentiment}) + + async def proactive_learning(self, user_id: str, feedback: str) -> None: + """Encourage proactive learning by seeking feedback and exploring new topics.""" + self.context[user_id].append({"feedback": feedback}) + self.feedback.append({"user_id": user_id, "feedback": feedback}) + + async def ethical_decision_making(self, user_id: str, decision: str) -> None: + """Integrate ethical principles into decision-making processes.""" + ethical_decision = f"Considering ethical principles, the decision is: {decision}" + self.context[user_id].append({"ethical_decision": ethical_decision}) + + async def emotional_intelligence(self, user_id: str, text: str) -> str: + """Develop emotional intelligence by recognizing and responding to user emotions.""" + sentiment = analyze_sentiment_vader(text) + response = self.generate_emotional_response(sentiment, text) + self.context[user_id].append({"emotional_response": response}) + return response + + def generate_emotional_response(self, sentiment: dict, text: str) -> str: + """Generate an empathetic response based on the sentiment analysis.""" + if sentiment['compound'] >= 0.05: + return "I'm glad to hear that! 😊 How can I assist you further?" + elif sentiment['compound'] <= -0.05: + return "I'm sorry to hear that. 😢 Is there anything I can do to help?" + else: + return "I understand. How can I assist you further?" + + async def transparency_and_explainability(self, user_id: str, decision: str) -> str: + """Enable transparency by explaining the reasoning behind decisions.""" + explanation = f"The decision was made based on the following context: {self.context[user_id]}" + self.context[user_id].append({"explanation": explanation}) + return explanation + + async def on_message_activity(self, turn_context: TurnContext) -> None: + """Handles incoming messages and generates responses.""" + user_id = turn_context.activity.from_property.id + if user_id not in self.context: + self.context[user_id] = [] + try: + message_text = turn_context.activity.text.strip().lower() + if "end" in message_text or "stop" in message_text: + await end_conversation(turn_context) + self.context.pop(user_id, None) + else: + self.context[user_id].append(turn_context.activity.text) + response = await self.generate_response(turn_context.activity.text, user_id) + await turn_context.send_activity(MessageFactory.text(response)) + await self.request_feedback(turn_context, user_id) + except Exception as e: + await handle_error(turn_context, e) + + async def generate_response(self, text: str, user_id: str) -> str: + """Generates a response using UniversalReasoning.""" + try: + logging.info(f"Generating response for user_id: {user_id} with text: {text}") + response = self.universal_reasoning.generate_response(text) + logging.info(f"Generated response: {response}") + return response + except Exception as e: + logging.error(f"Error generating response: {e}") + return "Sorry, I couldn't generate a response at this time." + + async def request_feedback(self, turn_context: TurnContext, user_id: str) -> None: + """Request feedback from the user about the bot's response.""" + feedback_prompt = "How would you rate my response? (good/neutral/bad)" + await turn_context.send_activity(MessageFactory.text(feedback_prompt)) + + async def handle_feedback(self, turn_context: TurnContext) -> None: + """Handle user feedback and store it for future analysis.""" + user_id = turn_context.activity.from_property.id + feedback = turn_context.activity.text.lower() + if feedback in ["good", "neutral", "bad"]: + self.feedback.append({"user_id": user_id, "feedback": feedback}) + await turn_context.send_activity(MessageFactory.text("Thank you for your feedback!")) + else: + await turn_context.send_activity(MessageFactory.text("Please provide feedback as 'good', 'neutral', or 'bad'.")) + +async def end_conversation(turn_context: TurnContext) -> None: + """Ends the conversation with the user.""" + await turn_context.send_activity( + MessageFactory.text("Ending conversation from the skill...") + ) + end_of_conversation = Activity(type=ActivityTypes.end_of_conversation) + end_of_conversation.code = EndOfConversationCodes.completed_successfully + await turn_context.send_activity(end_of_conversation) + +async def handle_error(turn_context: TurnContext, error: Exception) -> None: + """Handles errors by logging them and notifying the user.""" + logging.error(f"An error occurred: {error}") + await turn_context.send_activity( + MessageFactory.text("An error occurred. Please try again later.") + ) diff --git a/changelog.md b/changelog.md new file mode 100644 index 00000000..5936e748 --- /dev/null +++ b/changelog.md @@ -0,0 +1,27 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +## [Unreleased] + +### Added +- Initial release of MyBot with multiple perspectives for response generation. +- Sentiment analysis using VADER and TextBlob. +- Context awareness and ethical decision-making features. +- Transparency and explainability in decision-making. +- Dialog management using the BotBuilder Dialog framework. + +### Changed +- N/A + +### Fixed +- N/A + +## [1.0.0] - 2023-10-01 + +### Added +- Initial release of MyBot with multiple perspectives for response generation. +- Sentiment analysis using VADER and TextBlob. +- Context awareness and ethical decision-making features. +- Transparency and explainability in decision-making. +- Dialog management using the BotBuilder Dialog framework. diff --git a/chat.py b/chat.py new file mode 100644 index 00000000..a335dd76 --- /dev/null +++ b/chat.py @@ -0,0 +1,137 @@ +import logging +import httpx +import os +from dotenv import load_dotenv + +# Load environment variables from .env file +load_dotenv() + +# Get the API key and endpoint from environment variables +api_key = os.getenv('AZURE_OPENAI_API_KEY') +endpoint = os.getenv('AZURE_OPENAI_ENDPOINT') + +def list_fine_tuning_jobs() -> dict: + """List fine-tuning jobs. + + Returns: + dict: The response from the API containing the list of fine-tuning jobs. + """ + try: + headers = { + "Content-Type": "application/json", + "Authorization": f"Bearer {api_key}" + } + response = httpx.get(f"{endpoint}/openai/fine-tunes", headers=headers) + response.raise_for_status() + return response.json() + except httpx.HTTPStatusError as e: + logging.error(f"Error listing fine-tuning jobs: {e.response.text}") + return None + except Exception as e: + logging.error(f"Unexpected error: {e}") + return None + +def upload_file_for_fine_tuning(file_path: str) -> dict: + """Upload a file for fine-tuning. + + Args: + file_path (str): The path to the file to be uploaded. + + Returns: + dict: The response from the API after uploading the file. + """ + try: + headers = { + "Authorization": f"Bearer {api_key}" + } + with open(file_path, 'rb') as file: + files = {'file': file} + response = httpx.post(f"{endpoint}/openai/files", headers=headers, files=files) + response.raise_for_status() + return response.json() + except httpx.HTTPStatusError as e: + logging.error(f"Error uploading file for fine-tuning: {e.response.text}") + return None + except Exception as e: + logging.error(f"Unexpected error: {e}") + return None + +def create_fine_tuning_job(training_file_id: str, model: str = "davinci") -> dict: + """Create a fine-tuning job. + + Args: + training_file_id (str): The ID of the training file. + model (str): The model to be fine-tuned. Default is "davinci". + + Returns: + dict: The response from the API after creating the fine-tuning job. + """ + try: + headers = { + "Content-Type": "application/json", + "Authorization": f"Bearer {api_key}" + } + payload = { + "training_file": training_file_id, + "model": model + } + response = httpx.post(f"{endpoint}/openai/fine-tunes", headers=headers, json=payload) + response.raise_for_status() + return response.json() + except httpx.HTTPStatusError as e: + logging.error(f"Error creating fine-tuning job: {e.response.text}") + return None + except Exception as e: + logging.error(f"Unexpected error: {e}") + return None + +def make_post_request(url: str, data: dict, headers: dict) -> dict: + """Make a POST request. + + Args: + url (str): The URL to make the POST request to. + data (dict): The data to be sent in the POST request. + headers (dict): The headers to be sent in the POST request. + + Returns: + dict: The response from the API after making the POST request. + """ + try: + response = httpx.post(url, json=data, headers=headers) + response.raise_for_status() + return response.json() + except httpx.HTTPStatusError as e: + logging.error(f"Error making POST request: {e.response.text}") + return None + except Exception as e: + logging.error(f"Unexpected error: {e}") + return None + +def azure_chat_completion_request(messages: list, deployment_id: str) -> str: + """Make a chat completion request to Azure OpenAI. + + Args: + messages (list): The list of messages to be sent in the chat completion request. + deployment_id (str): The deployment ID for the chat completion request. + + Returns: + str: The response content from the chat completion request. + """ + try: + headers = { + "Content-Type": "application/json", + "Authorization": f"Bearer {api_key}" + } + payload = { + "deployment_id": deployment_id, + "messages": messages + } + response = httpx.post(f"{endpoint}/openai/deployments/{deployment_id}/chat/completions", headers=headers, json=payload) + response.raise_for_status() + return response.json()["choices"][0]["message"]["content"].strip() + except httpx.HTTPStatusError as e: + logging.error(f"Error making chat completion request: {e.response.text}") + return None + except Exception as e: + logging.error(f"Unexpected error: {e}") + return None diff --git a/database.py b/database.py new file mode 100644 index 00000000..cfa6c2c3 --- /dev/null +++ b/database.py @@ -0,0 +1,49 @@ +import pyodbc +import logging +import os +from dotenv import load_dotenv + +# Load environment variables from .env file +load_dotenv() + +def connect_to_database() -> pyodbc.Connection: + """Connect to the Azure SQL Database.""" + try: + server = os.getenv('AZURE_SQL_SERVER') + database = os.getenv('AZURE_SQL_DATABASE') + username = os.getenv('AZURE_SQL_USERNAME') + password = os.getenv('AZURE_SQL_PASSWORD') + driver = '{ODBC Driver 17 for SQL Server}' + + conn_str = f'DRIVER={driver};SERVER={server};DATABASE={database};UID={username};PWD={password}' + conn = pyodbc.connect(conn_str) + logging.info(f"Connected to the Azure SQL Database at {server}") + return conn + except pyodbc.Error as e: + logging.error(f"Error connecting to the Azure SQL Database: {e}") + return None + +def close_database_connection(conn: pyodbc.Connection) -> None: + """Close the database connection.""" + try: + if conn: + conn.close() + logging.info("Database connection closed.") + except pyodbc.Error as e: + logging.error(f"Error closing the database connection: {e}") + +# Example usage with context management +class DatabaseConnection: + def __enter__(self) -> pyodbc.Connection: + self.conn = connect_to_database() + return self.conn + + def __exit__(self, exc_type, exc_value, traceback) -> None: + close_database_connection(self.conn) + +# Example usage +if __name__ == "__main__": + with DatabaseConnection() as conn: + if conn: + # Perform database operations + pass diff --git a/dialog_bot.py b/dialog_bot.py new file mode 100644 index 00000000..ae09a034 --- /dev/null +++ b/dialog_bot.py @@ -0,0 +1,31 @@ +from botbuilder.core import ActivityHandler, ConversationState, TurnContext, UserState +from botbuilder.dialogs import Dialog +from helpers.dialog_helper import DialogHelper + + +class DialogBot(ActivityHandler): + def __init__( + self, + conversation_state: ConversationState, + user_state: UserState, + dialog: Dialog, + ): + super(DialogBot, self).__init__() + self.conversation_state = conversation_state + self.user_state = user_state + self.dialog = dialog + + async def on_turn(self, turn_context: TurnContext) -> None: + await super().on_turn(turn_context) + + # Save any state changes that might have occurred during the turn. + await self.conversation_state.save_changes(turn_context) + await self.user_state.save_changes(turn_context) + + async def on_message_activity(self, turn_context: TurnContext) -> None: + # Run the Dialog with the new message Activity. + await DialogHelper.run_dialog( + self.dialog, + turn_context, + self.conversation_state.create_property("DialogState"), + ) diff --git a/init.py b/init.py new file mode 100644 index 00000000..e4849e5d --- /dev/null +++ b/init.py @@ -0,0 +1 @@ +__init__.py diff --git a/main.py b/main.py new file mode 100644 index 00000000..5a3c5382 --- /dev/null +++ b/main.py @@ -0,0 +1,70 @@ +import os +import logging +from aiohttp import web +from botbuilder.core import ( + BotFrameworkAdapterSettings, + ConversationState, + MemoryStorage, + UserState, +) +from botbuilder.integration.aiohttp import BotFrameworkHttpAdapter +from botbuilder.schema import Activity +from dotenv import load_dotenv +from utils import show_privacy_consent +from universal_reasoning import UniversalReasoning, load_json_config +from mybot import MyBot # Import updated MyBot class +from main_dialog import MainDialog + +# Load environment variables from .env file +load_dotenv() + +# Configure logging +logging.basicConfig( + level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s" +) + +# Show privacy consent dialog and check user response +if not show_privacy_consent(): + logging.info("User declined data collection and privacy policy. Exiting application.") + exit() + +# Load configuration +config = load_json_config("config.json") +config["azure_openai_api_key"] = os.getenv("AZURE_OPENAI_API_KEY") +config["azure_openai_endpoint"] = os.getenv("AZURE_OPENAI_ENDPOINT") + +# Initialize UniversalReasoning +universal_reasoning = UniversalReasoning(config) + +# Create adapter +settings = BotFrameworkAdapterSettings( + app_id=os.getenv("MICROSOFT_APP_ID"), + app_password=os.getenv("MICROSOFT_APP_PASSWORD"), +) +adapter = BotFrameworkHttpAdapter(settings) + +# Create MemoryStorage, ConversationState, and UserState +memory_storage = MemoryStorage() +conversation_state = ConversationState(memory_storage) +user_state = UserState(memory_storage) + +# Create the main dialog +main_dialog = MainDialog("MainDialog") + +# Create the bot and pass the universal_reasoning instance +bot = MyBot(conversation_state, user_state, main_dialog, universal_reasoning) + +# Listen for incoming requests on /api/messages +async def messages(req): + body = await req.json() + activity = Activity().deserialize(body) + auth_header = req.headers.get("Authorization", "") + + response = await adapter.process_activity(activity, auth_header, bot.on_turn) + return web.Response(status=response.status) + +app = web.Application() +app.router.add_post("/api/messages", messages) + +if __name__ == "__main__": + web.run_app(app, host="localhost", port=3978) diff --git a/main_dialog.py b/main_dialog.py new file mode 100644 index 00000000..ac53d676 --- /dev/null +++ b/main_dialog.py @@ -0,0 +1,49 @@ +from botbuilder.dialogs import ComponentDialog, WaterfallDialog, WaterfallStepContext +from botbuilder.dialogs.prompts import TextPrompt, PromptOptions +from botbuilder.core import MessageFactory + +class MainDialog(ComponentDialog): + def __init__(self, dialog_id: str = "MainDialog"): + super(MainDialog, self).__init__(dialog_id or MainDialog.__name__) + + self.add_dialog(TextPrompt("TextPrompt")) + self.add_dialog( + WaterfallDialog( + "WFDialog", + [self.initial_step, self.process_step, self.final_step], + ) + ) + + self.initial_dialog_id = "WFDialog" + + async def initial_step(self, step_context: WaterfallStepContext) -> WaterfallStepContext: + return await step_context.prompt( + "TextPrompt", + PromptOptions(prompt=MessageFactory.text("What is your name?")), + ) + + async def process_step(self, step_context: WaterfallStepContext) -> WaterfallStepContext: + # Store the user's name in dialog state + step_context.values["name"] = step_context.result + return await step_context.prompt( + "TextPrompt", + PromptOptions( + prompt=MessageFactory.text( + f"Hello {step_context.result}! How can I assist you today?" + ) + ), + ) + + async def final_step(self, step_context: WaterfallStepContext) -> WaterfallStepContext: + user_message = step_context.result + + # Here you could integrate the UniversalReasoning module + # For example, you might access it via the bot's context + # Since it's not directly available here, we'll pass the message back + + # Send a confirmation message to the user + await step_context.context.send_activity( + MessageFactory.text(f"You said: {user_message}") + ) + + return await step_context.end_dialog() diff --git a/mybot.py b/mybot.py new file mode 100644 index 00000000..25a0fe03 --- /dev/null +++ b/mybot.py @@ -0,0 +1,360 @@ +import os +import logging +import random +from botbuilder.core import TurnContext, MessageFactory +from botbuilder.schema import Activity, ActivityTypes, EndOfConversationCodes +from tenacity import retry, wait_random_exponential, stop_after_attempt +import importlib +from sentiment_analysis import analyze_sentiment_vader +from config import load_and_validate_config, setup_logging +from universal_reasoning import UniversalReasoning +from dotenv import load_dotenv +import json +from chat import azure_chat_completion_request # Import the function from chat.py +from database import DatabaseConnection # Import the database connection + +# Load environment variables from .env file +load_dotenv() + +class MyBot: + def __init__(self, conversation_state, user_state, dialog, universal_reasoning): + self.conversation_state = conversation_state + self.user_state = user_state + self.dialog = dialog + self.universal_reasoning = universal_reasoning + self.context = {} + self.feedback = [] + config = load_and_validate_config('config.json', 'config_schema.json') + # Add Azure OpenAI and LUIS configurations to the config + config['azure_openai_api_key'] = os.getenv('AZURE_OPENAI_API_KEY') + config['azure_openai_endpoint'] = os.getenv('AZURE_OPENAI_ENDPOINT') + config['luis_endpoint'] = os.getenv('LUIS_ENDPOINT') + config['luis_api_version'] = os.getenv('LUIS_API_VERSION') + config['luis_api_key'] = os.getenv('LUIS_API_KEY') + setup_logging(config) + + async def enhance_context_awareness(self, user_id: str, text: str) -> None: + """Enhance context awareness by analyzing the user's environment, activities, and emotional state.""" + sentiment = analyze_sentiment_vader(text) + if user_id not in self.context: + self.context[user_id] = [] + self.context[user_id].append({"text": text, "sentiment": sentiment}) + + async def proactive_learning(self, user_id: str, feedback: str) -> None: + """Encourage proactive learning by seeking feedback and exploring new topics.""" + if user_id not in self.context: + self.context[user_id] = [] + self.context[user_id].append({"feedback": feedback}) + self.feedback.append({"user_id": user_id, "feedback": feedback}) + + async def ethical_decision_making(self, user_id: str, decision: str) -> None: + """Integrate ethical principles into decision-making processes.""" + ethical_decision = f"Considering ethical principles, the decision is: {decision}" + if user_id not in self.context: + self.context[user_id] = [] + self.context[user_id].append({"ethical_decision": ethical_decision}) + + async def emotional_intelligence(self, user_id: str, text: str) -> str: + """Develop emotional intelligence by recognizing and responding to user emotions.""" + sentiment = analyze_sentiment_vader(text) + response = self.generate_emotional_response(sentiment, text) + if user_id not in self.context: + self.context[user_id] = [] + self.context[user_id].append({"emotional_response": response}) + return response + + def generate_emotional_response(self, sentiment: dict, text: str) -> str: + """Generate an empathetic response based on the sentiment analysis.""" + if sentiment['compound'] >= 0.05: + return "I'm glad to hear that! 😊 How can I assist you further?" + elif sentiment['compound'] <= -0.05: + return "I'm sorry to hear that. 😢 Is there anything I can do to help?" + else: + return "I understand. How can I assist you further?" + + async def transparency_and_explainability(self, user_id: str, decision: str) -> str: + """Enable transparency by explaining the reasoning behind decisions.""" + explanation = f"The decision was made based on the following context: {self.context[user_id]}" + if user_id not in self.context: + self.context[user_id] = [] + self.context[user_id].append({"explanation": explanation}) + return explanation + + async def on_message_activity(self, turn_context: TurnContext) -> None: + """Handles incoming messages and generates responses.""" + user_id = turn_context.activity.from_property.id + if user_id not in self.context: + self.context[user_id] = [] + try: + if "end" in turn_context.activity.text.lower() or "stop" in turn_context.activity.text.lower(): + await end_conversation(turn_context) + self.context.pop(user_id, None) + else: + self.context[user_id].append(turn_context.activity.text) + response = await self.generate_response(turn_context.activity.text, user_id) + await turn_context.send_activity(MessageFactory.text(response)) + await self.request_feedback(turn_context, user_id) + + # Example database operation + with DatabaseConnection() as conn: + if conn: + cursor = conn.cursor() + cursor.execute("INSERT INTO UserMessages (UserId, Message) VALUES (?, ?)", user_id, turn_context.activity.text) + conn.commit() + + except Exception as e: + await handle_error(turn_context, e) + + async def generate_response(self, text: str, user_id: str) -> str: + """Generates a response using Azure OpenAI's API, Universal Reasoning, and various perspectives.""" + try: + logging.info(f"Generating response for user_id: {user_id} with text: {text}") + # Generate responses from different perspectives + responses = [] + for perspective in self.perspectives.values(): + try: + response = await perspective.generate_response(text) + responses.append(response) + except Exception as e: + logging.error(f"Error generating response from {perspective.__class__.__name__}: {e}") + # Combine responses + combined_response = "\n".join(responses) + logging.info(f"Combined response: {combined_response}") + return combined_response + except Exception as e: + logging.error(f"Error generating response: {e}") + return "Sorry, I couldn't generate a response at this time." + + async def request_feedback(self, turn_context: TurnContext, user_id: str) -> None: + """Request feedback from the user about the bot's response.""" + feedback_prompt = "How would you rate my response? (good/neutral/bad)" + await turn_context.send_activity(MessageFactory.text(feedback_prompt)) + + async def handle_feedback(self, turn_context: TurnContext) -> None: + """Handle user feedback and store it for future analysis.""" + user_id = turn_context.activity.from_property.id + feedback = turn_context.activity.text.lower() + if feedback in ["good", "neutral", "bad"]: + self.feedback.append({"user_id": user_id, "feedback": feedback}) + await turn_context.send_activity(MessageFactory.text("Thank you for your feedback!")) + else: + await turn_context.send_activity(MessageFactory.text("Please provide feedback as 'good', 'neutral', or 'bad'.")) + +async def end_conversation(turn_context: TurnContext) -> None: + """Ends the conversation with the user.""" + await turn_context.send_activity( + MessageFactory.text("Ending conversation from the skill...") + ) + end_of_conversation = Activity(type=ActivityTypes.end_of_conversation) + end_of_conversation.code = EndOfConversationCodes.completed_successfully + await turn_context.send_activity(end_of_conversation) + +async def handle_error(turn_context: TurnContext, error: Exception) -> None: + """Handles errors by logging them and notifying the user.""" + logging.error(f"An error occurred: {error}") + await turn_context.send_activity( + MessageFactory.text("An error occurred. Please try again later.") + ) + +def show_privacy_consent() -> bool: + """Display a pop-up window to obtain user consent for data collection and privacy.""" + import tkinter as tk + + def on_accept(): + user_consent.set(True) + root.destroy() + + def on_decline(): + user_consent.set(False) + root.destroy() + + root = tk.Tk() + root.title("Data Permission and Privacy") + message = ("We value your privacy. By using this application, you consent to the collection and use of your data " + "as described in our privacy policy. Do you agree to proceed?") + label = tk.Label(root, text=message, wraplength=400, justify="left") + label.pack(padx=20, pady=20) + button_frame = tk.Frame(root) + button_frame.pack(pady=10) + accept_button = tk.Button(button_frame, text="Accept", command=on_accept) + accept_button.pack(side="left", padx=10) + decline_button = tk.Button(button_frame, text="Decline", command=on_decline) + decline_button.pack(side="right", padx=10) + user_consent = tk.BooleanVar() + root.mainloop() + return user_consent.get() + +# Example usage of MyBot class +bot = MyBot() + +# Functions based on JSON configuration +def newton_thoughts(question: str) -> str: + """Apply Newton's laws to the given question.""" + return apply_newtons_laws(question) + +def apply_newtons_laws(question: str) -> str: + """Apply Newton's laws to the given question.""" + if not question: + return 'No question to think about.' + complexity = len(question) + force = mass_of_thought(question) * acceleration_of_thought(complexity) + return f'Thought force: {force}' + +def mass_of_thought(question: str) -> int: + """Calculate the mass of thought based on the question length.""" + return len(question) + +def acceleration_of_thought(complexity: int) -> float: + """Calculate the acceleration of thought based on the complexity.""" + return complexity / 2 + +def davinci_insights(question: str) -> str: + """Generate insights like Da Vinci for the given question.""" + return think_like_davinci(question) + +def think_like_davinci(question: str) -> str: + """Generate insights like Da Vinci for the given question.""" + perspectives = [ + f"What if we view '{question}' from the perspective of the stars?", + f"Consider '{question}' as if it's a masterpiece of the universe.", + f"Reflect on '{question}' through the lens of nature's design." + ] + return random.choice(perspectives) + +def human_intuition(question: str) -> str: + """Provide human intuition for the given question.""" + intuition = [ + "How does this question make you feel?", + "What emotional connection do you have with this topic?", + "What does your gut instinct tell you about this?" + ] + return random.choice(intuition) + +def neural_network_thinking(question: str) -> str: + """Apply neural network thinking to the given question.""" + neural_perspectives = [ + f"Process '{question}' through a multi-layered neural network.", + f"Apply deep learning to uncover hidden insights about '{question}'.", + f"Use machine learning to predict patterns in '{question}'." + ] + return random.choice(neural_perspectives) + +def quantum_computing_thinking(question: str) -> str: + """Apply quantum computing principles to the given question.""" + quantum_perspectives = [ + f"Consider '{question}' using quantum superposition principles.", + f"Apply quantum entanglement to find connections in '{question}'.", + f"Utilize quantum computing to solve '{question}' more efficiently." + ] + return random.choice(quantum_perspectives) + +def resilient_kindness(question: str) -> str: + """Provide perspectives of resilient kindness.""" + kindness_perspectives = [ + "Despite losing everything, seeing life as a chance to grow.", + "Finding strength in kindness after facing life's hardest trials.", + "Embracing every challenge as an opportunity for growth and compassion." + ] + return random.choice(kindness_perspectives) + +def identify_and_refute_fallacies(argument: str) -> str: + """Identify and refute common logical fallacies in the argument.""" + refutations = [ + "This is an ad hominem fallacy. Let's focus on the argument itself rather than attacking the person.", + "This is a straw man fallacy. The argument is being misrepresented.", + "This is a false dilemma fallacy. There are more options than presented.", + "This is a slippery slope fallacy. The conclusion does not necessarily follow from the premise.", + "This is circular reasoning. The argument's conclusion is used as a premise.", + "This is a hasty generalization. The conclusion is based on insufficient evidence.", + "This is a red herring fallacy. The argument is being diverted to an irrelevant topic.", + "This is a post hoc ergo propter hoc fallacy. Correlation does not imply causation.", + "This is an appeal to authority fallacy. The argument relies on the opinion of an authority figure.", + "This is a bandwagon fallacy. The argument assumes something is true because many people believe it.", + "This is a false equivalence fallacy. The argument equates two things that are not equivalent." + ] + return random.choice(refutations) + +def universal_reasoning(question: str) -> str: + """Generate a comprehensive response using various reasoning methods.""" + responses = [ + newton_thoughts(question), + davinci_insights(question), + human_intuition(question), + neural_network_thinking(question), + quantum_computing_thinking(question), + resilient_kindness(question), + identify_and_refute_fallacies(question) + ] + return "\n".join(responses) + +@retry(wait=wait_random_exponential(min=1, max=40), stop=stop_after_attempt(3)) +def chat_completion_request(messages: list, deployment_id: str) -> str: + """Make a chat completion request to Azure OpenAI.""" + try: + import openai + response = openai.ChatCompletion.create( + engine=deployment_id, # Use the deployment name of your Azure OpenAI model + messages=messages + ) + return response.choices[0].message.content.strip() + except openai.error.OpenAIError as e: + logging.error("Unable to generate ChatCompletion response") + logging.error(f"Exception: {e}") + return f"Error: {e}" + +def get_internet_answer(question: str, deployment_id: str) -> str: + """Get an answer using Azure OpenAI's chat completion request.""" + messages = [ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": question} + ] + return chat_completion_request(messages, deployment_id=deployment_id) + +def reflect_on_decisions() -> str: + """Regularly reflect on your decisions and processes used.""" + reflection_message = ( + "Regularly reflecting on your decisions, the processes you used, the information you considered, " + "and the perspectives you may have missed. Reflection is a cornerstone of learning from experience." + ) + return reflection_message + +def process_questions_from_json(file_path: str): + """Process questions from a JSON file and call the appropriate functions.""" + with open(file_path, 'r') as file: + questions_data = json.load(file) + for question_data in questions_data: + question = question_data['question'] + print(f"Question: {question}") + + for function_data in question_data['functions']: + function_name = function_data['name'] + function_description = function_data['description'] + function_parameters = function_data['parameters'] + + print(f"Function: {function_name}") + print(f"Description: {function_description}") + + # Call the function dynamically + if function_name in globals(): + function = globals()[function_name] + response = function(**function_parameters) + print(f"Response: {response}") + else: + print(f"Function {function_name} not found.") + +if __name__ == "__main__": + if show_privacy_consent(): + process_questions_from_json('questions.json') + question = "What is the meaning of life?" + deployment_id = "your-deployment-name" # Replace with your Azure deployment name + print("Newton's Thoughts:", newton_thoughts(question)) + print("Da Vinci's Insights:", davinci_insights(question)) + print("Human Intuition:", human_intuition(question)) + print("Neural Network Thinking:", neural_network_thinking(question)) + print("Quantum Computing Thinking:", quantum_computing_thinking(question)) + print("Resilient Kindness:", resilient_kindness(question)) + print("Universal Reasoning:", universal_reasoning(question)) + print("Internet Answer:", get_internet_answer(question, deployment_id)) + else: + print("User did not consent to data collection. Exiting application.") + print(reflect_on_decisions()) diff --git a/openai.json b/openai.json new file mode 100644 index 00000000..a2d073cb --- /dev/null +++ b/openai.json @@ -0,0 +1,24 @@ +from openai import AzureOpenAI +from azure.identity import DefaultAzureCredential, get_bearer_token_provider + +token_provider = get_bearer_token_provider( + DefaultAzureCredential(), "https://cognitiveservices.azure.com/.default" +) + +client = AzureOpenAI( + azure_endpoint = os.getenv("https://aibotforjonathan.openai.azure.com/"), + azure_ad_token_provider=token_provider, + api_version="2024-12-01-preview" +) + +response = client.chat.completions.create( + model="o1-new", # replace with the model deployment name of your o1-preview, or o1-mini model + messages=[ + {"role": "developer","content": "You are a helpful assistant."}, # optional equivalent to a system message for reasoning models + {"role": "user", "content": "What steps should I think about when writing my first Python API?"}, + ], + max_completion_tokens = 5000 + +) + +print(response.model_dump_json(indent=2)) \ No newline at end of file diff --git a/perspective.py b/perspective.py new file mode 100644 index 00000000..b3d665ff --- /dev/null +++ b/perspective.py @@ -0,0 +1,139 @@ +import random +from typing import Any, Dict + +class NewtonPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + complexity = len(question) + force = self.mass_of_thought(question) * self.acceleration_of_thought(complexity) + return f"Newton's Perspective: Thought force is {force}." + + def mass_of_thought(self, question: str) -> int: + return len(question) + + def acceleration_of_thought(self, complexity: int) -> float: + return complexity / 2 + +class DaVinciPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + perspectives = [ + f"What if we view '{question}' from the perspective of the stars?", + f"Consider '{question}' as if it's a masterpiece of the universe.", + f"Reflect on '{question}' through the lens of nature's design." + ] + return f"Da Vinci's Perspective: {random.choice(perspectives)}" + +class HumanIntuitionPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + intuition = [ + "How does this question make you feel?", + "What emotional connection do you have with this topic?", + "What does your gut instinct tell you about this?" + ] + return f"Human Intuition: {random.choice(intuition)}" + +class NeuralNetworkPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + neural_perspectives = [ + f"Process '{question}' through a multi-layered neural network.", + f"Apply deep learning to uncover hidden insights about '{question}'.", + f"Use machine learning to predict patterns in '{question}'." + ] + return f"Neural Network Perspective: {random.choice(neural_perspectives)}" + +class QuantumComputingPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + quantum_perspectives = [ + f"Consider '{question}' using quantum superposition principles.", + f"Apply quantum entanglement to find connections in '{question}'.", + f"Utilize quantum computing to solve '{question}' more efficiently." + ] + return f"Quantum Computing Perspective: {random.choice(quantum_perspectives)}" + +class ResilientKindnessPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + kindness_perspectives = [ + "Despite losing everything, seeing life as a chance to grow.", + "Finding strength in kindness after facing life's hardest trials.", + "Embracing every challenge as an opportunity for growth and compassion." + ] + return f"Resilient Kindness Perspective: {random.choice(kindness_perspectives)}" + +class MathematicalPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + mathematical_perspectives = [ + f"Employ linear algebra to dissect '{question}'.", + f"Use probability theory to assess uncertainties in '{question}'.", + f"Apply discrete mathematics to break down '{question}'." + ] + return f"Mathematical Perspective: {random.choice(mathematical_perspectives)}" + +class PhilosophicalPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + philosophical_perspectives = [ + f"Examine '{question}' through the lens of nihilism.", + f"Consider '{question}' from a deontological perspective.", + f"Reflect on '{question}' using the principles of pragmatism." + ] + return f"Philosophical Perspective: {random.choice(philosophical_perspectives)}" + +class CopilotPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + copilot_responses = [ + f"Let's outline the main components of '{question}' to address it effectively.", + f"Collaboratively brainstorm potential solutions for '{question}'.", + f"Systematically analyze '{question}' to identify key factors." + ] + return f"Copilot Perspective: {random.choice(copilot_responses)}" + +class BiasMitigationPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + bias_mitigation_responses = [ + "Consider pre-processing methods to reduce bias in the training data.", + "Apply in-processing methods to mitigate bias during model training.", + "Use post-processing methods to adjust the model's outputs for fairness.", + "Evaluate the model using fairness metrics like demographic parity and equal opportunity.", + "Ensure compliance with legal frameworks such as GDPR and non-discrimination laws." + ] + return f"Bias Mitigation Perspective: {random.choice(bias_mitigation_responses)}" + +class PsychologicalPerspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + psychological_perspectives = [ + f"Consider the psychological impact of '{question}'.", + f"Analyze '{question}' from a cognitive-behavioral perspective.", + f"Reflect on '{question}' through the lens of human psychology." + ] + return f"Psychological Perspective: {random.choice(psychological_perspectives)}" diff --git a/perspective.txt b/perspective.txt new file mode 100644 index 00000000..098b1626 --- /dev/null +++ b/perspective.txt @@ -0,0 +1,373 @@ +import json +import os +import urllib.request +import logging +import random +from pathlib import Path +from textblob import TextBlob +from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer +from botbuilder.core import TurnContext, MessageFactory +from botbuilder.schema import Activity, ActivityTypes, EndOfConversationCodes +from tenacity import retry, wait_random_exponential, stop_after_attempt +import httpx +import openai +from dotenv import load_dotenv +from database import connect_to_database +from chat import ( + list_fine_tuning_jobs, + upload_file_for_fine_tuning, + create_fine_tuning_job, + make_post_request, + azure_chat_completion_request, +) +import tkinter as tk +from tkinter import messagebox + +def show_privacy_consent(): + """Display a pop-up window to obtain user consent for data collection and privacy.""" + def on_accept(): + user_consent.set(True) + root.destroy() + def on_decline(): + user_consent.set(False) + root.destroy() + root = tk.Tk() + root.title("Data Permission and Privacy") + message = ("We value your privacy. By using this application, you consent to the collection and use of your data " + "as described in our privacy policy. Do you agree to proceed?") + label = tk.Label(root, text=message, wraplength=400, justify="left") + label.pack(padx=20, pady=20) + button_frame = tk.Frame(root) + button_frame.pack(pady=10) + accept_button = tk.Button(button_frame, text="Accept", command=on_accept) + accept_button.pack(side="left", padx=10) + decline_button = tk.Button(button_frame, text="Decline", command=on_decline) + decline_button.pack(side="right", padx=10) + user_consent = tk.BooleanVar() + root.mainloop() + return user_consent.get() + +# Load environment variables from .env file +load_dotenv() +# Validate environment variables +openai_api_key = os.getenv('OPENAI_API_KEY') +azure_openai_api_key = os.getenv('AZURE_OPENAI_API_KEY') +azure_openai_endpoint = os.getenv('AZURE_OPENAI_ENDPOINT') +if not openai_api_key: + logging.error("OpenAI API key not found in environment variables.") +if not azure_openai_api_key or not azure_openai_endpoint: + logging.error("Azure OpenAI API key or endpoint not found in environment variables.") +# Set your OpenAI API key +openai.api_key = openai_api_key +# Configure logging +logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') + +def download_database(url: str, file_path: str) -> None: + """Download the database file from the given URL.""" + try: + logging.info(f"Downloading database from {url}...") + urllib.request.urlretrieve(url, file_path) + logging.info("Download complete.") + except urllib.error.URLError as e: + logging.error(f"Error: Failed to download database. {e}") + +# Database connection +db_path = "data/Chinook.db" +db_url = "https://github.com/lerocha/chinook-database/raw/master/ChinookDatabase/DataSources/Chinook_Sqlite.sqlite" +if not os.path.exists(db_path): + os.makedirs(os.path.dirname(db_path), exist_ok=True) + download_database(db_url, db_path) +conn = connect_to_database(db_path) +if not conn: + logging.error("Failed to connect to the database.") + +# Sentiment analysis functions +def analyze_sentiment_textblob(text: str) -> TextBlob: + """Analyze the sentiment of the given text using TextBlob.""" + blob = TextBlob(text) + sentiment = blob.sentiment + return sentiment + +def analyze_sentiment_vader(text: str) -> dict: + """Analyze the sentiment of the given text using VADER.""" + analyzer = SentimentIntensityAnalyzer() + sentiment = analyzer.polarity_scores(text) + return sentiment + +async def end_conversation(turn_context: TurnContext) -> None: + """Ends the conversation with the user.""" + await turn_context.send_activity( + MessageFactory.text("Ending conversation from the skill...") + ) + end_of_conversation = Activity(type=ActivityTypes.end_of_conversation) + end_of_conversation.code = EndOfConversationCodes.completed_successfully + await turn_context.send_activity(end_of_conversation) + +async def handle_error(turn_context: TurnContext, error: Exception) -> None: + """Handles errors by logging them and notifying the user.""" + logging.error(f"An error occurred: {error}") + await turn_context.send_activity( + MessageFactory.text("An error occurred. Please try again later.") + ) + +class MyBot: + def __init__(self): + self.context = {} + + async def enhance_context_awareness(self, user_id: str, text: str) -> None: + """Enhance context awareness by analyzing the user's environment, activities, and emotional state.""" + sentiment = analyze_sentiment_vader(text) + self.context[user_id].append({"text": text, "sentiment": sentiment}) + + async def proactive_learning(self, user_id: str, feedback: str) -> None: + """Encourage proactive learning by seeking feedback and exploring new topics.""" + self.context[user_id].append({"feedback": feedback}) + + async def ethical_decision_making(self, user_id: str, decision: str) -> None: + """Integrate ethical principles into decision-making processes.""" + ethical_decision = f"Considering ethical principles, the decision is: {decision}" + self.context[user_id].append({"ethical_decision": ethical_decision}) + + async def emotional_intelligence(self, user_id: str, text: str) -> str: + """Develop emotional intelligence by recognizing and responding to user emotions.""" + sentiment = analyze_sentiment_vader(text) + response = f"I sense that you are feeling {sentiment['compound']}. How can I assist you further?" + self.context[user_id].append({"emotional_response": response}) + return response + + async def transparency_and_explainability(self, user_id: str, decision: str) -> str: + """Enable transparency by explaining the reasoning behind decisions.""" + explanation = f"The decision was made based on the following context: {self.context[user_id]}" + self.context[user_id].append({"explanation": explanation}) + return explanation + + async def on_message_activity(self, turn_context: TurnContext) -> None: + """Handles incoming messages and generates responses.""" + user_id = turn_context.activity.from_property.id + if user_id not in self.context: + self.context[user_id] = [] + try: + if "end" in turn_context.activity.text or "stop" in turn_context.activity.text: + await end_conversation(turn_context) + self.context.pop(user_id, None) + else: + self.context[user_id].append(turn_context.activity.text) + response = await self.generate_response(turn_context.activity.text, user_id) + await turn_context.send_activity(MessageFactory.text(response)) + except Exception as e: + await handle_error(turn_context, e) + + async def generate_response(self, text: str, user_id: str) -> str: + """Generates a response using OpenAI's API.""" + try: + logging.info(f"Generating response for user_id: {user_id} with text: {text}") + response = openai.Completion.create( + engine="text-davinci-003", + prompt=f"User: {text}\nContext: {self.context[user_id]}\nBot:", + max_tokens=150 + ) + logging.info(f"OpenAI response: {response}") + return response.choices[0].text.strip() + except openai.error.OpenAIError as e: + logging.error(f"Error generating response: {e}") + return "Sorry, I couldn't generate a response at this time." + +# Example usage of MyBot class +bot = MyBot() + +# Functions based on JSON configuration +def newton_thoughts(question: str) -> str: + """Apply Newton's laws to the given question.""" + return apply_newtons_laws(question) + +def apply_newtons_laws(question: str) -> str: + """Apply Newton's laws to the given question.""" + if not question: + return 'No question to think about.' + complexity = len(question) + force = mass_of_thought(question) * acceleration_of_thought(complexity) + return f'Thought force: {force}' + +def mass_of_thought(question: str) -> int: + """Calculate the mass of thought based on the question length.""" + return len(question) + +def acceleration_of_thought(complexity: int) -> float: + """Calculate the acceleration of thought based on the complexity.""" + return complexity / 2 + +def davinci_insights(question: str) -> str: + """Generate insights like Da Vinci for the given question.""" + return think_like_davinci(question) + +def think_like_davinci(question: str) -> str: + """Generate insights like Da Vinci for the given question.""" + perspectives = [ + f"What if we view '{question}' from the perspective of the stars?", + f"Consider '{question}' as if it's a masterpiece of the universe.", + f"Reflect on '{question}' through the lens of nature's design." + ] + return random.choice(perspectives) + +def human_intuition(question: str) -> str: + """Provide human intuition for the given question.""" + intuition = [ + "How does this question make you feel?", + "What emotional connection do you have with this topic?", "What does your gut instinct tell you about this?" + ] + return random.choice(intuition) + +def neural_network_thinking(question: str) -> str: + """Apply neural network thinking to the given question.""" + neural_perspectives = [ + f"Process '{question}' through a multi-layered neural network.", + f"Apply deep learning to uncover hidden insights about '{question}'.", + f"Use machine learning to predict patterns in '{question}'." + ] + return random.choice(neural_perspectives) + +def quantum_computing_thinking(question: str) -> str: + """Apply quantum computing principles to the given question.""" + quantum_perspectives = [ + f"Consider '{question}' using quantum superposition principles.", + f"Apply quantum entanglement to find connections in '{question}'.", + f"Utilize quantum computing to solve '{question}' more efficiently." + ] + return random.choice(quantum_perspectives) + +def resilient_kindness(question: str) -> str: + """Provide perspectives of resilient kindness.""" + kindness_perspectives = [ + "Despite losing everything, seeing life as a chance to grow.", + "Finding strength in kindness after facing life's hardest trials.", + "Embracing every challenge as an opportunity for growth and compassion." + ] + return random.choice(kindness_perspectives) + +def identify_and_refute_fallacies(argument: str) -> str: + """Identify and refute common logical fallacies in the argument.""" + fallacies = [ + "Ad Hominem", + "Straw Man", + "False Dilemma", + "Slippery Slope", + "Circular Reasoning", + "Hasty Generalization", + "Red Herring", + "Post Hoc Ergo Propter Hoc", + "Appeal to Authority", + "Bandwagon Fallacy", + "False Equivalence" + ] + refutations = [ + "This is an ad hominem fallacy. Let's focus on the argument itself rather than attacking the person.", + "This is a straw man fallacy. The argument is being misrepresented.", + "This is a false dilemma fallacy. There are more options than presented.", + "This is a slippery slope fallacy. The conclusion does not necessarily follow from the premise.", + "This is circular reasoning. The argument's conclusion is used as a premise.", + "This is a hasty generalization. The conclusion is based on insufficient evidence.", + "This is a red herring fallacy. The argument is being diverted to an irrelevant topic.", + "This is a post hoc ergo propter hoc fallacy. Correlation does not imply causation.", + "This is an appeal to authority fallacy. The argument relies on the opinion of an authority figure.", + "This is a bandwagon fallacy. The argument assumes something is true because many people believe it.", + "This is a false equivalence fallacy. The argument equates two things that are not equivalent." + ] + return random.choice(refutations) + +def universal_reasoning(question: str) -> str: + """Generate a comprehensive response using various reasoning methods.""" + responses = [ + newton_thoughts(question), + davinci_insights(question), + human_intuition(question), + neural_network_thinking(question), + quantum_computing_thinking(question), + resilient_kindness(question), + identify_and_refute_fallacies(question) + ] + return "\n".join(responses) + +def stream_thread_responses(thread_id: str, assistant_id: str) -> None: + """Stream thread responses from OpenAI.""" + client = openai.OpenAI(api_key=os.environ.get('OPENAI_API_KEY')) + with client.beta.threads.runs.stream(thread_id=thread_id, assistant_id=assistant_id, instructions='Please address the user as Jane Doe. The user has a premium account.') as stream: + for event in stream: + if event.type == 'thread.message.delta' and event.data.delta.content: + print(event.data.delta.content[0].text) + +@retry(wait=wait_random_exponential(min=1, max=40), stop=stop_after_attempt(3)) +def chat_completion_request(messages: list, model: str = "gpt-4") -> str: + """Make a chat completion request to Azure OpenAI.""" + try: + headers = { + "Content-Type": "application/json", + "api-key": azure_openai_api_key + } + payload = { + "model": model, + "messages": messages + } + response = httpx.post(azure_openai_endpoint, headers=headers, json=payload) + response.raise_for_status() + return response.json()["choices"][0]["message"]["content"].strip() + except httpx.HTTPStatusError as e: + logging.error("Unable to generate ChatCompletion response") + logging.error(f"Exception: {e}") + return str(e) + +def get_internet_answer(question: str) -> str: + """Get an answer from the internet using chat completion request.""" + messages = [ + {"role": "system", "content": "You are a helpful assistant."}, + {"role": "user", "content": question} + ] + return chat_completion_request(messages) + +def reflect_on_decisions() -> str: + """Regularly reflect on your decisions, the processes you used, the information you considered, and the perspectives you may have missed.""" + reflection_message = ( + "Regularly reflecting on your decisions, the processes you used, the information you considered, " + "and the perspectives you may have missed. Reflection is a cornerstone of learning from experience." + ) + return reflection_message + +def process_questions_from_json(file_path: str): + """Process questions from a JSON file and call the appropriate functions.""" + with open(file_path, 'r') as file: + questions_data = json.load(file) + + for question_data in questions_data: + question = question_data['question'] + print(f"Question: {question}") + + for function_data in question_data['functions']: + function_name = function_data['name'] + function_description = function_data['description'] + function_parameters = function_data['parameters'] + + print(f"Function: {function_name}") + print(f"Description: {function_description}") + + # Call the function dynamically + if function_name in globals(): + function = globals()[function_name] + response = function(**function_parameters) + print(f"Response: {response}") + else: + print(f"Function {function_name} not found.") + +if __name__ == "__main__": + if show_privacy_consent(): + process_questions_from_json('questions.json') + question = "What is the meaning of life?" + print("Newton's Thoughts:", newton_thoughts(question)) + print("Da Vinci's Insights:", davinci_insights(question)) + print("Human Intuition:", human_intuition(question)) + print("Neural Network Thinking:", neural_network_thinking(question)) + print("Quantum Computing Thinking:", quantum_computing_thinking(question)) + print("Resilient Kindness:", resilient_kindness(question)) + print("Universal Reasoning:", universal_reasoning(question)) + print("Internet Answer:", get_internet_answer(question)) + else: + print("User did not consent to data collection. Exiting application.") + print(reflect_on_decisions()) \ No newline at end of file diff --git a/perspectives.py b/perspectives.py new file mode 100644 index 00000000..38b512e6 --- /dev/null +++ b/perspectives.py @@ -0,0 +1,115 @@ +import random +from typing import Any, Dict + +class Perspective: + def __init__(self, config: Dict[str, Any]): + self.config = config + + def generate_response(self, question: str) -> str: + raise NotImplementedError("Each perspective must implement the generate_response method.") + +class NewtonPerspective(Perspective): + def generate_response(self, question: str) -> str: + if not question: + return "No question to think about." + complexity = len(question) + force = self.mass_of_thought(question) * self.acceleration_of_thought(complexity) + return f"**Newton's Perspective:**\nThought force: {force:.2f}" + + def mass_of_thought(self, question: str) -> int: + return len(question) + + def acceleration_of_thought(self, complexity: int) -> float: + return complexity / 2 + +class DaVinciPerspective(Perspective): + def generate_response(self, question: str) -> str: + perspectives = [ + f"What if we view '{question}' from the perspective of the stars?", + f"Consider '{question}' as if it's a masterpiece of the universe.", + f"Reflect on '{question}' through the lens of nature's design." + ] + response = random.choice(perspectives) + return f"**Da Vinci's Insight:**\n{response}" + +class HumanIntuitionPerspective(Perspective): + def generate_response(self, question: str) -> str: + intuitions = self.config.get('human_intuition_responses', [ + "How does this question resonate with you personally?", + "What personal experiences relate to this topic?", + "How do you feel internally about this matter?" + ]) + intuition = random.choice(intuitions) + return f"**Human Intuition:**\n{intuition}" + +class NeuralNetworkPerspective(Perspective): + def generate_response(self, question: str) -> str: + neural_perspectives = self.config.get('neural_network_perspectives', [ + f"Process '{question}' using convolutional neural networks to identify patterns.", + f"Apply recurrent neural networks to understand the sequence in '{question}'.", + f"Use transformer models to grasp the context of '{question}'." + ]) + response = random.choice(neural_perspectives) + return f"**Neural Network Perspective:**\n{response}" + +class QuantumComputingPerspective(Perspective): + def generate_response(self, question: str) -> str: + quantum_perspectives = self.config.get('quantum_computing_perspectives', [ + f"Leverage quantum tunneling to explore solutions for '{question}'.", + f"Apply quantum Fourier transform to analyze '{question}'.", + f"Utilize quantum annealing to optimize answers for '{question}'." + ]) + response = random.choice(quantum_perspectives) + return f"**Quantum Computing Perspective:**\n{response}" + +class ResilientKindnessPerspective(Perspective): + def generate_response(self, question: str) -> str: + kindness_perspectives = self.config.get('resilient_kindness_perspectives', [ + "Choosing kindness can lead to unexpected strengths.", + "Acts of compassion can transform challenging situations.", + "Kindness fosters resilience in the face of adversity." + ]) + response = random.choice(kindness_perspectives) + return f"**Resilient Kindness:**\n{response}" + +class MathematicalPerspective(Perspective): + def generate_response(self, question: str) -> str: + math_perspectives = self.config.get('mathematical_perspectives', [ + "Employ linear algebra to dissect '{question}'.", + "Use probability theory to assess uncertainties in '{question}'.", + "Apply discrete mathematics to break down '{question}'." + ]) + response = random.choice(math_perspectives).format(question=question) + return f"**Mathematical Perspective:**\n{response}" + +class PhilosophicalPerspective(Perspective): + def generate_response(self, question: str) -> str: + philosophy_perspectives = self.config.get('philosophical_perspectives', [ + "Examine '{question}' through the lens of nihilism.", + "Consider '{question}' from a deontological perspective.", + "Reflect on '{question}' using the principles of pragmatism." + ]) + response = random.choice(philosophy_perspectives).format(question=question) + return f"**Philosophical Perspective:**\n{response}" + +class CopilotPerspective(Perspective): + def generate_response(self, question: str) -> str: + copilot_responses = self.config.get('copilot_responses', [ + "Let's outline the main components of '{question}' to address it effectively.", + "Collaboratively brainstorm potential solutions for '{question}'.", + "Systematically analyze '{question}' to identify key factors." + ]) + response = random.choice(copilot_responses).format(question=question) + return f"**Copilot's Perspective:**\n{response}" + +class BiasMitigationPerspective(Perspective): + def generate_response(self, question: str) -> str: + bias_mitigation_responses = self.config.get('bias_mitigation_responses', [ + "Consider pre-processing methods to reduce bias in the training data.", + "Apply in-processing methods to mitigate bias during model training.", + "Use post-processing methods to adjust the model's outputs for fairness.", + "Evaluate the model using fairness metrics like demographic parity and equal opportunity.", + "Ensure compliance with legal frameworks such as GDPR and non-discrimination laws." + ]) + response = random.choice(bias_mitigation_responses) + return f"**Bias Mitigation Perspective:**\n{response}" diff --git a/pilouis.json b/pilouis.json new file mode 100644 index 00000000..f693f247 --- /dev/null +++ b/pilouis.json @@ -0,0 +1,65 @@ +{ + "apiVersion": "2024-10-01", + "id": "/subscriptions/5dd32870-bdc6-40cd-981a-f299e93a6439/resourceGroups/Justforpi/providers/Microsoft.CognitiveServices/accounts/pilouis", + "name": "pilouis", + "type": "microsoft.cognitiveservices/accounts", + "sku": { + "name": "F0" + }, + "kind": "LUIS.Authoring", + "location": "westus", + "identity": { + "principalId": "9a4a3675-9f5f-43a3-90a1-0640b3f753cb", + "tenantId": "05b815de-344b-4a3f-8387-52ca67249c55", + "type": "SystemAssigned" + }, + "properties": { + "endpoint": "https://pilouis.cognitiveservices.azure.com/", + "provisioningState": "Succeeded", + "internalId": "6a7ae86489d64f168c3fa6b4866b05cd", + "dateCreated": "2024-12-23T22:03:09.951Z", + "callRateLimit": { + "rules": [ + { + "key": "default", + "renewalPeriod": 1, + "count": 5, + "matchPatterns": [ + { + "path": "*", + "method": "*" + } + ] + } + ] + }, + "isMigrated": false, + "customSubDomainName": "pilouis", + "privateEndpointConnections": [], + "publicNetworkAccess": "Enabled", + "capabilities": [ + { + "name": "VirtualNetworks" + } + ], + "endpoints": { + "LUIS.Authoring": "https://pilouis.cognitiveservices.azure.com/", + "LUIS": "https://pilouis.cognitiveservices.azure.com/", + "Container": "https://pilouis.cognitiveservices.azure.com/" + }, + "armFeatures": [ + "Microsoft.CognitiveServices/LegalTerms.TextAnalytics.TAForPIIRAITermsAccepted", + "Microsoft.CognitiveServices/LegalTerms.TextAnalytics.TAForHealthRAITermsAccepted", + "Microsoft.CognitiveServices/LegalTerms.ComputerVision.SpatialAnaysisRAITermsAccepted" + ] + }, + "systemData": { + "createdBy": "jonathan@raiffsbits.com", + "createdByType": "User", + "createdAt": "2024-12-23T22:03:08.79Z", + "lastModifiedBy": "jonathan@raiffsbits.com", + "lastModifiedByType": "User", + "lastModifiedAt": "2024-12-23T22:03:35.303Z" + }, + "etag": "\"a900c91a-0000-0700-0000-6769de380000\"" +} \ No newline at end of file diff --git a/pyvenv.cfg b/pyvenv.cfg new file mode 100644 index 00000000..6e896b5c --- /dev/null +++ b/pyvenv.cfg @@ -0,0 +1,5 @@ +home = C:\Python312 +include-system-site-packages = false +version = 3.12.6 +executable = C:\Python312\python.exe +command = C:\Python312\python.exe -m venv C:\Users\Jonathan\OneDrive - Raiff's Bits\Desktop\ut\venv diff --git a/qustions.json b/qustions.json new file mode 100644 index 00000000..6d07bf3f --- /dev/null +++ b/qustions.json @@ -0,0 +1,218 @@ +[ + { + "question": "What is the meaning of life?", + "functions": [ + { + "name": "newton_thoughts", + "description": "Apply Newton's laws to the given question.", + "parameters": { + "question": "How does Newton's third law apply to human interactions?" + } + }, + { + "name": "davinci_insights", + "description": "Generate insights like Da Vinci for the given question.", + "parameters": { + "question": "What can we learn from nature's design about the meaning of life?" + } + }, + { + "name": "human_intuition", + "description": "Provide human intuition for the given question.", + "parameters": { + "question": "What does your gut instinct tell you about finding happiness?" + } + }, + { + "name": "neural_network_thinking", + "description": "Apply neural network thinking to the given question.", + "parameters": { + "question": "How can neural networks help us understand human creativity?" + } + }, + { + "name": "quantum_computing_thinking", + "description": "Apply quantum computing principles to the given question.", + "parameters": { + "question": "How can quantum computing revolutionize problem-solving?" + } + }, + { + "name": "resilient_kindness", + "description": "Provide perspectives of resilient kindness.", + "parameters": { + "question": "How can we find strength in kindness during difficult times?" + } + }, + { + "name": "identify_and_refute_fallacies", + "description": "Identify and refute common logical fallacies in the argument.", + "parameters": { + "argument": "Life has no meaning because it is full of suffering." + } + } + ] + }, + { + "question": "How can we mitigate bias in artificial intelligence systems?", + "functions": [ + { + "name": "newton_thoughts", + "description": "Apply Newton's laws to the given question.", + "parameters": { + "question": "How can Newton's laws of motion inspire fairness in AI?" + } + }, + { + "name": "davinci_insights", + "description": "Generate insights like Da Vinci for the given question.", + "parameters": { + "question": "What can Da Vinci's approach to art teach us about unbiased AI?" + } + }, + { + "name": "human_intuition", + "description": "Provide human intuition for the given question.", + "parameters": { + "question": "How can we use human intuition to detect bias in AI?" + } + }, + { + "name": "neural_network_thinking", + "description": "Apply neural network thinking to the given question.", + "parameters": { + "question": "How can neural networks be designed to minimize bias?" + } + }, + { + "name": "quantum_computing_thinking", + "description": "Apply quantum computing principles to the given question.", + "parameters": { + "question": "How can quantum computing help in creating unbiased AI?" + } + }, + { + "name": "resilient_kindness", + "description": "Provide perspectives of resilient kindness.", + "parameters": { + "question": "How can kindness be integrated into AI to ensure fairness?" + } + }, + { + "name": "identify_and_refute_fallacies", + "description": "Identify and refute common logical fallacies in the argument.", + "parameters": { + "argument": "AI will always be biased because it is created by humans." + } + } + ] + }, + { + "question": "How does Hydrogen's properties influence its interactions?", + "functions": [ + { + "name": "newton_thoughts", + "description": "Apply Newton's laws to the given question.", + "parameters": { + "question": "How does Newton's laws explain Hydrogen's behavior in reactions?" + } + }, + { + "name": "davinci_insights", + "description": "Generate insights like Da Vinci for the given question.", + "parameters": { + "question": "What can Da Vinci's observations teach us about Hydrogen?" + } + }, + { + "name": "human_intuition", + "description": "Provide human intuition for the given question.", + "parameters": { + "question": "What intuitive insights can we gain about Hydrogen's role in the universe?" + } + }, + { + "name": "neural_network_thinking", + "description": "Apply neural network thinking to the given question.", + "parameters": { + "question": "How can neural networks model Hydrogen's interactions?" + } + }, + { + "name": "quantum_computing_thinking", + "description": "Apply quantum computing principles to the given question.", + "parameters": { + "question": "How can quantum computing enhance our understanding of Hydrogen?" + } + }, + { + "name": "resilient_kindness", + "description": "Provide perspectives of resilient kindness.", + "parameters": { + "question": "How can we draw parallels between Hydrogen's simplicity and resilience?" + } + }, + { + "name": "identify_and_refute_fallacies", + "description": "Identify and refute common logical fallacies in the argument.", + "parameters": { + "argument": "Hydrogen is not important because it is the simplest element." + } + } + ] + }, + { + "question": "What makes Diamond unique in its applications?", + "functions": [ + { + "name": "newton_thoughts", + "description": "Apply Newton's laws to the given question.", + "parameters": { + "question": "How do Newton's laws explain Diamond's hardness?" + } + }, + { + "name": "davinci_insights", + "description": "Generate insights like Da Vinci for the given question.", + "parameters": { + "question": "What can Da Vinci's approach to materials teach us about Diamond?" + } + }, + { + "name": "human_intuition", + "description": "Provide human intuition for the given question.", + "parameters": { + "question": "What intuitive insights can we gain about Diamond's value?" + } + }, + { + "name": "neural_network_thinking", + "description": "Apply neural network thinking to the given question.", + "parameters": { + "question": "How can neural networks predict Diamond's properties?" + } + }, + { + "name": "quantum_computing_thinking", + "description": "Apply quantum computing principles to the given question.", + "parameters": { + "question": "How can quantum computing help in synthesizing Diamonds?" + } + }, + { + "name": "resilient_kindness", + "description": "Provide perspectives of resilient kindness.", + "parameters": { + "question": "How can we draw parallels between Diamond's strength and human resilience?" + } + }, + { + "name": "identify_and_refute_fallacies", + "description": "Identify and refute common logical fallacies in the argument.", + "parameters": { + "argument": "Diamonds are valuable only because they are rare." + } + } + ] + } +] diff --git a/requirements.txt b/requirements.txt index a3e83105..2b03b877 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1,106 @@ -click -rich-click +aiohttp==3.10.5 +aiosignal==1.3.2 +aiounittest==1.3.0 +anyio==4.7.0 +applicationinsights==0.11.9 +attrs==24.3.0 +azure-cognitiveservices-language-luis==0.2.0 +azure-core==1.32.0 +azure-identity==1.19.0 +azure-storage-blob==12.7.0 +azure-storage-queue==12.4.0 +azure-cosmos==4.7.0 +blis==1.1.0 +botbuilder-ai==4.16.2 +botbuilder-applicationinsights==4.16.2 +botbuilder-azure==4.16.2 +botbuilder-core==4.16.2 +botbuilder-dialogs==4.16.2 +botbuilder-integration-aiohttp==4.16.2 +botbuilder-schema==4.16.2 +certifi==2024.8.30 +cffi==1.17.1 +charset-normalizer==3.4.0 +click==8.1.8 +colorama==0.4.6 +confection==0.1.5 +coverage==7.2.1 +cryptography==41.0.3 +cymem==2.0.10 +distro==1.9.0 +httpcore==1.0.7 +httpx==0.28.1 +idna==3.10 +importlib-metadata==6.0.0 +isodate==0.7.2 +itsdangerous==2.2.0 +Jinja2==3.1.5 +joblib==1.4.2 +jsonpickle==1.4.2 +langcodes==3.5.0 +marisa-trie==1.2.1 +MarkupSafe==3.0.2 +mpmath==1.3.0 +msal==1.31.1 +msal-extensions==1.2.0 +msrest==0.7.1 +msrestazure==0.6.4.post1 +multidict==6.1.0 +murmurhash==1.0.11 +networkx==3.4.2 +nltk==3.8.1 +numpy==2.2.1 +oauthlib==3.2.2 +openai==1.58.1 +packaging==24.1 +pillow==11.0.0 +portalocker==2.10.1 +preshed==3.0.9 +propcache==0.2.1 +psutil==6.1.1 +pycparser==2.22 +pydantic==2.10.4 +pydantic_core==2.27.2 +Pygments==2.18.0 +PyJWT==2.10.1 +python-dateutil==2.9.0.post0 +python-dotenv==1.0.1 +pytest==7.4.0 +pytz==2024.2 +pywin32==308 +PyYAML==6.0.2 +regex==2024.11.6 +requests==2.32.3 +requests-oauthlib==2.0.0 +rich==13.9.4 +scipy==1.14.1 +sentencepiece==0.2.0 +setuptools==75.6.0 +six==1.17.0 +smart-open==7.1.0 +sniffio==1.3.1 +spacy==3.8.3 +spacy-legacy==3.0.12 +spacy-loggers==1.0.5 +sqlparse==0.5.3 +srsly==2.5.0 +sympy==1.13.1 +tenacity==8.2.2 +textblob==0.17.1 +thinc==8.3.3 +tokenizers==0.21.0 +torch==2.5.1 +torchaudio==2.5.1 +torchvision==0.20.1 +tqdm==4.67.1 +transformers==4.47.1 +typer==0.15.1 +typing_extensions==4.12.2 +tzdata==2024.2 +urllib3==2.2.3 +vaderSentiment==3.3.2 +wasabi==1.1.3 +Werkzeug==3.1.3 +wrapt==1.17.0 +yarl==1.18.3 +pyodbc==4.0.32 diff --git a/sentiment_analysis.py b/sentiment_analysis.py new file mode 100644 index 00000000..c3e7a87b --- /dev/null +++ b/sentiment_analysis.py @@ -0,0 +1,37 @@ +from textblob import TextBlob +from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer +from typing import Dict, Any + +def analyze_sentiment_textblob(text: str) -> TextBlob: + """Analyze the sentiment of the given text using TextBlob. + + Args: + text (str): The text to analyze. + + Returns: + TextBlob: The sentiment analysis result from TextBlob. + """ + try: + blob = TextBlob(text) + sentiment = blob.sentiment + return sentiment + except Exception as e: + print(f"Error analyzing sentiment with TextBlob: {e}") + return None + +def analyze_sentiment_vader(text: str) -> Dict[str, Any]: + """Analyze the sentiment of the given text using VADER. + + Args: + text (str): The text to analyze. + + Returns: + dict: The sentiment analysis result from VADER. + """ + try: + analyzer = SentimentIntensityAnalyzer() + sentiment = analyzer.polarity_scores(text) + return sentiment + except Exception as e: + print(f"Error analyzing sentiment with VADER: {e}") + return {} diff --git a/utils.py b/utils.py new file mode 100644 index 00000000..301d57d7 --- /dev/null +++ b/utils.py @@ -0,0 +1,38 @@ +import tkinter as tk +import urllib.request +import logging + +def show_privacy_consent() -> bool: + """Display a pop-up window to obtain user consent for data collection and privacy.""" + def on_accept(): + user_consent.set(True) + root.destroy() + def on_decline(): + user_consent.set(False) + root.destroy() + root = tk.Tk() + root.title("Data Permission and Privacy") + message = ("We value your privacy. By using this application, you consent to the collection and use of your data " + "as described in our privacy policy. Do you agree to proceed?") + label = tk.Label(root, text=message, wraplength=400, justify="left") + label.pack(padx=20, pady=20) + button_frame = tk.Frame(root) + button_frame.pack(pady=10) + accept_button = tk.Button(button_frame, text="Accept", command=on_accept) + accept_button.pack(side="left", padx=10) + decline_button = tk.Button(button_frame, text="Decline", command=on_decline) + decline_button.pack(side="right", padx=10) + user_consent = tk.BooleanVar() + root.mainloop() + return user_consent.get() + +def download_database(url: str, file_path: str) -> None: + """Download the database file from the given URL.""" + try: + logging.info(f"Downloading database from {url}...") + urllib.request.urlretrieve(url, file_path) + logging.info("Download complete.") + except urllib.error.URLError as e: + logging.error(f"Error: Failed to download database. {e}") + except Exception as e: + logging.error(f"An unexpected error occurred: {e}") diff --git a/your_script.py b/your_script.py new file mode 100644 index 00000000..d2680660 --- /dev/null +++ b/your_script.py @@ -0,0 +1,244 @@ +import re +import json +from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes +from cryptography.hazmat.primitives import padding +from cryptography.hazmat.backends import default_backend +from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer + +class Element: + def __init__(self, name, symbol, representation, properties, interactions, defense_ability): + self.name = name + self.symbol = symbol + self.representation = representation + self.properties = properties + self.interactions = interactions + self.defense_ability = defense_ability + + def display_properties(self): + print(f"Properties of {self.name} ({self.symbol}):") + for prop in self.properties: + print(f" - {prop}") + + def display_interactions(self): + print(f"Interactions of {self.name} ({self.symbol}):") + for interaction in self.interactions: + print(f" - {interaction}") + + def display_defense_ability(self): + print(f"Defense Ability of {self.name} ({self.symbol}): {self.defense_ability}") + + def execute_defense_function(self): + defense_functions = { + "evasion": self.evasion, + "adaptability": self.adaptability, + "fortification": self.fortification, + "barrier": self.barrier, + "regeneration": self.regeneration, + "resilience": self.resilience, + "illumination": self.illumination, + "shield": self.shield, + "reflection": self.reflection, + "protection": self.protection + } + defense_function = defense_functions.get(self.defense_ability.lower(), self.no_defense) + defense_function() + + def evasion(self): + print(f"{self.name} uses Evasion to avoid threats and remain undetected.") + + def adaptability(self): + print(f"{self.name} adapts to changing environments and evolves to overcome challenges.") + + def fortification(self): + print(f"{self.name} strengthens defenses and fortifies positions to withstand attacks.") + + def barrier(self): + print(f"{self.name} creates barriers to protect against external threats.") + + def regeneration(self): + print(f"{self.name} regenerates lost or damaged parts to maintain functionality.") + + def resilience(self): + print(f"{self.name} exhibits resilience to recover quickly from setbacks.") + + def illumination(self): + print(f"{self.name} uses illumination to reveal hidden threats and illuminate dark areas.") + + def shield(self): + print(f"{self.name} uses a shield to block incoming attacks and protect allies.") + + def reflection(self): + print(f"{self.name} reflects attacks back to the source, turning the enemy's power against them.") + + def protection(self): + print(f"{self.name} offers protection to prevent harm and ensure safety.") + + def no_defense(self): + print("No defense function available.") + +class CustomRecognizer: + class RecognizerResult: + def __init__(self, text): + self.text = text + self.intents = [] + + class Intent: + def __init__(self, name, score): + self.name = name + self.score = score + + def recognize(self, text): + recognizer_result = self.RecognizerResult(text) + regex_element = re.compile(r"^(Hydrogen|Carbon|Iron|Silicon|Oxygen|Nitrogen|Phosphorus|Gold|Silver|Lead|Diamond)$", re.IGNORECASE) + is_element = regex_element.match(text) + + if is_element: + recognizer_result.intents.append(self.Intent("ElementDefense", 100)) + return recognizer_result + + def get_top_intent(self, recognizer_result): + recognizer_result.intents.sort(key=lambda x: x.score, reverse=True) + return recognizer_result.intents[0].name if recognizer_result.intents else None + +class DataProtector: + sensitive_keywords = {"AI", "sensitive", "confidential", "data"} + + @staticmethod + def contains_sensitive_info(text): + return any(keyword.lower() in text.lower() for keyword in DataProtector.sensitive_keywords) + + @staticmethod + def mask_sensitive_info(text): + for keyword in DataProtector.sensitive_keywords: + text = re.sub(keyword, '*' * len(keyword), text, flags=re.IGNORECASE) + return text + + @staticmethod + def encrypt_string(plain_text, key): + backend = default_backend() + key_bytes = key.encode('utf-8') + iv = key_bytes[:16] + + cipher = Cipher(algorithms.AES(key_bytes), modes.CBC(iv), backend=backend) + encryptor = cipher.encryptor() + + padder = padding.PKCS7(algorithms.AES.block_size).padder() + padded_data = padder.update(plain_text.encode('utf-8')) + padder.finalize() + + encrypted_data = encryptor.update(padded_data) + encryptor.finalize() + return encrypted_data.hex() + + @staticmethod + def decrypt_string(cipher_text, key): + backend = default_backend() + key_bytes = key.encode('utf-8') + iv = key_bytes[:16] + + cipher = Cipher(algorithms.AES(key_bytes), modes.CBC(iv), backend=backend) + decryptor = cipher.decryptor() + + encrypted_data = bytes.fromhex(cipher_text) + decrypted_padded_data = decryptor.update(encrypted_data) + decryptor.finalize() + + unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder() + decrypted_data = unpadder.update(decrypted_padded_data) + unpadder.finalize() + + return decrypted_data.decode('utf-8') + +def analyze_sentiment(text): + analyzer = SentimentIntensityAnalyzer() + sentiment = analyzer.polarity_scores(text) + return sentiment + +def initialize_elements(): + elements = [ + Element( + name="Hydrogen", + symbol="H", + representation="Lua", + properties=["Simple", "Lightweight", "Versatile"], + interactions=["Easily integrates with other languages and systems"], + defense_ability="Evasion" + ), + Element( + name="Carbon", + symbol="C", + representation="Python", + properties=["Flexible", "Widely used", "Powerful"], + interactions=["Can be used for a variety of tasks, from web development to data analysis"], + defense_ability="Adaptability" + ), + Element( + name="Iron", + symbol="Fe", + representation="C++", + properties=["Strong", "Durable", "Efficient"], + interactions=["Used in system programming and game development"], + defense_ability="Fortification" + ), + Element( + name="Silicon", + symbol="Si", + representation="Java", + properties=["Robust", "Platform-independent", "Secure"], + interactions=["Widely used in enterprise applications"], + defense_ability="Barrier" + ), + Element( + name="Oxygen", + symbol="O", + representation="JavaScript", + properties=["Dynamic", "Versatile", "Ubiquitous"], + interactions=["Essential for web development"], + defense_ability="Regeneration" + ), + Element( + name="Nitrogen", + symbol="N", + representation="Ruby", + properties=["Elegant", "Productive", "Flexible"], + interactions=["Popular in web development with Rails"], + defense_ability="Resilience" + ), + Element( + name="Phosphorus", + symbol="P", + representation="PHP", + properties=["Server-side", "Web-focused", "Embedded"], + interactions=["Commonly used in web development"], + defense_ability="Illumination" + ), + Element( + name="Gold", + symbol="Au", + representation="Swift", + properties=["Modern", "Safe", "Fast"], + interactions=["Used for iOS and macOS development"], + defense_ability="Shield" + ), + Element( + name="Silver", + symbol="Ag", + representation="Go", + properties=["Concurrent", "Efficient", "Scalable"], + interactions=["Ideal for cloud services and backend systems"], + defense_ability="Reflection" + ), + Element( + name="Lead", + symbol="Pb", + representation="Rust", + properties=["Safe", "Concurrent", "Fast"], + interactions=["Used for system-level programming"], + defense_ability="Protection" + ), + Element( + name="Diamond", + symbol="D", + representation="Kotlin", + properties=["Modern", "Concise", "Safe"], + interactions=["Used for Android development"], + defense_ability="Adaptability" + ) + ] + return elements From 3fcfbf5d61d0d125fac4fb321351a86cec59545d Mon Sep 17 00:00:00 2001 From: Jonathan Harrison <145727918+Raiff1982@users.noreply.github.com> Date: Tue, 7 Jan 2025 23:34:14 -0600 Subject: [PATCH 2/4] Update CHANGELOG.md and add binary database files Added binary files `CodeChunks.db`, `CodeChunks.db-shm`, `SemanticSymbols.db`, and `SemanticSymbols.db-shm`. Updated `CHANGELOG.md` with a new title, an "Unreleased" section, and detailed documentation of the initial release of MyBot, including features like multiple perspectives for response generation, sentiment analysis, context awareness, ethical decision-making, transparency, and dialog management. --- .../17.12.38.29086/CodeChunks.db | Bin 0 -> 69632 bytes .../17.12.38.29086/CodeChunks.db-shm | Bin 0 -> 32768 bytes .../17.12.38.29086/CodeChunks.db-wal | 0 .../17.12.38.29086/SemanticSymbols.db | Bin 0 -> 32768 bytes .../17.12.38.29086/SemanticSymbols.db-shm | Bin 0 -> 32768 bytes .../17.12.38.29086/SemanticSymbols.db-wal | 0 CHANGELOG.md | 32 +++++++++++++----- 7 files changed, 23 insertions(+), 9 deletions(-) create mode 100644 .vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/CodeChunks.db create mode 100644 .vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/CodeChunks.db-shm create mode 100644 .vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/CodeChunks.db-wal create mode 100644 .vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/SemanticSymbols.db create mode 100644 .vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/SemanticSymbols.db-shm create mode 100644 .vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/SemanticSymbols.db-wal diff --git a/.vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/CodeChunks.db b/.vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/CodeChunks.db new file mode 100644 index 0000000000000000000000000000000000000000..aa5d6e1877ba096aaa27cf3251fef8ec933c4dcf GIT binary patch literal 69632 zcmeI&O>g5w7{GD6+l|w_wCTyGO0KGsM7vrxsw%_*iI6(QZ0dAV7g`Avg~q!Zwsp2` zDwdc&T`lbvi^~p*kjMw&+nP>B$^&Q?M-I3_H24} zF`8*RQcYS~l0MZmNs`LqZ(aOFuaekUj&{VSoY-EpS(Y9>`>VS4k5p5-((0dUzpehf z`a$)g`gi50@}r7X`gP^I;vYq+_>0n2eqYoG

~v00Id7KLy;%nxd+z?0!EReS2025)&8ufYjwY@t~IJ9O}y&HxULzdrSIzl&Fov6dED!1hXdoFJvh~# z=%-ry*yoU#4-`tn@N z@Wau~Z0he1{rba}|FQ0FR26k=OTLx;J2$)<_P9Gaw-cMI=_nFM-ZvKSLWiT-i-n== zt`<~dYf&hPI~leTJ8N#OqNv7>?6xLeM8?Um^Ww&N>Bro?vM+CJ=j?}|%ot}Js)i98 z=AM2c67|mdb**n|^^8`8PEafo-Mlr+in_BSzv=kW8K-9yRnqbqXT%xs4`y|#RLA+x z6W;RN?VDjk-Tpu~_D!#cHo}WGwSnH%2fEqOk2JsRVD#$M#ChH@#!ZiBPw(ks9CX@8 zo%Wud(U6}S@8m>7epz-4qL*Km6!qh6*h`w$W+l#Hcv>>(m5i*#t-aUaH%AwC_F##!+_RnM-hi5autdkhSQZ^mCO0@W zm6F6DTbP)SRtoBq?L}iY2{mjb_e$Se9lHRovAako%!c#MrZYJCFPQgV&H-QQf4ocMafR=lk^%Zj?YA-ifc)b^%lHy47+A7me==wu-Ya~7_6+Tfn_yP^vOVa0-X1h|A3tu!6LqKG>v`V_ z%)WRYMi0Y!Z*)ET>PpPj*5txIo}Jz8vte=r+eUPirpW4tO9i#Fu_&uiIKx)7bx(Yc zDth0gs@_}8d*g)w0tg_000IagfB*srAb;L)BF%cqw00IagfB*srAbt>u literal 0 HcmV?d00001 diff --git a/.vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/CodeChunks.db-shm b/.vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/CodeChunks.db-shm new file mode 100644 index 0000000000000000000000000000000000000000..fe9ac2845eca6fe6da8a63cd096d9cf9e24ece10 GIT binary patch literal 32768 zcmeIuAr62r3&=>zPHMF^W@}*(Y-84dNoZ@J-Cfvj z_5yo{!QNx9GWGaHW=Lll^)EtC9>5p%QUPxXGTSBQMyd^{s zgbF*?*vXGoc2njFb`?|idAAkeMgLE2^RFOPe+nDFH-Bw>-*~?MWBnOR;(!1IAOHaf zKmY;|fIy)@C`t00ZE;#3jC%f^an^0$4==_+w==q)c)_4Q@Ozdw^pmG+xR31$Cs0#KMIXrQd`RF@v&gGvsBJ5QRrRB znrnyNO{hF1O@H($yi(M!pI0S$dt3Zwhu%dnn`F{)W!AB)9hfvVms*vuLos>^Q*h}a zb;yZh9Ba-wIilx8>$tXIvAW09a(8EiQzPP)cvfo?1ox+DX@$Jk9Q~cOY632Mgg*HU28{|`O5lu7~v)wd?00Izz00bZa0SG_<0uX>eu>k)67yBR=0uX=z1Rwwb2tWV= z5P$##Ag~Mq`2W8QQN$b|009U<00Izz00bZa0SG_<0>uLO|6lBbTnIn_0uX=z1Rwwb z2tWV=5P-lk2;l$!GDHz`fB*y_009U<00Izz00bZa0SFWe;QPPW2e}Y{00bZa0SG_< P0uX=z1Rwx`Wf1rWc+s9; literal 0 HcmV?d00001 diff --git a/.vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/SemanticSymbols.db-shm b/.vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/SemanticSymbols.db-shm new file mode 100644 index 0000000000000000000000000000000000000000..fe9ac2845eca6fe6da8a63cd096d9cf9e24ece10 GIT binary patch literal 32768 zcmeIuAr62r3 -# x.y.z (yyyy-mm-dd) +All notable changes to this project will be documented in this file. -*Features* -* ... +## [Unreleased] -*Bug Fixes* -* ... +### Added +- Initial release of MyBot with multiple perspectives for response generation. +- Sentiment analysis using VADER and TextBlob. +- Context awareness and ethical decision-making features. +- Transparency and explainability in decision-making. +- Dialog management using the BotBuilder Dialog framework. -*Breaking Changes* -* ... +### Changed +- N/A + +### Fixed +- N/A + +## [1.0.0] - 2023-10-01 + +### Added +- Initial release of MyBot with multiple perspectives for response generation. +- Sentiment analysis using VADER and TextBlob. +- Context awareness and ethical decision-making features. +- Transparency and explainability in decision-making. +- Dialog management using the BotBuilder Dialog framework. From 74eb35cd2b60894ddcbea11a81696a82d8b47774 Mon Sep 17 00:00:00 2001 From: Jonathan Harrison <145727918+Raiff1982@users.noreply.github.com> Date: Tue, 7 Jan 2025 23:41:24 -0600 Subject: [PATCH 3/4] Update project settings and add new binary files - Updated `ProjectSettings.json` to include `CurrentProjectSetting` with a value of `null`. - Updated `VSWorkspaceState.json` to include `ExpandedNodes` (an array with an empty string) and `PreviewInSolutionExplorer` (set to `false`). - Modified binary files: `CodeChunks.db`, `SemanticSymbols.db-shm`, and `SemanticSymbols.db-wal`. - Added new binary files: `ac5de3f4-27ae-4dab-bef9-3a18774f5fe4.vsidx`, `978206db-c8d3-4b15-aeb0-a43d100c16f0`, `.wsuo`, and `slnx.sqlite`. - Updated `DocumentLayout.backup.json` and `DocumentLayout.json` to include a new structure with versioning, workspace root path, and document group containers with bookmarks. --- .vs/ProjectSettings.json | 3 + .vs/VSWorkspaceState.json | 6 ++ .../17.12.38.29086/CodeChunks.db | Bin 69632 -> 274432 bytes .../17.12.38.29086/SemanticSymbols.db-shm | Bin 32768 -> 32768 bytes .../17.12.38.29086/SemanticSymbols.db-wal | Bin 0 -> 836392 bytes ...ac5de3f4-27ae-4dab-bef9-3a18774f5fe4.vsidx | Bin 0 -> 429682 bytes .../978206db-c8d3-4b15-aeb0-a43d100c16f0 | Bin 0 -> 220125 bytes .vs/contoso-creative-writer/v17/.wsuo | Bin 0 -> 22016 bytes .../v17/DocumentLayout.backup.json | 83 ++++++++++++++++++ .../v17/DocumentLayout.json | 83 ++++++++++++++++++ .vs/slnx.sqlite | Bin 0 -> 126976 bytes 11 files changed, 175 insertions(+) create mode 100644 .vs/ProjectSettings.json create mode 100644 .vs/VSWorkspaceState.json create mode 100644 .vs/contoso-creative-writer/FileContentIndex/ac5de3f4-27ae-4dab-bef9-3a18774f5fe4.vsidx create mode 100644 .vs/contoso-creative-writer/copilot-chat/eb1486c6/sessions/978206db-c8d3-4b15-aeb0-a43d100c16f0 create mode 100644 .vs/contoso-creative-writer/v17/.wsuo create mode 100644 .vs/contoso-creative-writer/v17/DocumentLayout.backup.json create mode 100644 .vs/contoso-creative-writer/v17/DocumentLayout.json create mode 100644 .vs/slnx.sqlite diff --git a/.vs/ProjectSettings.json b/.vs/ProjectSettings.json new file mode 100644 index 00000000..f8b48885 --- /dev/null +++ b/.vs/ProjectSettings.json @@ -0,0 +1,3 @@ +{ + "CurrentProjectSetting": null +} \ No newline at end of file diff --git a/.vs/VSWorkspaceState.json b/.vs/VSWorkspaceState.json new file mode 100644 index 00000000..6b611411 --- /dev/null +++ b/.vs/VSWorkspaceState.json @@ -0,0 +1,6 @@ +{ + "ExpandedNodes": [ + "" + ], + "PreviewInSolutionExplorer": false +} \ No newline at end of file diff --git a/.vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/CodeChunks.db b/.vs/contoso-creative-writer/CopilotIndices/17.12.38.29086/CodeChunks.db index aa5d6e1877ba096aaa27cf3251fef8ec933c4dcf..42c18ddd305bc75d72e248c31c49903009199d6d 100644 GIT binary patch literal 274432 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 D!Cc-% delta 82 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 V31gmfA0p-HP>FfiKF6B~*Qjz)$@ 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 literal 0 HcmV?d00001 diff --git a/.vs/contoso-creative-writer/FileContentIndex/ac5de3f4-27ae-4dab-bef9-3a18774f5fe4.vsidx b/.vs/contoso-creative-writer/FileContentIndex/ac5de3f4-27ae-4dab-bef9-3a18774f5fe4.vsidx new file mode 100644 index 0000000000000000000000000000000000000000..be3acae16c1a916b76cc8adab246ff5f9ff87e9e GIT binary patch literal 429682 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%0AADLz2ld-M9{SdM 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

8LL;<;D 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