PikoAi 0.1.0__py3-none-any.whl

Tools/file_task.py

@@ -0,0 +1,240 @@
+import os
+from PyPDF2 import PdfReader
+from PyPDF2 import errors as PyPDF2Errors
+import docx
+from docx.opc import exceptions as DocxOpcExceptions
+
+def file_reader(**kwargs) -> dict:
+    """Reads the content of a specified file and returns it.
+    
+    Args:
+        **kwargs: Keyword arguments with 'file_path' specifying the file to read.
+    
+    Returns:
+        Dictionary with 'success' (bool), 'output' (file content or error message).
+    """
+    try:
+        # Validate input
+        if "file_path" not in kwargs:
+            return {"success": False, "output": "Error: 'file_path' is required."}
+        
+        file_path = kwargs["file_path"]
+        
+        # Enhanced Security Checks (Primary Change Area)
+        abs_file_path = os.path.abspath(file_path)
+        normalized_abs_path = abs_file_path.lower()
+
+        # Expanded and normalized forbidden directories
+        # Ensure trailing slashes for directory checks and all lowercase
+        forbidden_dirs = [
+            "/etc/", "/root/", "/sys/", "/proc/", "/dev/", "/boot/", "/sbin/", "/usr/sbin/",
+            "c:\\windows\\", "c:\\program files\\", "c:\\program files (x86)\\",
+            "c:\\users\\default\\", # Added default user for windows
+            "/system/", "/library/", "/private/", "/applications/", "/usr/bin/"
+        ]
+
+        if any(normalized_abs_path.startswith(d) for d in forbidden_dirs):
+            return {"success": False, "output": f"Error: Access to system or restricted directory '{abs_file_path}' is not allowed."}
+
+        # Check for sensitive files/directories in user's home directory
+        try:
+            user_home = os.path.expanduser("~").lower()
+            # Define sensitive files and directories relative to user_home
+            sensitive_home_files = [
+                os.path.join(user_home, ".gitconfig").lower(),
+                os.path.join(user_home, ".bash_history").lower(),
+                os.path.join(user_home, ".zsh_history").lower(),
+                os.path.join(user_home, ".python_history").lower(), # Added from previous patterns
+                os.path.join(user_home, ".npmrc").lower(),        # Added from previous patterns
+                os.path.join(user_home, ".yarnrc").lower(),       # Added from previous patterns
+                os.path.join(user_home, ".gemrc").lower()         # Added from previous patterns
+                # Add other specific sensitive *files* here
+            ]
+            sensitive_home_dirs = [
+                os.path.join(user_home, ".ssh").lower(),
+                os.path.join(user_home, ".aws").lower(),
+                os.path.join(user_home, ".gcloud").lower(), # Changed from .config/gcloud as per request
+                os.path.join(user_home, ".gnupg").lower(),       # Added from previous patterns
+                os.path.join(user_home, ".docker").lower(),      # Added from previous patterns
+                os.path.join(user_home, ".kube").lower()         # Added from previous patterns
+                # Add other specific sensitive *directories* here
+            ]
+
+            if normalized_abs_path in sensitive_home_files:
+                return {"success": False, "output": f"Error: Access to sensitive user configuration file '{normalized_abs_path}' is restricted."}
+
+            if any(normalized_abs_path.startswith(d + os.sep) for d in sensitive_home_dirs): # Check if path starts with any sensitive dir + separator
+                return {"success": False, "output": f"Error: Access to files within sensitive user directory '{os.path.dirname(normalized_abs_path)}' is restricted."}
+
+            # Also, if the path *is* one of the sensitive_home_dirs itself (e.g. trying to read ~/.ssh as a file)
+            if normalized_abs_path in sensitive_home_dirs:
+                return {"success": False, "output": f"Error: Direct access to sensitive user directory '{normalized_abs_path}' is restricted."}
+
+        except Exception: # Broad exception catch
+            # In case of error determining home directory or paths (e.g., os.path.expanduser fails),
+            # proceed with caution. For now, we'll let it pass, but logging this would be advisable.
+            # This means sensitive home path checks might be bypassed if an error occurs here.
+            pass
+
+        # Determine file extension (moved after security checks)
+        _, file_extension = os.path.splitext(file_path)
+        file_extension = file_extension.lower()
+
+        # Check if file exists and is readable (after security checks)
+        if not os.path.isfile(file_path):
+            return {"success": False, "output": f"Error: File '{file_path}' does not exist."}
+        if not os.access(file_path, os.R_OK):
+            return {"success": False, "output": f"Error: No read permission for '{file_path}'."}
+        
+        # Read file content
+        content = ""
+        if file_extension == ".pdf":
+            try:
+                with open(file_path, "rb") as f:
+                    reader = PdfReader(f)
+                    if reader.is_encrypted:
+                        # Attempt to decrypt with an empty password, or handle if not possible.
+                        # For now, we'll assume most encrypted files without passwords are not readable by default.
+                        return {"success": False, "output": f"Error: PDF file '{file_path}' is encrypted and cannot be read without a password."}
+                    for page in reader.pages:
+                        content += page.extract_text() or ""
+            except PyPDF2Errors.FileNotDecryptedError:
+                return {"success": False, "output": f"Error: PDF file '{file_path}' is encrypted and cannot be read."}
+            except PyPDF2Errors.PdfReadError as pe:
+                return {"success": False, "output": f"Error: Could not read PDF file '{file_path}'. It may be corrupted, not a valid PDF, or an unsupported format. Details: {str(pe)}"}
+            except Exception as e: # General fallback for other PDF issues
+                return {"success": False, "output": f"Error processing PDF file '{file_path}': {str(e)}"}
+        elif file_extension == ".docx":
+            try:
+                doc = docx.Document(file_path)
+                for para in doc.paragraphs:
+                    content += para.text + "\n"
+            except DocxOpcExceptions.PackageNotFoundError:
+                return {"success": False, "output": f"Error: File '{file_path}' is not a valid DOCX file, is corrupted, or is not a compatible OOXML package."}
+            except Exception as e: # General fallback for other DOCX issues
+                return {"success": False, "output": f"Error processing DOCX file '{file_path}': {str(e)}"}
+        else: # Fallback to existing plain text reading
+            # Ensure this part also has robust error handling, though it's simpler
+            try:
+                with open(file_path, "r", encoding="utf-8") as f:
+                    content = f.read()
+            except UnicodeDecodeError as ude:
+                return {"success": False, "output": f"Error: Could not decode file '{file_path}' using UTF-8. It might be a binary file or use a different text encoding. Details: {str(ude)}"}
+            except Exception as e: # General fallback for text files
+                return {"success": False, "output": f"Error reading text file '{file_path}': {str(e)}"}
+        
+        return {"success": True, "output": content}
+    
+    except FileNotFoundError: # Specific exception for file not found
+        return {"success": False, "output": f"Error: File '{file_path}' does not exist."} # Redundant if isfile check is perfect, but good practice
+    except PermissionError: # Specific exception for permission issues
+        return {"success": False, "output": f"Error: No read permission for '{file_path}'."} # Redundant if os.access check is perfect
+    except Exception as e:
+        return {"success": False, "output": f"An unexpected error occurred while trying to read '{file_path}': {str(e)}"}
+
+def file_maker(**kwargs) -> dict:
+    """Creates an empty file at the specified path.
+    
+    Args:
+        **kwargs: Keyword arguments with 'file_path' specifying the file to create.
+    
+    Returns:
+        Dictionary with 'success' (bool), 'output' (confirmation or error message).
+    """
+    try:
+        # Validate input
+        if "file_path" not in kwargs:
+            return {"success": False, "output": "Error: 'file_path' is required."}
+        
+        file_path = kwargs["file_path"]
+        
+        # Security check: Prevent creation in sensitive directories
+        forbidden_dirs = ["/etc", "/root", "/sys", "/proc"]
+        if any(file_path.startswith(d) for d in forbidden_dirs):
+            return {"success": False, "output": "Error: Creation in system directories is restricted."}
+        
+        # Check if file already exists
+        if os.path.exists(file_path):
+            return {"success": False, "output": f"Error: File '{file_path}' already exists."}
+        
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        # Create empty file
+        with open(file_path, "w", encoding="utf-8"):
+            pass
+        
+        return {"success": True, "output": f"File '{file_path}' created successfully."}
+    
+    except Exception as e:
+        return {"success": False, "output": f"Error: {str(e)}"}
+
+def file_writer(**kwargs) -> dict:
+    """Writes or appends content to a specified file.
+    
+    Args:
+        **kwargs: Keyword arguments with 'file_path' (str), 'content' (str), and optional 'append' (bool).
+    
+    Returns:
+        Dictionary with 'success' (bool), 'output' (confirmation or error message).
+    """
+    try:
+        # Validate input
+        if "file_path" not in kwargs or "content" not in kwargs:
+            return {"success": False, "output": "Error: 'file_path' and 'content' are required."}
+        
+        file_path = kwargs["file_path"]
+        content = kwargs["content"]
+        append_mode = kwargs.get("append", False)
+        
+        # Security check: Prevent writing to sensitive directories
+        forbidden_dirs = ["/etc", "/root", "/sys", "/proc"]
+        if any(file_path.startswith(d) for d in forbidden_dirs):
+            return {"success": False, "output": "Error: Writing to system directories is restricted."}
+        
+        # Ensure directory exists
+        os.makedirs(os.path.dirname(file_path), exist_ok=True)
+        
+        # Write or append to file
+        mode = "a" if append_mode else "w"
+        with open(file_path, mode, encoding="utf-8") as f:
+            f.write(content)
+        
+        action = "appended to" if append_mode else "written to"
+        return {"success": True, "output": f"Content {action} '{file_path}' successfully."}
+    
+    except Exception as e:
+        return {"success": False, "output": f"Error: {str(e)}"}
+
+def directory_maker(**kwargs) -> dict:
+    """Creates a directory at the specified path.
+    
+    Args:
+        **kwargs: Keyword arguments with 'dir_path' specifying the directory to create.
+    
+    Returns:
+        Dictionary with 'success' (bool), 'output' (confirmation or error message).
+    """
+    try:
+        # Validate input
+        if "dir_path" not in kwargs:
+            return {"success": False, "output": "Error: 'dir_path' is required."}
+        
+        dir_path = kwargs["dir_path"]
+        
+        # Security check: Prevent creation in sensitive directories
+        forbidden_dirs = ["/etc", "/root", "/sys", "/proc"]
+        if any(dir_path.startswith(d) for d in forbidden_dirs):
+            return {"success": False, "output": "Error: Creation in system directories is restricted."}
+        
+        # Check if directory already exists
+        if os.path.exists(dir_path):
+            return {"success": False, "output": f"Error: Directory '{dir_path}' already exists."}
+        
+        # Create directory
+        os.makedirs(dir_path)
+        
+        return {"success": True, "output": f"Directory '{dir_path}' created successfully."}
+    
+    except Exception as e:
+        return {"success": False, "output": f"Error: {str(e)}"}

