agno 0.1.2__py3-none-any.whl → 2.3.13__py3-none-any.whl

agno/embedder/huggingface.py

@@ -1,54 +0,0 @@
-import json
-from dataclasses import dataclass
-from os import getenv
-from typing import Any, Dict, List, Optional, Tuple
-
-from agno.embedder.base import Embedder
-from agno.utils.log import logger
-
-try:
-    from huggingface_hub import InferenceClient, SentenceSimilarityInput
-except ImportError:
-    logger.error("`huggingface-hub` not installed, please run `pip install huggingface-hub`")
-    raise
-
-
-@dataclass
-class HuggingfaceCustomEmbedder(Embedder):
-    """Huggingface Custom Embedder"""
-
-    id: str = "jinaai/jina-embeddings-v2-base-code"
-    api_key: Optional[str] = getenv("HUGGINGFACE_API_KEY")
-    client_params: Optional[Dict[str, Any]] = None
-    huggingface_client: Optional[InferenceClient] = None
-
-    @property
-    def client(self) -> InferenceClient:
-        if self.huggingface_client:
-            return self.huggingface_client
-        _client_params: Dict[str, Any] = {}
-        if self.api_key:
-            _client_params["api_key"] = self.api_key
-        if self.client_params:
-            _client_params.update(self.client_params)
-        return InferenceClient(**_client_params)
-
-    def _response(self, text: str):
-        _request_params: SentenceSimilarityInput = {
-            "json": {"inputs": text},
-            "model": self.id,
-        }
-        return self.client.post(**_request_params)
-
-    def get_embedding(self, text: str) -> List[float]:
-        response = self._response(text=text)
-        try:
-            decoded_string = response.decode("utf-8")
-            return json.loads(decoded_string)
-
-        except Exception as e:
-            logger.warning(e)
-            return []
-
-    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
-        return self.get_embedding(text=text), None

agno/embedder/mistral.py

@@ -1,80 +0,0 @@
-from dataclasses import dataclass
-from os import getenv
-from typing import Any, Dict, List, Optional, Tuple
-
-from agno.embedder.base import Embedder
-from agno.utils.log import logger
-
-try:
-    from mistralai import Mistral
-    from mistralai.models.embeddingresponse import EmbeddingResponse
-except ImportError:
-    raise ImportError("`mistralai` not installed")
-
-
-@dataclass
-class MistralEmbedder(Embedder):
-    id: str = "mistral-embed"
-    dimensions: int = 1024
-    # -*- Request parameters
-    request_params: Optional[Dict[str, Any]] = None
-    # -*- Client parameters
-    api_key: Optional[str] = getenv("MISTRAL_API_KEY")
-    endpoint: Optional[str] = None
-    max_retries: Optional[int] = None
-    timeout: Optional[int] = None
-    client_params: Optional[Dict[str, Any]] = None
-    # -*- Provide the Mistral Client manually
-    mistral_client: Optional[Mistral] = None
-
-    @property
-    def client(self) -> Mistral:
-        if self.mistral_client:
-            return self.mistral_client
-
-        _client_params: Dict[str, Any] = {}
-        if self.api_key:
-            _client_params["api_key"] = self.api_key
-        if self.endpoint:
-            _client_params["endpoint"] = self.endpoint
-        if self.max_retries:
-            _client_params["max_retries"] = self.max_retries
-        if self.timeout:
-            _client_params["timeout"] = self.timeout
-        if self.client_params:
-            _client_params.update(self.client_params)
-        return Mistral(**_client_params)
-
-    def _response(self, text: str) -> EmbeddingResponse:
-        _request_params: Dict[str, Any] = {
-            "inputs": text,
-            "model": self.id,
-        }
-        if self.request_params:
-            _request_params.update(self.request_params)
-        response = self.client.embeddings.create(**_request_params)
-        if response is None:
-            raise ValueError("Failed to get embedding response")
-        return response
-
-    def get_embedding(self, text: str) -> List[float]:
-        try:
-            response: EmbeddingResponse = self._response(text=text)
-            if response.data and response.data[0].embedding:
-                return response.data[0].embedding
-            return []
-        except Exception as e:
-            logger.warning(f"Error getting embedding: {e}")
-            return []
-
-    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Dict[str, Any]]:
-        try:
-            response: EmbeddingResponse = self._response(text=text)
-            embedding: List[float] = (
-                response.data[0].embedding if (response.data and response.data[0].embedding) else []
-            )
-            usage: Dict[str, Any] = response.usage.model_dump() if response.usage else {}
-            return embedding, usage
-        except Exception as e:
-            logger.warning(f"Error getting embedding and usage: {e}")
-            return [], {}

