semantio 0.0.1__py3-none-any.whl

semantio/tools/duckduckgo.py

@@ -0,0 +1,128 @@
+# duckduckgo.py
+from .base_tool import BaseTool
+from duckduckgo_search import DDGS
+from typing import Dict, Any, List, Optional
+from pydantic import Field
+
+class DuckDuckGo(BaseTool):
+    enable_web_search: bool = Field(default=True, description="Enable web search functionality.")
+    enable_news_search: bool = Field(default=False, description="Enable news search functionality.")
+    enable_image_search: bool = Field(default=False, description="Enable image search functionality.")
+    enable_video_search: bool = Field(default=False, description="Enable video search functionality.")
+    region: Optional[str] = Field(default="wt-wt", description="Region for search results (e.g., 'us-en', 'fr-fr').")
+    safesearch: str = Field(default="moderate", description="Safesearch filter ('on', 'moderate', 'off').")
+    time_range: Optional[str] = Field(default=None, description="Time range for search results ('d', 'w', 'm', 'y').")
+
+    def __init__(self, **kwargs):
+        super().__init__(name="DuckDuckGo", description="Perform web, news, image, and video searches using DuckDuckGo.", **kwargs)
+
+    def execute(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute a search using DuckDuckGo based on the provided input.
+
+        Args:
+            input_data (Dict[str, Any]): Input data containing the query and optional parameters.
+
+        Returns:
+            Dict[str, Any]: Search results for the requested types.
+        """
+        query = input_data.get("query", "")
+        max_results = input_data.get("max_results", 5)  # Default to 5 results
+        region = input_data.get("region", self.region)
+        safesearch = input_data.get("safesearch", self.safesearch)
+        time_range = input_data.get("time_range", self.time_range)
+
+        results = {}
+
+        # Perform web search
+        if self.enable_web_search:
+            results["web"] = self._perform_search(
+                query, max_results, region, safesearch, time_range, search_type="text"
+            )
+
+        # Perform news search
+        if self.enable_news_search:
+            results["news"] = self._perform_search(
+                query, max_results, region, safesearch, time_range, search_type="news"
+            )
+
+        # Perform image search
+        if self.enable_image_search:
+            results["images"] = self._perform_search(
+                query, max_results, region, safesearch, time_range, search_type="images"
+            )
+
+        # Perform video search
+        if self.enable_video_search:
+            results["videos"] = self._perform_search(
+                query, max_results, region, safesearch, time_range, search_type="videos"
+            )
+
+        return results
+
+    def _perform_search(
+        self,
+        query: str,
+        max_results: int,
+        region: str,
+        safesearch: str,
+        time_range: Optional[str],
+        search_type: str,
+    ) -> List[Dict[str, Any]]:
+        """
+        Perform a search using DuckDuckGo.
+
+        Args:
+            query (str): The search query.
+            max_results (int): Maximum number of results to return.
+            region (str): Region for search results.
+            safesearch (str): Safesearch filter.
+            time_range (Optional[str]): Time range for search results.
+            search_type (str): Type of search ("text", "news", "images", "videos").
+
+        Returns:
+            List[Dict[str, Any]]: List of search results.
+        """
+        with DDGS() as ddgs:
+            if search_type == "text":
+                return list(
+                    ddgs.text(
+                        keywords=query,
+                        max_results=max_results,
+                        region=region,
+                        safesearch=safesearch,
+                        timelimit=time_range,
+                    )
+                )
+            elif search_type == "news":
+                return list(
+                    ddgs.news(
+                        keywords=query,
+                        max_results=max_results,
+                        region=region,
+                        safesearch=safesearch,
+                        timelimit=time_range,
+                    )
+                )
+            elif search_type == "images":
+                return list(
+                    ddgs.images(
+                        keywords=query,
+                        max_results=max_results,
+                        region=region,
+                        safesearch=safesearch,
+                        timelimit=time_range,
+                    )
+                )
+            elif search_type == "videos":
+                return list(
+                    ddgs.videos(
+                        keywords=query,
+                        max_results=max_results,
+                        region=region,
+                        safesearch=safesearch,
+                        timelimit=time_range,
+                    )
+                )
+            else:
+                raise ValueError(f"Unsupported search type: {search_type}")

semantio/tools/stocks.py

@@ -0,0 +1,131 @@
+from .base_tool import BaseTool
+import yfinance as yf
+from typing import Dict, Any, List, Optional
+from pydantic import Field
+import logging
+import re
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class StockPriceChecker(BaseTool):
+    default_symbol: str = Field(default="AAPL", description="Default stock symbol (e.g., 'AAPL').")
+    enable_historical_data: bool = Field(default=True, description="Enable fetching historical data.")
+    enable_multiple_symbols: bool = Field(default=True, description="Enable fetching data for multiple stocks.")
+    enable_metrics: bool = Field(default=True, description="Enable additional metrics like volume and market cap.")
+    llm: Optional[Any] = Field(None, description="The LLM instance to use for symbol extraction.")
+
+    def __init__(self, **kwargs):
+        super().__init__(
+            name="StockPriceChecker",
+            description="Fetch real-time and historical stock prices and metrics.",
+            **kwargs
+        )
+
+    def execute(self, input_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Execute the stock price check based on the provided input.
+
+        Args:
+            input_data (Dict[str, Any]): Input data containing the query and optional parameters.
+
+        Returns:
+            Dict[str, Any]: Stock price and additional metrics.
+        """
+        try:
+            query = input_data.get("query", "")
+            symbols = self._extract_symbols(query) if query else [self.default_symbol]
+            time_range = input_data.get("time_range", "1d")  # Default to 1 day
+            metrics = input_data.get("metrics", ["price"])  # Default to price only
+
+            results = {}
+
+            for symbol in symbols:
+                # Validate the symbol
+                if not self._is_valid_symbol(symbol):
+                    logger.warning(f"Invalid stock symbol: {symbol}")
+                    results[symbol] = {"error": "Invalid symbol"}
+                    continue
+
+                try:
+                    stock = yf.Ticker(symbol)
+                    data = {}
+
+                    # Fetch real-time price
+                    if "price" in metrics:
+                        history = stock.history(period=time_range)
+                        if not history.empty:
+                            data["price"] = history["Close"].iloc[-1]
+                        else:
+                            data["price"] = "No data available"
+
+                    # Fetch historical data
+                    if self.enable_historical_data and "history" in metrics:
+                        history = stock.history(period=time_range)
+                        if not history.empty:
+                            data["history"] = history.to_dict()
+                        else:
+                            data["history"] = "No historical data available"
+
+                    # Fetch additional metrics
+                    if self.enable_metrics:
+                        info = stock.info
+                        if "volume" in metrics:
+                            data["volume"] = info.get("volume", "No volume data available")
+                        if "market_cap" in metrics:
+                            data["market_cap"] = info.get("marketCap", "No market cap data available")
+
+                    results[symbol] = data
+                except Exception as e:
+                    results[symbol] = {"error": str(e)}
+
+            return results
+        except Exception as e:
+            return {"error": str(e)}
+
+    def _extract_symbols(self, query: str) -> List[str]:
+        """
+        Use the LLM to extract stock symbols from the user's query.
+        """
+        if not self.llm:
+            logger.error("LLM instance not available for symbol extraction.")
+            return []
+
+        # Create a prompt for the LLM
+        prompt = f"""
+        Extract the stock symbols from the following user query. 
+        Return ONLY the symbols as a comma-separated list (e.g., "AAPL,MSFT"). 
+        Do not include any explanations or additional text. 
+        If no symbols are found, return "None".
+
+        User Query: "{query}"
+        """
+
+        try:
+            # Call the LLM to generate the response
+            response = self.llm.generate(prompt=prompt)
+            logger.info(f"LLM response: {response}")
+            symbols = response.strip().replace('"', '').replace("'", "")
+
+            # Fallback: Extract symbols from verbose responses
+            if ":" in symbols or "\n" in symbols:
+                # Look for patterns like "AAPL,MSFT" in the response
+                symbol_pattern = re.compile(r"\b[A-Z]{1,5}\b")
+                symbols = ",".join(symbol_pattern.findall(symbols))
+                logger.info(f"Extracted symbols: {symbols}")
+
+            # Parse the response into a list of symbols
+            if symbols.lower() == "none":
+                return []
+            return [s.strip() for s in symbols.split(",")]
+        except Exception as e:
+            logger.error(f"Failed to extract symbols: {e}")
+            return []
+
+    def _is_valid_symbol(self, symbol: str) -> bool:
+        """
+        Validate if the symbol is a valid stock symbol.
+        """
+        # Check if the symbol is a valid stock ticker (e.g., AAPL, MSFT)
+        return bool(symbol.strip()) and symbol.isalpha() and 1 <= len(symbol) <= 5

semantio/tools/web_browser.py

@@ -0,0 +1,153 @@
+from typing import Dict, Any, Optional, List
+from playwright.async_api import async_playwright
+import asyncio
+import logging
+
+logger = logging.getLogger(__name__)
+
+class WebBrowserTool:
+    """
+    A tool for performing browser automation tasks using Playwright.
+    """
+
+    def __init__(self, headless: bool = True):
+        """
+        Initialize the WebBrowserTool.
+
+        Args:
+            headless (bool): Whether to run the browser in headless mode (default: True).
+        """
+        self.headless = headless
+        self.browser = None
+        self.context = None
+        self.page = None
+
+    async def start(self):
+        """
+        Start the browser and create a new context and page.
+        """
+        self.playwright = await async_playwright().start()
+        self.browser = await self.playwright.chromium.launch(headless=self.headless)
+        self.context = await self.browser.new_context()
+        self.page = await self.context.new_page()
+        logger.info("Browser started successfully.")
+
+    async def close(self):
+        """
+        Close the browser and cleanup resources.
+        """
+        if self.browser:
+            await self.browser.close()
+        await self.playwright.stop()
+        logger.info("Browser closed successfully.")
+
+    async def navigate(self, url: str) -> str:
+        """
+        Navigate to a specific URL.
+
+        Args:
+            url (str): The URL to navigate to.
+
+        Returns:
+            str: The page title after navigation.
+        """
+        if not self.page:
+            raise RuntimeError("Browser is not started. Call start() first.")
+
+        await self.page.goto(url)
+        title = await self.page.title()
+        logger.info(f"Navigated to {url}. Page title: {title}")
+        return title
+
+    async def fill_form(self, fields: Dict[str, str]) -> str:
+        """
+        Fill a form with the provided fields.
+
+        Args:
+            fields (Dict[str, str]): A dictionary of field names and values to fill.
+
+        Returns:
+            str: A success message.
+        """
+        if not self.page:
+            raise RuntimeError("Browser is not started. Call start() first.")
+
+        for field, value in fields.items():
+            await self.page.fill(f'input[name="{field}"]', value)
+            logger.info(f"Filled field '{field}' with value '{value}'.")
+
+        return "Form filled successfully."
+
+    async def click(self, selector: str) -> str:
+        """
+        Click an element on the page.
+
+        Args:
+            selector (str): The CSS selector of the element to click.
+
+        Returns:
+            str: A success message.
+        """
+        if not self.page:
+            raise RuntimeError("Browser is not started. Call start() first.")
+
+        await self.page.click(selector)
+        logger.info(f"Clicked element with selector '{selector}'.")
+        return f"Clicked element: {selector}"
+
+    async def scrape(self, selector: str) -> List[Dict[str, str]]:
+        """
+        Scrape data from the page.
+
+        Args:
+            selector (str): The CSS selector of the elements to scrape.
+
+        Returns:
+            List[Dict[str, str]]: A list of dictionaries containing the scraped data.
+        """
+        if not self.page:
+            raise RuntimeError("Browser is not started. Call start() first.")
+
+        elements = await self.page.query_selector_all(selector)
+        scraped_data = []
+        for element in elements:
+            text = await element.inner_text()
+            scraped_data.append({"text": text.strip()})
+            logger.info(f"Scraped text: {text.strip()}")
+
+        return scraped_data
+
+    async def execute_step(self, step: Dict[str, Any]) -> str:
+        """
+        Execute a browser automation step.
+
+        Args:
+            step (Dict[str, Any]): A dictionary containing the step details.
+                - "action": The action to perform (e.g., "navigate", "fill_form", "click", "scrape").
+                - "details": The details required for the action (e.g., URL, form fields, selector).
+                - "website": The website to perform the action on (optional).
+
+        Returns:
+            str: The result of the step execution.
+        """
+        action = step.get("action")
+        details = step.get("details")
+        website = step.get("website", "https://www.google.com")
+
+        if not self.page:
+            await self.start()
+
+        try:
+            if action == "navigate":
+                return await self.navigate(details)
+            elif action == "fill_form":
+                return await self.fill_form(details)
+            elif action == "click":
+                return await self.click(details)
+            elif action == "scrape":
+                return str(await self.scrape(details))
+            else:
+                return f"Unknown action: {action}"
+        except Exception as e:
+            logger.error(f"Error executing step: {e}")
+            return f"Error executing step: {e}"

semantio/utils/__init__.py

@@ -0,0 +1,7 @@
+from .logger import logger
+from .config import Config
+from .file_utils import FileUtils
+from .date_utils import DateUtils
+from .validation_utils import ValidationUtils
+
+__all__ = ["logger", "Config", "FileUtils", "DateUtils", "ValidationUtils"]

semantio/utils/config.py

@@ -0,0 +1,41 @@
+import os
+from dotenv import load_dotenv
+from pathlib import Path
+from typing import Any, Optional, Type, TypeVar, List, Dict
+
+# Load environment variables from .env file
+load_dotenv()
+
+class Config:
+    """
+    Configuration class to load and manage environment variables.
+    """
+
+    @staticmethod
+    def get(key: str, default: Optional[str] = None) -> str:
+        """
+        Get an environment variable. Raise an error if it's not found and no default is provided.
+        """
+        value = os.getenv(key, default)
+        if value is None:
+            raise ValueError(f"Environment variable {key} is not set.")
+        return value
+
+    @staticmethod
+    def get_bool(key: str, default: bool = False) -> bool:
+        """
+        Get an environment variable as a boolean.
+        """
+        value = os.getenv(key, str(default)).lower()
+        return value in ("true", "1", "yes")
+
+    @staticmethod
+    def get_int(key: str, default: int = 0) -> int:
+        """
+        Get an environment variable as an integer.
+        """
+        return int(os.getenv(key, str(default)))
+
+# Example usage:
+# GROQ_API_KEY = Config.get("GROQ_API_KEY")
+# MAX_RETRIES = Config.get_int("MAX_RETRIES", 5)

semantio/utils/date_utils.py

@@ -0,0 +1,44 @@
+from datetime import datetime, timedelta
+from typing import Optional
+
+class DateUtils:
+    @staticmethod
+    def get_current_time() -> str:
+        """
+        Get the current time in ISO format.
+        """
+        return datetime.now().isoformat()
+
+    @staticmethod
+    def format_time(timestamp: str, format: str = "%Y-%m-%d %H:%M:%S") -> str:
+        """
+        Format a timestamp string into a custom format.
+        """
+        try:
+            dt = datetime.fromisoformat(timestamp)
+            return dt.strftime(format)
+        except Exception as e:
+            raise ValueError(f"Failed to format timestamp {timestamp}: {e}")
+
+    @staticmethod
+    def add_time(timestamp: str, days: int = 0, hours: int = 0, minutes: int = 0) -> str:
+        """
+        Add days, hours, or minutes to a timestamp.
+        """
+        try:
+            dt = datetime.fromisoformat(timestamp)
+            dt += timedelta(days=days, hours=hours, minutes=minutes)
+            return dt.isoformat()
+        except Exception as e:
+            raise ValueError(f"Failed to add time to timestamp {timestamp}: {e}")
+
+    @staticmethod
+    def is_future_time(timestamp: str) -> bool:
+        """
+        Check if a timestamp is in the future.
+        """
+        try:
+            dt = datetime.fromisoformat(timestamp)
+            return dt > datetime.now()
+        except Exception as e:
+            raise ValueError(f"Failed to check if timestamp {timestamp} is in the future: {e}")

semantio/utils/file_utils.py

@@ -0,0 +1,56 @@
+import os
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+class FileUtils:
+    @staticmethod
+    def read_file(file_path: str) -> str:
+        """
+        Read the contents of a file.
+        """
+        try:
+            with open(file_path, "r", encoding="utf-8") as file:
+                return file.read()
+        except Exception as e:
+            raise ValueError(f"Failed to read file {file_path}: {e}")
+
+    @staticmethod
+    def write_file(file_path: str, content: str) -> None:
+        """
+        Write content to a file.
+        """
+        try:
+            with open(file_path, "w", encoding="utf-8") as file:
+                file.write(content)
+        except Exception as e:
+            raise ValueError(f"Failed to write to file {file_path}: {e}")
+
+    @staticmethod
+    def read_json(file_path: str) -> Dict[str, Any]:
+        """
+        Read a JSON file and return its contents as a dictionary.
+        """
+        try:
+            with open(file_path, "r", encoding="utf-8") as file:
+                return json.load(file)
+        except Exception as e:
+            raise ValueError(f"Failed to read JSON file {file_path}: {e}")
+
+    @staticmethod
+    def write_json(file_path: str, data: Dict[str, Any]) -> None:
+        """
+        Write a dictionary to a JSON file.
+        """
+        try:
+            with open(file_path, "w", encoding="utf-8") as file:
+                json.dump(data, file, indent=2)
+        except Exception as e:
+            raise ValueError(f"Failed to write JSON file {file_path}: {e}")
+
+    @staticmethod
+    def ensure_directory_exists(directory: str) -> None:
+        """
+        Ensure that a directory exists. If not, create it.
+        """
+        Path(directory).mkdir(parents=True, exist_ok=True)

semantio/utils/logger.py

@@ -0,0 +1,20 @@
+import logging
+import sys
+from pathlib import Path
+
+# Create a logs directory if it doesn't exist
+logs_dir = Path("logs")
+logs_dir.mkdir(exist_ok=True)
+
+# Logger configuration
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+    handlers=[
+        logging.FileHandler(logs_dir / "agent.log"),  # Log to a file
+        logging.StreamHandler(sys.stdout),  # Log to the console
+    ],
+)
+
+# Create a logger instance
+logger = logging.getLogger("agent")