Tools/system_details.py

@@ -0,0 +1,76 @@
+import platform
+import psutil
+import datetime
+import json
+
+def get_os_details():
+    """Get operating system details"""
+    return {
+        "system": platform.system(),
+        "release": platform.release(),
+        "version": platform.version(),
+        "machine": platform.machine(),
+        "processor": platform.processor()
+    }
+
+def get_datetime():
+    """Get current date and time"""
+    now = datetime.datetime.now()
+    return {
+        "date": now.strftime("%Y-%m-%d"),
+        "time": now.strftime("%H:%M:%S"),
+        "timezone": datetime.datetime.now().astimezone().tzname()
+    }
+
+def get_memory_usage():
+    """Get memory usage details"""
+    memory = psutil.virtual_memory()
+    return {
+        "total": f"{memory.total / (1024**3):.2f} GB",
+        "available": f"{memory.available / (1024**3):.2f} GB",
+        "used": f"{memory.used / (1024**3):.2f} GB",
+        "percent": f"{memory.percent}%"
+    }
+
+def get_cpu_info():
+    """Get CPU information"""
+    return {
+        "physical_cores": psutil.cpu_count(logical=False),
+        "total_cores": psutil.cpu_count(logical=True),
+        "cpu_freq": {
+            "current": f"{psutil.cpu_freq().current:.2f} MHz",
+            "min": f"{psutil.cpu_freq().min:.2f} MHz",
+            "max": f"{psutil.cpu_freq().max:.2f} MHz"
+        },
+        "cpu_usage": f"{psutil.cpu_percent()}%"
+    }
+
+def system_details(detail_type="all"):
+    """
+    Get system details based on the requested type.
+    
+    Args:
+        detail_type (str): Type of system detail to retrieve (os, datetime, memory, cpu, all)
+    
+    Returns:
+        dict: Requested system details
+    """
+    detail_type = detail_type.lower()
+    
+    if detail_type == "all":
+        return {
+            "os": get_os_details(),
+            "datetime": get_datetime(),
+            "memory": get_memory_usage(),
+            "cpu": get_cpu_info()
+        }
+    elif detail_type == "os":
+        return get_os_details()
+    elif detail_type == "datetime":
+        return get_datetime()
+    elif detail_type == "memory":
+        return get_memory_usage()
+    elif detail_type == "cpu":
+        return get_cpu_info()
+    else:
+        raise ValueError(f"Invalid detail type: {detail_type}. Must be one of: os, datetime, memory, cpu, all")