agno/embedder/ollama.py

@@ -1,57 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
-
-from agno.embedder.base import Embedder
-from agno.utils.log import logger
-
-try:
-    from ollama import Client as OllamaClient
-except (ModuleNotFoundError, ImportError):
-    raise ImportError("`ollama` not installed. Please install using `pip install ollama`")
-
-
-@dataclass
-class OllamaEmbedder(Embedder):
-    id: str = "openhermes"
-    dimensions: int = 4096
-    host: Optional[str] = None
-    timeout: Optional[Any] = None
-    options: Optional[Any] = None
-    client_kwargs: Optional[Dict[str, Any]] = None
-    ollama_client: Optional[OllamaClient] = None
-
-    @property
-    def client(self) -> OllamaClient:
-        if self.ollama_client:
-            return self.ollama_client
-
-        _ollama_params: Dict[str, Any] = {}
-        if self.host:
-            _ollama_params["host"] = self.host
-        if self.timeout:
-            _ollama_params["timeout"] = self.timeout
-        if self.client_kwargs:
-            _ollama_params.update(self.client_kwargs)
-        return OllamaClient(**_ollama_params)
-
-    def _response(self, text: str) -> Dict[str, Any]:
-        kwargs: Dict[str, Any] = {}
-        if self.options is not None:
-            kwargs["options"] = self.options
-
-        return self.client.embeddings(prompt=text, model=self.id, **kwargs)  # type: ignore
-
-    def get_embedding(self, text: str) -> List[float]:
-        try:
-            response = self._response(text=text)
-            if response is None:
-                return []
-            return response.get("embedding", [])
-        except Exception as e:
-            logger.warning(e)
-            return []
-
-    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
-        embedding = self.get_embedding(text=text)
-        usage = None
-        return embedding, usage

agno/embedder/openai.py

@@ -1,74 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
-
-from typing_extensions import Literal
-
-from agno.embedder.base import Embedder
-from agno.utils.log import logger
-
-try:
-    from openai import OpenAI as OpenAIClient
-    from openai.types.create_embedding_response import CreateEmbeddingResponse
-except ImportError:
-    raise ImportError("`openai` not installed")
-
-
-@dataclass
-class OpenAIEmbedder(Embedder):
-    id: str = "text-embedding-3-small"
-    dimensions: int = 1536
-    encoding_format: Literal["float", "base64"] = "float"
-    user: Optional[str] = None
-    api_key: Optional[str] = None
-    organization: Optional[str] = None
-    base_url: Optional[str] = None
-    request_params: Optional[Dict[str, Any]] = None
-    client_params: Optional[Dict[str, Any]] = None
-    openai_client: Optional[OpenAIClient] = None
-
-    @property
-    def client(self) -> OpenAIClient:
-        if self.openai_client:
-            return self.openai_client
-
-        _client_params: Dict[str, Any] = {}
-        if self.api_key:
-            _client_params["api_key"] = self.api_key
-        if self.organization:
-            _client_params["organization"] = self.organization
-        if self.base_url:
-            _client_params["base_url"] = self.base_url
-        if self.client_params:
-            _client_params.update(self.client_params)
-        return OpenAIClient(**_client_params)
-
-    def response(self, text: str) -> CreateEmbeddingResponse:
-        _request_params: Dict[str, Any] = {
-            "input": text,
-            "model": self.id,
-            "encoding_format": self.encoding_format,
-        }
-        if self.user is not None:
-            _request_params["user"] = self.user
-        if self.id.startswith("text-embedding-3"):
-            _request_params["dimensions"] = self.dimensions
-        if self.request_params:
-            _request_params.update(self.request_params)
-        return self.client.embeddings.create(**_request_params)
-
-    def get_embedding(self, text: str) -> List[float]:
-        response: CreateEmbeddingResponse = self.response(text=text)
-        try:
-            return response.data[0].embedding
-        except Exception as e:
-            logger.warning(e)
-            return []
-
-    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
-        response: CreateEmbeddingResponse = self.response(text=text)
-
-        embedding = response.data[0].embedding
-        usage = response.usage
-        if usage:
-            return embedding, usage.model_dump()
-        return embedding, None

