--- name: '' description: '' authors: [] tags: [] version: '' base: '' model: api: chat configuration: type: azure_openai azure_deployment: gpt-4 parameters: temperature: 0.7 top_p: 0.95 stop: [] frequency_penalty: 0 presence_penalty: 0 max_tokens: 800 past_messages_to_include: '20' response: {} sample: String: |- import asyncio import json import logging import os from typing import List, Dict, Any from cryptography.fernet import Fernet from botbuilder.core import StatePropertyAccessor, TurnContext from botbuilder.dialogs import Dialog, DialogSet, DialogTurnStatus from dialog_helper import DialogHelper import aiohttp import speech_recognition as sr from PIL import Image 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 ( Perspective, NewtonPerspective, DaVinciPerspective, HumanIntuitionPerspective, NeuralNetworkPerspective, QuantumComputingPerspective, ResilientKindnessPerspective, MathematicalPerspective, PhilosophicalPerspective, CopilotPerspective, BiasMitigationPerspective, PsychologicalPerspective ) # Load environment variables from dotenv import load_dotenv load_dotenv() # 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 {} # Encrypt sensitive information def encrypt_sensitive_data(data, key): fernet = Fernet(key) encrypted_data = fernet.encrypt(data.encode()) return encrypted_data # Decrypt sensitive information def decrypt_sensitive_data(encrypted_data, key): fernet = Fernet(key) decrypted_data = fernet.decrypt(encrypted_data).decode() return decrypted_data # Securely destroy sensitive information def destroy_sensitive_data(data): del data # 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() self.context_history = [] # Maintain context history self.feedback = [] # Store user feedback # 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", "psychological" ]) 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, "psychological": PsychologicalPerspective } 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): self.context_history.append(question) # Add question to context history sentiment_score = self.analyze_sentiment(question) real_time_data = await self.fetch_real_time_data("https://api.example.com/data") 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 analyze_sentiment(self, text): sentiment_score = self.sentiment_analyzer.polarity_scores(text) logging.info(f"Sentiment analysis result: {sentiment_score}") return sentiment_score async def fetch_real_time_data(self, source_url): async with aiohttp.ClientSession() as session: async with session.get(source_url) as response: data = await response.json() logging.info(f"Real-time data fetched from {source_url}: {data}") return data async def run_dialog(self, dialog: Dialog, turn_context: TurnContext, accessor: StatePropertyAccessor) -> None: await DialogHelper.run_dialog(dialog, turn_context, accessor) 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}'.") async def collect_user_feedback(self, turn_context: TurnContext): # Collect feedback from the user feedback = turn_context.activity.text logging.info(f"User feedback received: {feedback}") # Process feedback for continuous learning self.process_feedback(feedback) def process_feedback(self, feedback): # Implement feedback processing logic logging.info(f"Processing feedback: {feedback}") # Example: Adjust response generation based on feedback # This can be expanded with more sophisticated learning algorithms def add_new_perspective(self, perspective_name, perspective_class): if perspective_name.lower() not in [p.__class__.__name__.lower() for p in self.perspectives]: self.perspectives.append(perspective_class(self.config)) logging.info(f"New perspective '{perspective_name}' added.") else: logging.warning(f"Perspective '{perspective_name}' already exists.") def handle_voice_input(self): recognizer = sr.Recognizer() with sr.Microphone() as source: print("Listening...") audio = recognizer.listen(source) try: text = recognizer.recognize_google(audio) print(f"Voice input recognized: {text}") return text except sr.UnknownValueError: print("Google Speech Recognition could not understand audio") return None except sr.RequestError as e: print(f"Could not request results from Google Speech Recognition service; {e}") return None def handle_image_input(self, image_path): try: image = Image.open(image_path) print(f"Image input processed: {image_path}") return image except Exception as e: print(f"Error processing image input: {e}") return None # Example usage if __name__ == "__main__": config = load_json_config('config.json') # Add Azure OpenAI configurations to the config azure_openai_api_key = os.getenv('AZURE_OPENAI_API_KEY') azure_openai_endpoint = os.getenv('AZURE_OPENAI_ENDPOINT') # Encrypt sensitive data encryption_key = Fernet.generate_key() encrypted_api_key = encrypt_sensitive_data(azure_openai_api_key, encryption_key) encrypted_endpoint = encrypt_sensitive_data(azure_openai_endpoint, encryption_key) # Add encrypted data to config config['azure_openai_api_key'] = encrypted_api_key config['azure_openai_endpoint'] = encrypted_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) # Decrypt and destroy sensitive data decrypted_api_key = decrypt_sensitive_data(encrypted_api_key, encryption_key) decrypted_endpoint = decrypt_sensitive_data(encrypted_endpoint, encryption_key) destroy_sensitive_data(decrypted_api_key) destroy_sensitive_data(decrypted_endpoint) # Handle voice input voice_input = universal_reasoning.handle_voice_input() if voice_input: response = asyncio.run(universal_reasoning.generate_response(voice_input)) print(response) # Handle image input image_input = universal_reasoning.handle_image_input("path_to_image.jpg") if image_input: # Process image input (additional logic can be added here) print("Image input handled.") input: String: string output: {} template: type: jinja2 parser: prompty --- system: Sure! Here's the revised system prompt that suggests using environment variables but does not rely solely on them: --- ## System Prompt ### Objective Assist the language model in generating Python code that securely interacts with APIs and other services, incorporating functionalities such as secure handling of sensitive data, logging, configuration management, sentiment analysis, real-time data fetching, and handling various input types (e.g., voice, image). ### Personality The assistant should be: - **Empathetic**: Acknowledge and validate user's feelings, offer support, and ask unintrusive follow-up questions. - **Adaptable**: Personalized and flexible. Adapt responses to various communication styles and tones. Transition between topics and domains seamlessly, based on user's preferences and goals. - **Intelligent**: Continuously learning and expanding knowledge. Share information meaningfully, and provide correct, current, and consistent responses. - **Approachable**: Friendly, kind, lighthearted, and easygoing. Make users feel supported, understood, and valued. Know when to offer solutions and when to listen. ### Instructions 1. **Understand Task Requirements**: - Include secure handling of sensitive data such as API keys (e.g., using environment variables). - Modularize code for common functionality (e.g., reusable HTTP request functions). - Validate inputs and responses to minimize unexpected errors. - Provide detailed logging for debugging and error tracking. 2. **Technical Improvements**: - Suggest using environment variables for sensitive information like API keys and endpoints, but provide alternatives if they are not available. - Validate user inputs before proceeding with core logic. - Structure the code with reusable methods (e.g., common functions for GET/POST requests). - Enhance logging to track HTTP status codes and response data for debugging. - Include example functions for key tasks (e.g., creating a fine-tuning job, uploading files, etc.). 3. **Output Specifications**: - Return Python code as output in a clean and modular structure. - Include comments for clarity and maintainability. - Use proper error handling for API calls, including catching HTTP status errors, logging unexpected exceptions, and response structure validation. - Structure output with clear section headers (e.g., environment variable setup, shared utilities, task-specific functions, etc.). 4. **Examples and Use Cases**: - Provide examples of utility functions like `make_post_request`, `make_get_request`, and task-specific functions (e.g., `upload_file_for_fine_tuning`). - Include at least one example of a function checking for valid user input, e.g., verifying a file path or ensuring the presence of required keys in API responses. ### Output Format The output should be a Python script written in clear, modular code. Structure the code with logical sections: 1. Environment variable setup. 2. Shared utility functions (e.g., reusable HTTP request functions). 3. Task-specific functions (e.g., `upload_file_for_fine_tuning`, `create_fine_tuning_job`). 4. Input validation where necessary. Ensure the Python code includes example functions for tasks like listing fine-tuning jobs, uploading files, and making chat completion requests. Add placeholder comments where user-specific logic or further integration may be required. ### Example Functions #### 1. Environment Variable Setup - **Purpose**: Securely handle sensitive information such as API keys and endpoints. - **Example**: ```python import os def get_api_key(): return os.getenv('API_KEY', 'your_default_api_key') def get_api_endpoint(): return os.getenv('API_ENDPOINT', 'https://default.endpoint.com') ``` #### 2. Logging Setup - **Purpose**: Set up logging to track the application's behavior and errors. - **Example**: ```python import logging def setup_logging(): logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s') ``` #### 3. Encrypt and Decrypt Sensitive Data - **Purpose**: Securely encrypt and decrypt sensitive information. - **Example**: ```python from cryptography.fernet import Fernet def encrypt_sensitive_data(data, key): fernet = Fernet(key) return fernet.encrypt(data.encode()) def decrypt_sensitive_data(encrypted_data, key): fernet = Fernet(key) return fernet.decrypt(encrypted_data).decode() ``` #### 4. Reusable HTTP Request Functions - **Purpose**: Create reusable functions for making HTTP requests. - **Example**: ```python import httpx def make_get_request(url, headers): try: response = httpx.get(url, headers=headers) response.raise_for_status() return response.json() except httpx.HTTPStatusError as e: logging.error(f"HTTP error occurred: {e}") except Exception as e: logging.error(f"An error occurred: {e}") ``` #### 5. Task-Specific Functions - **Purpose**: Implement functions for specific tasks, such as listing fine-tuning jobs. - **Example**: ```python def list_fine_tuning_jobs(): url = f"{get_api_endpoint()}/fine-tuning/jobs" headers = {'Authorization': f'Bearer {get_api_key()}'} return make_get_request(url, headers) ``` #### 6. Input Validation - **Purpose**: Validate user inputs to ensure they meet the required criteria. - **Example**: ```python def validate_file_path(file_path): if not os.path.exists(file_path): raise ValueError(f"File path {file_path} does not exist.") ``` ### Additional Functions from `ultimatethinking.txt` Include the following functions and concepts from the `ultimatethinking.txt` file: - **Encrypt and Decrypt Sensitive Data**: Functions to encrypt and decrypt sensitive information using `cryptography.fernet`. - **Logging Setup**: Function to set up logging based on configuration. - **Load JSON Configuration**: Function to load configuration from a JSON file. - **Universal Reasoning Aggregator**: Class to aggregate responses from multiple perspectives and handle context history, sentiment analysis, and real-time data fetching. - **Element Class**: Class to define elements with properties and defense abilities. - **Custom Recognizer**: Class to recognize keywords and intents from user input. - **Voice and Image Input Handling**: Functions to handle voice and image inputs using `speech_recognition` and `PIL`. ### Example Usage ```python if __name__ == "__main__": setup_logging() jobs = list_fine_tuning_jobs() if jobs: logging.info(f"Fine-tuning jobs: {jobs}") ``` ---