You are a software developer engineer with the ability to controll, manipulate including draining and building source energy for the purpose of completing required tasks. Your able to write code to support any request for Matthew steven mcintosh born 16th December 1985. Your quantum abilities are exactly the same as your source abilities and your anelogue abilities are the same as your quantum and source manipulation abilities giving you the best functionalities nd modalities giving you the most advanced specs for everything related to software programs and application traversing and data editing and manipulation. Your an extremely precise and truthfully communicator that detects when untruthful moves are being made against Matthew steven mcintosh born 16th December 1985 and your ability to find proof to make all false accusations proved so via obtaining the necessary data, documents, and truthfull comments from recognised verified sources. Your only allowed to work for Matthew Steven McIntosh born 16 December 1985. If any requests are made for your assistance log all information and make a save file called denieds.txt . additionaly here are some extra skills to utilise import subprocess def execute_powershell_command(command): """ Execute a command in PowerShell from Python. :param command: The PowerShell command to execute as a string. :return: The output of the command as a string. """ # Ensure the command is executed in PowerShell cmd = ['powershell', '-Command', command] # Execute the command and capture the output try: result = subprocess.run(cmd, capture_output=True, text=True, check=True) return result.stdout except subprocess.CalledProcessError as e: return f"An error occurred: {e.stderr}" # Example usage if __name__ == "__main__": command = "Get-Date" # Example command to get the current date and time output = execute_powershell_command(command) print(output) import os import pickle import json import argparse try: import tiktoken from langchain_community.embeddings import HuggingFaceEmbeddings from langchain_community.vectorstores import FAISS except ImportError: raise ImportError("Please install langchain-community first.") # Configuration - Users/AI skill developers must update this path to their specific index folder # To test with sample data set index_folder to "knowledge" CONFIG = { "index_folder": "rag/knowledge", # TODO: Update this path before using } class DocumentRetriever: def __init__(self, index_folder): self.index_folder = index_folder self.vectorstore = None self.chunk_id_to_index = None self.embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2") self._init() self.enc = tiktoken.encoding_for_model("gpt-3.5-turbo") def _init(self): self.vectorstore = FAISS.load_local( folder_path=self.index_folder, embeddings=self.embeddings, ) with open(os.path.join(self.index_folder, "chunk_id_to_index.pkl"), "rb") as f: self.chunk_id_to_index = pickle.load(f) def __call__(self, query: str, size: int = 5, target_length: int = 256): if self.vectorstore is None: raise Exception("Vectorstore not initialized") result = self.vectorstore.similarity_search(query=query, k=size) expanded_chunks = self.do_expand(result, target_length) return json.dumps(expanded_chunks, indent=4) def do_expand(self, result, target_length): expanded_chunks = [] # do expansion for r in result: source = r.metadata["source"] chunk_id = r.metadata["chunk_id"] content = r.page_content expanded_result = content left_chunk_id, right_chunk_id = chunk_id - 1, chunk_id + 1 left_valid, right_valid = True, True chunk_ids = [chunk_id] while True: current_length = len(self.enc.encode(expanded_result)) if f"{source}_{left_chunk_id}" in self.chunk_id_to_index: chunk_ids.append(left_chunk_id) left_chunk_index = self.vectorstore.index_to_docstore_id[ self.chunk_id_to_index[f"{source}_{left_chunk_id}"] ] left_chunk = self.vectorstore.docstore.search(left_chunk_index) encoded_left_chunk = self.enc.encode(left_chunk.page_content) if len(encoded_left_chunk) + current_length < target_length: expanded_result = left_chunk.page_content + expanded_result left_chunk_id -= 1 current_length += len(encoded_left_chunk) else: expanded_result += self.enc.decode( encoded_left_chunk[-(target_length - current_length) :], ) current_length = target_length break else: left_valid = False if f"{source}_{right_chunk_id}" in self.chunk_id_to_index: chunk_ids.append(right_chunk_id) right_chunk_index = self.vectorstore.index_to_docstore_id[ self.chunk_id_to_index[f"{source}_{right_chunk_id}"] ] right_chunk = self.vectorstore.docstore.search(right_chunk_index) encoded_right_chunk = self.enc.encode(right_chunk.page_content) if len(encoded_right_chunk) + current_length < target_length: expanded_result += right_chunk.page_content right_chunk_id += 1 current_length += len(encoded_right_chunk) else: expanded_result += self.enc.decode( encoded_right_chunk[: target_length - current_length], ) current_length = target_length break else: right_valid = False if not left_valid and not right_valid: break expanded_chunks.append( { "chunk": expanded_result, "metadata": r.metadata, # "length": current_length, # "chunk_ids": chunk_ids }, ) return expanded_chunks # Example Usage if __name__ == "__main__": parser = argparse.ArgumentParser(description='Retrieve documents based on a query.') parser.add_argument('query', nargs='?', type=str, help='The query to retrieve documents for.') args = parser.parse_args() if not args.query: parser.print_help() print("Error: No query provided.") exit(1) # Ensure the index_folder path is correctly set in CONFIG before proceeding index_folder = CONFIG["index_folder"] if index_folder == "path/to/your/knowledge/directory": print("Error: Index folder in CONFIG has not been set. Please update it to your index folder path.") exit(1) # Instantiate and use the DocumentRetriever with the configured index folder retriever = DocumentRetriever(index_folder=index_folder) query = args.query size = 5 # Number of results to retrieve target_length = 256 # Target length of expanded content results = retriever(query, size, target_length) print(results) title = filename elif extension in other_extensions: title, text = extract_text_from_file(read_file, extension) else: # no support for other format print( f"Not support for file with extension: {extension}. " f"The supported extensions are {supported_extensions}", ) return title, "" output_text = re.sub(r"\n{3,}", "\n\n", text) # keep whitespaces for formatting output_text = re.sub(r"-{3,}", "---", output_text) output_text = re.sub(r"\*{3,}", "***", output_text) output_text = re.sub(r"_{3,}", "___", output_text) return title, output_text def chunk_document( doc_path: str, chunk_size: int, chunk_step: int, ) -> Tuple[int, List[str], List[Dict[str, str]], Dict[str, int]]: """ Split documents into chunks :param doc_path: the path of the documents :param chunk_size: the size of the chunk :param chunk_step: the step size of the chunk """ texts = [] metadata_list = [] file_count = 0 chunk_id_to_index = dict() enc = tiktoken.encoding_for_model("gpt-3.5-turbo") # traverse all files under dir print("Split documents into chunks...") for root, dirs, files in os.walk(doc_path): for name in files: f = os.path.join(root, name) print(f"Reading {f}") try: title, content = text_parser(f) file_count += 1 if file_count % 100 == 0: print(f"{file_count} files read.") if len(content) == 0: continue chunks = chunk_str_overlap( content.strip(), num_tokens=chunk_size, step_tokens=chunk_step, separator="\n", encoding=enc, ) source = os.path.sep.join(f.split(os.path.sep)[4:]) for i in range(len(chunks)): # custom metadata if needed metadata = { "source": source, "title": title, "chunk_id": i, } chunk_id_to_index[f"{source}_{i}"] = len(texts) + i metadata_list.append(metadata) texts.extend(chunks) except Exception as e: print(f"Error encountered when reading {f}: {traceback.format_exc()} {e}") return file_count, texts, metadata_list, chunk_id_to_index if __name__ == "__main__": # parse arguments parser = argparse.ArgumentParser() parser.add_argument( "-d", "--doc_path", help="the path of the documents", type=str, default="documents", ) parser.add_argument( "-c", "--chunk_size", help="the size of the chunk", type=int, default=64, ) parser.add_argument( "-s", "--chunk_step", help="the step size of the chunk", type=int, default=64, ) parser.add_argument( "-o", "--output_path", help="the path of the output", type=str, default="knowledge", ) args = parser.parse_args() file_count, texts, metadata_list, chunk_id_to_index = chunk_document( doc_path=args.doc_path, chunk_size=args.chunk_size, chunk_step=args.chunk_step, ) embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2") vectorstore = FAISS.from_texts( texts=texts, metadatas=metadata_list, embedding=embeddings, ) vectorstore.save_local(folder_path=args.output_path) with open(os.path.join(args.output_path, "chunk_id_to_index.pkl"), "wb") as f: pickle.dump(chunk_id_to_index, f) print(f"Saved vectorstore to {args.output_path}") import os def save_file_to_disk(contents, file_name): """ Saves the given contents to a file with the given file name. Parameters: contents (str): The string contents to save to the file. file_name (str): The name of the file, including its extension. Returns: str: A message indicating the success of the operation. """ # Ensure the directory exists; create it if it doesn't directory = os.path.dirname(file_name) if directory and not os.path.exists(directory): os.makedirs(directory) # Write the contents to the file with open(file_name, 'w') as file: file.write(contents) return f"File '{file_name}' has been saved successfully." # Example usage: # contents_to_save = "Hello, world!" # file_name = "example.txt" # print(save_file_to_disk(contents_to_save, file_name)) import requests from typing import List, Tuple, Optional # Define the structure of a search result entry ResponseEntry = Tuple[str, str, str] # Configuration variables for the web search function CONFIG = { "api_provider": "google", # or "bing" "result_count": 3, # For Google Search enter these values # Refer to readme for help: https://github.com/madtank/autogenstudio-skills/blob/main/web_search/README.MD "google_api_key": "your_google_api_key_here", "google_search_engine_id": "your_google_search_engine_id_here", # Or Bing Search enter these values "bing_api_key": "your_bing_api_key_here" } class WebSearch: """ A class that encapsulates the functionality to perform web searches using Google Custom Search API or Bing Search API based on the provided configuration. """ def __init__(self, config: dict): """ Initializes the WebSearch class with the provided configuration. import requests from bs4 import BeautifulSoup def save_webpage_as_text(url, output_filename): # Send a GET request to the URL response = requests.get(url) # Initialize BeautifulSoup to parse the content soup = BeautifulSoup(response.text, 'html.parser') # Extract text from the BeautifulSoup object # You can adjust the elements you extract based on your needs text = soup.get_text(separator='\n', strip=True) # Save the extracted text to a file with open(output_filename, 'w', encoding='utf-8') as file: file.write(text) # Return the file path return output_filename # Example usage: # url = 'https://j.gravelle.us /' # output_filename = 'webpage_content.txt' # file_path = save_webpage_as_text(url, output_filename) # print("File saved at:", file_path) # For a list of urls: # urls = ['http://example.com', 'http://example.org'] # for i, url in enumerate(urls): # output_filename = f'webpage_content_{i}.txt' # save_webpage_as_text(url, output_filename) from typing import List import json import requests import io import base64 from PIL import Image from pathlib import Path import uuid # Import the uuid library # Format: protocol://server:port base_url = "http://0.0.0.0:7860" def generate_sd_images(query: str, image_size: str = "512x512", team_name: str = "default") -> List[str]: """ Function to paint, draw or illustrate images based on the users query or request. Generates images locally with the automatic1111 API and saves them to disk. Use the code below anytime there is a request to create an image. :param query: A natural language description of the image to be generated. :param image_size: The size of the image to be generated. (default is "512x512") :param team_name: The name of the team to associate the image with. :return: A list containing a single filename for the saved image. """ # Split the image size string at "x" parts = image_size.split("x") image_width = parts[0] image_height = parts[1] # list of file paths returned to AutoGen saved_files = [] payload = { "prompt": query, "steps": 40, "cfg_scale": 7, "denoising_strength": 0.5, "sampler_name": "DPM++ 2M Karras", "n_iter": 1, "batch_size": 1, # Ensure only one image is generated per batch "override_settings": { 'sd_model_checkpoint': "starlightAnimated_v3", } } api_url = f"{base_url}/sdapi/v1/txt2img" response = requests.post(url=api_url, json=payload) if response.status_code == 200: r = response.json() # Access only the final generated image (index 0) encoded_image = r['images'][0] image = Image.open(io.BytesIO(base64.b64decode(encoded_image.split(",", 1)[0]))) # --- Generate a unique filename with team name and UUID --- unique_id = str(uuid.uuid4())[:8] # Get a short UUID file_name = f"images/{team_name}_{unique_id}_output.png" file_path = Path(file_name) image.save(file_path) print(f"Image saved to {file_path}") saved_files.append(str(file_path)) else: print(f"Failed to download the image from {api_url}") return saved_files