agno/embedder/sentence_transformer.py

@@ -1,38 +0,0 @@
-import platform
-from dataclasses import dataclass
-from typing import Dict, List, Optional, Tuple, Union
-
-from agno.embedder.base import Embedder
-from agno.utils.log import logger
-
-try:
-    from sentence_transformers import SentenceTransformer
-
-    if platform.system() == "Windows":
-        import numpy as np
-
-        numpy_version = np.__version__
-        if numpy_version.startswith("2"):
-            raise RuntimeError(
-                "Incompatible NumPy version detected. Please install NumPy 1.x by running 'pip install numpy<2'."
-            )
-except ImportError:
-    raise ImportError("sentence-transformers not installed, please run pip install sentence-transformers")
-
-
-@dataclass
-class SentenceTransformerEmbedder(Embedder):
-    id: str = "sentence-transformers/all-MiniLM-L6-v2"
-    sentence_transformer_client: Optional[SentenceTransformer] = None
-
-    def get_embedding(self, text: Union[str, List[str]]) -> List[float]:
-        model = SentenceTransformer(model_name_or_path=self.id)
-        embedding = model.encode(text)
-        try:
-            return embedding  # type: ignore
-        except Exception as e:
-            logger.warning(e)
-            return []
-
-    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
-        return self.get_embedding(text=text), None

agno/embedder/voyageai.py

@@ -1,64 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Tuple
-
-from agno.embedder.base import Embedder
-from agno.utils.log import logger
-
-try:
-    from voyageai import Client
-    from voyageai.object import EmbeddingsObject
-except ImportError:
-    raise ImportError("`voyageai` not installed")
-
-
-@dataclass
-class VoyageAIEmbedder(Embedder):
-    id: str = "voyage-2"
-    dimensions: int = 1024
-    request_params: Optional[Dict[str, Any]] = None
-    api_key: Optional[str] = None
-    base_url: str = "https://api.voyageai.com/v1/embeddings"
-    max_retries: Optional[int] = None
-    timeout: Optional[float] = None
-    client_params: Optional[Dict[str, Any]] = None
-    voyage_client: Optional[Client] = None
-
-    @property
-    def client(self) -> Client:
-        if self.voyage_client:
-            return self.voyage_client
-
-        _client_params: Dict[str, Any] = {}
-        if self.api_key:
-            _client_params["api_key"] = self.api_key
-        if self.max_retries:
-            _client_params["max_retries"] = self.max_retries
-        if self.timeout:
-            _client_params["timeout"] = self.timeout
-        if self.client_params:
-            _client_params.update(self.client_params)
-        return Client(**_client_params)
-
-    def _response(self, text: str) -> EmbeddingsObject:
-        _request_params: Dict[str, Any] = {
-            "texts": [text],
-            "model": self.id,
-        }
-        if self.request_params:
-            _request_params.update(self.request_params)
-        return self.client.embed(**_request_params)
-
-    def get_embedding(self, text: str) -> List[float]:
-        response: EmbeddingsObject = self._response(text=text)
-        try:
-            return response.embeddings[0]
-        except Exception as e:
-            logger.warning(e)
-            return []
-
-    def get_embedding_and_usage(self, text: str) -> Tuple[List[float], Optional[Dict]]:
-        response: EmbeddingsObject = self._response(text=text)
-
-        embedding = response.embeddings[0]
-        usage = {"total_tokens": response.total_tokens}
-        return embedding, usage

agno/eval/perf.py