semantio/utils/validation_utils.py

@@ -0,0 +1,44 @@
+import re
+from typing import Any, Optional
+
+class ValidationUtils:
+    @staticmethod
+    def validate_email(email: str) -> bool:
+        """
+        Validate an email address.
+        """
+        regex = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
+        return re.match(regex, email) is not None
+
+    @staticmethod
+    def validate_phone_number(phone: str) -> bool:
+        """
+        Validate a phone number (basic validation for US numbers).
+        """
+        regex = r"^\+?1?\d{10}$"
+        return re.match(regex, phone) is not None
+
+    @staticmethod
+    def validate_not_empty(value: Any) -> bool:
+        """
+        Validate that a value is not empty.
+        """
+        if isinstance(value, str):
+            return bool(value.strip())
+        elif isinstance(value, (list, dict, set)):
+            return bool(value)
+        return value is not None
+
+    @staticmethod
+    def validate_numeric(value: Any) -> bool:
+        """
+        Validate that a value is numeric (int or float).
+        """
+        return isinstance(value, (int, float))
+
+    @staticmethod
+    def validate_in_range(value: float, min: float, max: float) -> bool:
+        """
+        Validate that a numeric value is within a specified range.
+        """
+        return min <= value <= max

semantio-0.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Syenah
+
+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.