Tools/tool_manager.py

@@ -0,0 +1,51 @@
+import sys
+import os
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '../../')))
+from Src.Tools.web_loader import load_data
+from Src.Tools.web_search import web_search
+from Src.Tools.file_task import file_reader, file_maker, file_writer, directory_maker
+from Src.Tools.system_details import get_os_details, get_datetime, get_memory_usage, get_cpu_info
+from Src.Tools.userinp import get_user_input
+
+#need to transform it into map of dictionary
+#name : [function : xyz,description : blah bah]
+
+tools_function_map = {
+    "web_loader": load_data,
+    "web_search": web_search,
+    "file_maker": file_maker,
+    "file_reader":file_reader,
+    "directory_maker":directory_maker,
+    "file_writer":file_writer,
+    "get_os_details": get_os_details,
+    "get_datetime": get_datetime,
+    "get_memory_usage": get_memory_usage,
+    "get_cpu_info": get_cpu_info,
+    "get_user_input": get_user_input
+}
+
+
+
+def call_tool(tool_name, tool_input):
+    """
+    Calls the appropriate tool function with the given input.
+    
+    Args:
+        tool_name (str): Name of the tool to call
+        tool_input (dict): Input parameters for the tool
+    """
+    if tool_name in tools_function_map:
+        # Pass the tool_input dictionary as kwargs to the tool function
+        return tools_function_map[tool_name](**tool_input)
+    else:
+        raise ValueError(f"Tool '{tool_name}' not found. Check the tools available in the tool directory")
+
+
+# print(call_tool("web_loader","https://www.toastmasters.org"))
+# print(call_tool("web_search","manus ai"))
+# print(call_tool("web_loader",{"url":"https://www.toastmasters.org"}))
+# print(call_tool("file_reader",{"file_path":"/Users/niharshettigar/Web Dev Projects/Jsprograms/Arrays.js"}))
+
+
+
+    