@@ -1,201 +0,0 @@
-from dataclasses import asdict, dataclass, field
-from os import getenv
-from pathlib import Path
-from typing import TYPE_CHECKING, Callable, List, Optional
-from uuid import uuid4
-
-from memory_profiler import memory_usage
-
-from agno.utils.log import logger, set_log_level_to_debug, set_log_level_to_info
-from agno.utils.timer import Timer
-
-if TYPE_CHECKING:
-    from rich.console import Console
-
-
-@dataclass
-class PerfResult:
-    # Run time performance in seconds
-    run_times: List[float] = field(default_factory=list)
-    avg_run_time: float = field(init=False)
-    min_run_time: float = field(init=False)
-    max_run_time: float = field(init=False)
-    std_dev_run_time: float = field(init=False)
-
-    # Memory performance in MiB
-    memory_usages: List[float] = field(default_factory=list)
-    avg_memory_usage: float = field(init=False)
-    min_memory_usage: float = field(init=False)
-    max_memory_usage: float = field(init=False)
-    std_dev_memory_usage: float = field(init=False)
-
-    def __post_init__(self):
-        self.compute_stats()
-
-    def compute_stats(self):
-        import statistics
-
-        if self.run_times:
-            self.avg_run_time = statistics.mean(self.run_times)
-            self.min_run_time = min(self.run_times)
-            self.max_run_time = max(self.run_times)
-            self.std_dev_run_time = statistics.stdev(self.run_times) if len(self.run_times) > 1 else 0
-
-        if self.memory_usages:
-            self.avg_memory_usage = statistics.mean(self.memory_usages)
-            self.min_memory_usage = min(self.memory_usages)
-            self.max_memory_usage = max(self.memory_usages)
-            self.std_dev_memory_usage = statistics.stdev(self.memory_usages) if len(self.memory_usages) > 1 else 0
-
-    def print_summary(self, console: Optional["Console"] = None):
-        from rich.console import Console
-        from rich.table import Table
-
-        if console is None:
-            console = Console()
-
-        # Create performance table
-        perf_table = Table(title="Performance Summary", show_header=True, header_style="bold magenta")
-        perf_table.add_column("Metric", style="cyan")
-        perf_table.add_column("Time (seconds)", style="green")
-        perf_table.add_column("Memory (MiB)", style="yellow")
-
-        # Add rows
-        perf_table.add_row("Average", f"{self.avg_run_time:.6f}", f"{self.avg_memory_usage:.2f}")
-        perf_table.add_row("Minimum", f"{self.min_run_time:.6f}", f"{self.min_memory_usage:.2f}")
-        perf_table.add_row("Maximum", f"{self.max_run_time:.6f}", f"{self.max_memory_usage:.2f}")
-        perf_table.add_row("Std Dev", f"{self.std_dev_run_time:.6f}", f"{self.std_dev_memory_usage:.2f}")
-
-        console.print(perf_table)
-
-    def print_results(self, console: Optional["Console"] = None):
-        from rich.console import Console
-        from rich.table import Table
-
-        if console is None:
-            console = Console()
-
-        # Create runs table
-        results_table = Table(title="Individual Runs", show_header=True, header_style="bold magenta")
-        results_table.add_column("Run #", style="cyan")
-        results_table.add_column("Time (seconds)", style="green")
-        results_table.add_column("Memory (MiB)", style="yellow")
-
-        # Add rows
-        for i in range(len(self.run_times)):
-            results_table.add_row(str(i + 1), f"{self.run_times[i]:.6f}", f"{self.memory_usages[i]:.2f}")
-
-        console.print(results_table)
-
-
-@dataclass
-class PerfEval:
-    """Evaluate the performance of a function."""
-
-    # Function to evaluate
-    func: Callable
-
-    # Evaluation name
-    name: Optional[str] = None
-    # Evaluation UUID (autogenerated if not set)
-    eval_id: Optional[str] = None
-
-    # Number of iterations to run
-    num_iterations: int = 3
-    # Result of the evaluation
-    result: Optional[PerfResult] = None
-
-    # Print summary of results
-    print_summary: bool = False
-    # Print detailed results
-    print_results: bool = False
-    # Save the result to a file
-    save_result_to_file: Optional[str] = None
-
-    # debug_mode=True enables debug logs
-    debug_mode: bool = False
-
-    def set_eval_id(self) -> str:
-        if self.eval_id is None:
-            self.eval_id = str(uuid4())
-        logger.debug(f"*********** Evaluation ID: {self.eval_id} ***********")
-        return self.eval_id
-
-    def set_debug_mode(self) -> None:
-        if self.debug_mode or getenv("AGNO_DEBUG", "false").lower() == "true":
-            self.debug_mode = True
-            set_log_level_to_debug()
-            logger.debug("Debug logs enabled")
-        else:
-            set_log_level_to_info()
-
-    def run(self, *, print_summary: bool = False, print_results: bool = False) -> PerfResult:
-        from rich.console import Console
-        from rich.live import Live
-        from rich.status import Status
-
-        run_times = []
-        memory_usages = []
-        self.set_eval_id()
-        self.set_debug_mode()
-        self.print_results = print_results
-        self.print_summary = print_summary
-
-        # Add a spinner while running the evaluations
-        console = Console()
-        with Live(console=console, transient=True) as live_log:
-            # Measure run time
-            for i in range(self.num_iterations):
-                status = Status(
-                    f"Running run time evaluation {i + 1}...", spinner="dots", speed=1.0, refresh_per_second=10
-                )
-                live_log.update(status)
-
-                timer = Timer()
-                # Start the timer
-                timer.start()
-                # Run the function
-                self.func()
-                # Stop the timer
-                timer.stop()
-                # Append the time taken
-                run_times.append(timer.elapsed)
-                logger.debug(f"\nRun {i + 1}:")
-                logger.debug(f"Time taken: {timer.elapsed:.6f} seconds")
-                status.stop()
-
-            # Measure memory usage
-            for i in range(self.num_iterations):
-                status = Status(
-                    f"Running memory usage evaluation {i + 1}...", spinner="dots", speed=1.0, refresh_per_second=10
-                )
-                live_log.update(status)
-                mem_usage = memory_usage((self.func, (), {}), interval=0.1, max_iterations=1, max_usage=True)
-                memory_usages.append(mem_usage)
-                logger.debug(f"\nRun {i + 1}:")
-                logger.debug(f"Memory usage: {mem_usage} MiB")
-                status.stop()
-
-        # Create and store the result
-        self.result = PerfResult(run_times=run_times, memory_usages=memory_usages)
-
-        # -*- Save result to file if save_result_to_file is set
-        if self.save_result_to_file is not None and self.result is not None:
-            try:
-                import json
-
-                fn_path = Path(self.save_result_to_file.format(name=self.name, eval_id=self.eval_id))
-                if not fn_path.parent.exists():
-                    fn_path.parent.mkdir(parents=True, exist_ok=True)
-                fn_path.write_text(json.dumps(asdict(self.result), indent=4))
-            except Exception as e:
-                logger.warning(f"Failed to save result to file: {e}")
-
-        # Show results
-        if self.print_results:
-            self.result.print_results(console)
-        if self.print_summary or self.print_results:
-            self.result.print_summary(console)
-
-        logger.debug(f"*********** Evaluation End: {self.eval_id} ***********")
-        return self.result

agno/file/__init__.py

@@ -1 +0,0 @@
-from agno.file.file import File

agno/file/file.py

@@ -1,16 +0,0 @@
-from dataclasses import dataclass
-from typing import Any, List, Optional
-
-from agno.utils.common import dataclass_to_dict
-
-
-@dataclass
-class File:
-    name: Optional[str] = None
-    description: Optional[str] = None
-    columns: Optional[List[str]] = None
-    path: Optional[str] = None
-    type: str = "FILE"
-
-    def get_metadata(self) -> dict[str, Any]:
-        return dataclass_to_dict(self, exclude_none=True)

agno/file/local/csv.py

@@ -1,32 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-from agno.file import File
-from agno.utils.common import dataclass_to_dict
-from agno.utils.log import logger
-
-
-@dataclass
-class CsvFile(File):
-    path: str = ""  # type: ignore
-    type: str = "CSV"
-
-    def get_metadata(self) -> dict[str, Any]:
-        if self.name is None:
-            from pathlib import Path
-
-            self.name = Path(self.path).name
-
-        if self.columns is None:
-            try:
-                # Get the columns from the file
-                import csv
-
-                with open(self.path) as csvfile:
-                    dict_reader = csv.DictReader(csvfile)
-                    if dict_reader.fieldnames is not None:
-                        self.columns = list(dict_reader.fieldnames)
-            except Exception as e:
-                logger.debug(f"Error getting columns from file: {e}")
-
-        return dataclass_to_dict(self, exclude_none=True)

agno/file/local/txt.py

@@ -1,19 +0,0 @@
-from dataclasses import dataclass
-from typing import Any
-
-from agno.file import File
-from agno.utils.common import dataclass_to_dict
-
-
-@dataclass
-class TextFile(File):
-    path: str = ""  # type: ignore
-    type: str = "TEXT"
-
-    def get_metadata(self) -> dict[str, Any]:
-        if self.name is None:
-            from pathlib import Path
-
-            self.name = Path(self.path).name
-
-        return dataclass_to_dict(self, exclude_none=True)