Tools/userinp.py

@@ -0,0 +1,34 @@
+def get_user_input(prompt="Enter input: ", input_type="text"):
+    """
+    Get input from the user with optional type validation.
+    
+    Args:
+        prompt (str): The message to display to the user
+        input_type (str): Type of input to validate (text, number, boolean)
+    
+    Returns:
+        The user's input, converted to the appropriate type
+    """
+    while True:
+        try:
+            user_input = input(prompt)
+            
+            if input_type == "text":
+                return user_input
+            elif input_type == "number":
+                return float(user_input)
+            elif input_type == "boolean":
+                user_input = user_input.lower()
+                if user_input in ["true", "yes", "y", "1"]:
+                    return True
+                elif user_input in ["false", "no", "n", "0"]:
+                    return False
+                else:
+                    print("Please enter 'yes' or 'no'")
+                    continue
+            else:
+                raise ValueError(f"Invalid input type: {input_type}")
+                
+        except ValueError as e:
+            print(f"Invalid input. Please try again. ({str(e)})")
+            continue

Tools/web_loader.py

@@ -0,0 +1,173 @@
+import hashlib
+import logging
+import re
+import requests
+import pdfplumber
+from io import BytesIO
+try:
+    from bs4 import BeautifulSoup
+except ImportError:
+    raise ImportError(
+        'Webpage requires extra dependencies. Install with `pip install --upgrade "embedchain[dataloaders]"`'
+    ) from None
+
+
+def clean_string(text):
+    """
+    This function takes in a string and performs a series of text cleaning operations.
+
+    Args:
+        text (str): The text to be cleaned. This is expected to be a string.
+
+    Returns:
+        cleaned_text (str): The cleaned text after all the cleaning operations
+        have been performed.
+    """
+    # Replacement of newline characters:
+    text = text.replace("\n", " ")
+
+    # Stripping and reducing multiple spaces to single:
+    cleaned_text = re.sub(r"\s+", " ", text.strip())
+
+    # Removing backslashes:
+    cleaned_text = cleaned_text.replace("\\", "")
+
+    # Replacing hash characters:
+    cleaned_text = cleaned_text.replace("#", " ")
+
+    # Eliminating consecutive non-alphanumeric characters:
+    # This regex identifies consecutive non-alphanumeric characters (i.e., not
+    # a word character [a-zA-Z0-9_] and not a whitespace) in the string
+    # and replaces each group of such characters with a single occurrence of
+    # that character.
+    # For example, "!!! hello !!!" would become "! hello !".
+    cleaned_text = re.sub(r"([^\w\s])\1*", r"\1", cleaned_text)
+
+    return cleaned_text
+
+
+def get_clean_content(html, url) -> str:
+    """
+    Clean and extract text from HTML content.
+
+    Args:
+        html (bytes): The HTML content to be cleaned.
+        url (str): The URL of the webpage (for logging purposes).
+
+    Returns:
+        str: The cleaned text content.
+    """
+    soup = BeautifulSoup(html, "html.parser")
+    original_size = len(str(soup.get_text()))
+
+    tags_to_exclude = [
+        "nav",
+        "aside",
+        "form",
+        "header",
+        "noscript",
+        "svg",
+        "canvas",
+        "footer",
+        "script",
+        "style",
+    ]
+    for tag in soup(tags_to_exclude):
+        tag.decompose()
+
+    ids_to_exclude = ["sidebar", "main-navigation", "menu-main-menu"]
+    for id in ids_to_exclude:
+        tags = soup.find_all(id=id)
+        for tag in tags:
+            tag.decompose()
+
+    classes_to_exclude = [
+        "elementor-location-header",
+        "navbar-header",
+        "nav",
+        "header-sidebar-wrapper",
+        "blog-sidebar-wrapper",
+        "related-posts",
+    ]
+    for class_name in classes_to_exclude:
+        tags = soup.find_all(class_=class_name)
+        for tag in tags:
+            tag.decompose()
+
+    content = soup.get_text()
+    content = clean_string(content)
+
+    cleaned_size = len(content)
+    if original_size != 0:
+        logging.info(
+            f"[{url}] Cleaned page size: {cleaned_size} characters, down from {original_size} (shrunk: {original_size-cleaned_size} chars, {round((1-(cleaned_size/original_size)) * 100, 2)}%)"
+        )
+
+    return content
+
+
+def load_data(**kwargs):
+    # Get the url from kwargs, raise error if not found
+    if 'url' not in kwargs:
+        raise ValueError("URL is required but not provided in kwargs")
+    
+    url = kwargs['url']
+    
+    # Alternative way using .get() with error handling
+    # url = kwargs.get('url')
+    # if url is None:
+    #     raise ValueError("URL is required but not provided in kwargs")
+    
+    session = requests.Session()
+
+    headers = {
+        "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_4) AppleWebKit/537.36 (KHTML like Gecko) Chrome/52.0.2743.116 Safari/537.36"
+    }
+    web_data = {}
+    content = ""
+    try:
+        response = session.get(url, headers=headers, timeout=30)
+        response.raise_for_status()
+        data = response.content
+        # Check content type
+        content_type = response.headers.get("Content-Type", "")
+        if "html" in content_type:
+            content = get_clean_content(data, url)
+        elif "pdf" in content_type:
+            # Open the PDF file using pdfplumber
+            with pdfplumber.open(BytesIO(response.content)) as pdf:
+                # Extract text from each page and combine it
+                content = "\n".join([page.extract_text() for page in pdf.pages if page.extract_text()])
+
+        meta_data = {"url": url}
+        doc_id = hashlib.sha256((content + url).encode()).hexdigest()
+        web_data = {
+            "doc_id": doc_id,
+            "data": [
+                {
+                    "content": content,
+                    "meta_data": meta_data,
+                }
+            ],
+        }
+    except Exception as e:
+        logging.error(f"Error loading data from {url}: {e}")
+        web_data = {
+            "data": [
+                {
+                    "content": "",
+                    "meta_data": "",
+                }
+            ],
+        }
+    return web_data
+
+
+def close_session(session):
+    """
+    Close the requests session.
+
+    Args:
+        session (requests.Session): The session to close.
+    """
+    session.close()

Tools/web_search.py

@@ -0,0 +1,30 @@
+from duckduckgo_search import DDGS
+
+def web_search(max_results: int = 10, **kwargs) -> str:
+    """
+    Performs a DuckDuckGo web search based on your query (think a Google search) then returns the top search results.
+
+    Args:
+        query (str): The search query to perform.
+        max_results (int, optional): Maximum number of results to return. Defaults to 10.
+        **kwargs: Additional keyword arguments to pass to DDGS.
+
+    Returns:
+        str: Formatted string containing search results.
+
+    Raises:
+        ImportError: If the duckduckgo_search package is not installed.
+        Exception: If no results are found for the given query.
+    """
+    try:
+        ddgs = DDGS()
+    except ImportError as e:
+        raise ImportError("You must install package `duckduckgo_search` to run this function: for instance run `pip install duckduckgo-search`."
+        ) from e
+    query = kwargs['query']
+    results = ddgs.text(query, max_results=max_results)
+    if len(results) == 0:
+        raise Exception("No results found! Try a less restrictive/shorter query.")
+
+    postprocessed_results = [f"[{result['title']}]({result['href']})\n{result['body']}" for result in results]
+    return "## Search Results\n\n" + "\n\n".join(postprocessed_results)