agno 2.3.15__py3-none-any.whl → 2.3.17__py3-none-any.whl

agno/db/base.py

@@ -58,6 +58,14 @@ class BaseDb(ABC):
         """Create all tables for this database."""
         pass
 
+    def close(self) -> None:
+        """Close database connections and release resources.
+
+        Override in subclasses to properly dispose of connection pools.
+        Should be called during application shutdown.
+        """
+        pass
+
     # --- Schema Version ---
     @abstractmethod
     def get_latest_schema_version(self, table_name: str):
@@ -517,6 +525,18 @@ class AsyncBaseDb(ABC):
         self.culture_table_name = culture_table or "agno_culture"
         self.versions_table_name = versions_table or "agno_schema_versions"
 
+    async def _create_all_tables(self) -> None:
+        """Create all tables for this database. Override in subclasses."""
+        pass
+
+    async def close(self) -> None:
+        """Close database connections and release resources.
+
+        Override in subclasses to properly dispose of connection pools.
+        Should be called during application shutdown.
+        """
+        pass
+
     @abstractmethod
     async def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in this database.

agno/db/mongo/async_mongo.py

@@ -249,6 +249,17 @@ class AsyncMongoDb(AsyncBaseDb):
             if collection_name and not await self.table_exists(collection_name):
                 await self._get_collection(collection_type, create_collection_if_not_found=True)
 
+    async def close(self) -> None:
+        """Close the MongoDB client connection.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self._client is not None:
+            self._client.close()
+            self._client = None
+            self._database = None
+
     def _ensure_client(self) -> AsyncMongoClientType:
         """
         Ensure the MongoDB async client is valid for the current event loop.

agno/db/mongo/mongo.py

@@ -98,10 +98,20 @@ class MongoDb(BaseDb):
 
         self.db_url: Optional[str] = db_url
         self.db_client: MongoClient = _client
+
         self.db_name: str = db_name if db_name is not None else "agno"
 
         self._database: Optional[Database] = None
 
+    def close(self) -> None:
+        """Close the MongoDB client connection.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_client is not None:
+            self.db_client.close()
+
     @property
     def database(self) -> Database:
         if self._database is None:

agno/db/mysql/async_mysql.py

@@ -123,6 +123,15 @@ class AsyncMySQLDb(AsyncBaseDb):
             expire_on_commit=False,
         )
 
+    async def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            await self.db_engine.dispose()
+
     # -- DB methods --
     async def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the MySQL database.

agno/db/mysql/mysql.py

@@ -121,6 +121,15 @@ class MySQLDb(BaseDb):
         # Initialize database session
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine))
 
+    def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            self.db_engine.dispose()
+
     # -- DB methods --
     def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the MySQL database.

agno/db/postgres/async_postgres.py

@@ -128,6 +128,15 @@ class AsyncPostgresDb(AsyncBaseDb):
             expire_on_commit=False,
         )
 
+    async def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            await self.db_engine.dispose()
+
     # -- DB methods --
     async def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the Postgres database.

agno/db/postgres/postgres.py

@@ -124,6 +124,15 @@ class PostgresDb(BaseDb):
         # Initialize database session
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine, expire_on_commit=False))
 
+    def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            self.db_engine.dispose()
+
     # -- DB methods --
     def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the Postgres database.

agno/db/postgres/utils.py

@@ -298,8 +298,9 @@ def calculate_date_metrics(date_to_process: date, sessions_data: dict) -> dict:
         for session in sessions:
             if session.get("user_id"):
                 all_user_ids.add(session["user_id"])
-            metrics[runs_count_key] += len(session.get("runs", []))
-            if runs := session.get("runs", []):
+            runs = session.get("runs", []) or []
+            metrics[runs_count_key] += len(runs)
+            if runs:
                 for run in runs:
                     if model_id := run.get("model"):
                         model_provider = run.get("model_provider", "")

agno/db/sqlite/async_sqlite.py

@@ -124,6 +124,15 @@ class AsyncSqliteDb(AsyncBaseDb):
         # Initialize database session factory
         self.async_session_factory = async_sessionmaker(bind=self.db_engine, expire_on_commit=False)
 
+    async def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            await self.db_engine.dispose()
+
     # -- DB methods --
     async def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the SQLite database.

agno/db/sqlite/sqlite.py

@@ -125,6 +125,15 @@ class SqliteDb(BaseDb):
         # Initialize database session
         self.Session: scoped_session = scoped_session(sessionmaker(bind=self.db_engine))
 
+    def close(self) -> None:
+        """Close database connections and dispose of the connection pool.
+
+        Should be called during application shutdown to properly release
+        all database connections.
+        """
+        if self.db_engine is not None:
+            self.db_engine.dispose()
+
     # -- DB methods --
     def table_exists(self, table_name: str) -> bool:
         """Check if a table with the given name exists in the SQLite database.
@@ -1110,7 +1119,8 @@ class SqliteDb(BaseDb):
                 # Select topics from all results
                 stmt = select(table.c.topics)
                 result = sess.execute(stmt).fetchall()
-                return list(set([record[0] for record in result]))
+                result = result[0][0]
+                return list(set(result))
 
         except Exception as e:
             log_debug(f"Exception reading from memory table: {e}")

agno/exceptions.py

@@ -178,3 +178,26 @@ class RetryableModelProviderError(Exception):
     original_error: Optional[str] = None
     # Guidance message to retry a model invocation after an error
     retry_guidance_message: Optional[str] = None
+
+
+class RemoteServerUnavailableError(AgnoError):
+    """Exception raised when a remote server is unavailable.
+
+    This can happen due to:
+    - Connection refused (server not running)
+    - Connection timeout
+    - Network errors
+    - DNS resolution failures
+    """
+
+    def __init__(
+        self,
+        message: str,
+        base_url: Optional[str] = None,
+        original_error: Optional[Exception] = None,
+    ):
+        super().__init__(message, status_code=503)
+        self.base_url = base_url
+        self.original_error = original_error
+        self.type = "remote_server_unavailable_error"
+        self.error_id = "remote_server_unavailable_error"

agno/knowledge/chunking/semantic.py

@@ -1,5 +1,18 @@
-import inspect
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Literal, Optional, Union
+
+try:
+    import numpy as np
+except ImportError:
+    raise ImportError("`numpy` not installed. Please install using `pip install numpy`")
+
+try:
+    from chonkie import SemanticChunker
+    from chonkie.embeddings.base import BaseEmbeddings
+except ImportError:
+    raise ImportError(
+        "`chonkie` is required for semantic chunking. "
+        "Please install it using `pip install chonkie` to use SemanticChunking."
+    )
 
 from agno.knowledge.chunking.strategy import ChunkingStrategy
 from agno.knowledge.document.base import Document
@@ -7,10 +20,69 @@ from agno.knowledge.embedder.base import Embedder
 from agno.utils.log import log_info
 
 
-class SemanticChunking(ChunkingStrategy):
-    """Chunking strategy that splits text into semantic chunks using chonkie"""
+def _get_chonkie_embedder_wrapper(embedder: Embedder):
+    """Create a wrapper that adapts Agno Embedder to chonkie's BaseEmbeddings interface."""
+
+    class _ChonkieEmbedderWrapper(BaseEmbeddings):
+        """Wrapper to make Agno Embedders compatible with chonkie."""
+
+        def __init__(self, agno_embedder: Embedder):
+            super().__init__()
+            self._embedder = agno_embedder
+
+        def embed(self, text: str):
+            embedding = self._embedder.get_embedding(text)  # type: ignore[attr-defined]
+            return np.array(embedding, dtype=np.float32)
+
+        def get_tokenizer(self):
+            """Return a simple token counter function."""
+            return lambda text: len(text.split())
 
-    def __init__(self, embedder: Optional[Embedder] = None, chunk_size: int = 5000, similarity_threshold: float = 0.5):
+        @property
+        def dimension(self) -> int:
+            return getattr(self._embedder, "dimensions")
+
+    return _ChonkieEmbedderWrapper(embedder)
+
+
+class SemanticChunking(ChunkingStrategy):
+    """Chunking strategy that splits text into semantic chunks using chonkie.
+
+    Args:
+        embedder: The embedder to use for generating embeddings. Can be:
+            - A string model identifier (e.g., "minishlab/potion-base-32M") for chonkie's built-in models
+            - A chonkie BaseEmbeddings instance (used directly)
+            - An Agno Embedder (wrapped for chonkie compatibility)
+        chunk_size: Maximum tokens allowed per chunk.
+        similarity_threshold: Threshold for semantic similarity (0-1).
+        similarity_window: Number of sentences to consider for similarity calculation.
+        min_sentences_per_chunk: Minimum number of sentences per chunk.
+        min_characters_per_sentence: Minimum number of characters per sentence.
+        delimiters: Delimiters to use for sentence splitting.
+        include_delimiters: Whether to include delimiter in prev/next sentence or None.
+        skip_window: Number of groups to skip when merging (0=disabled).
+        filter_window: Window length for the Savitzky-Golay filter.
+        filter_polyorder: Polynomial order for the Savitzky-Golay filter.
+        filter_tolerance: Tolerance for the Savitzky-Golay filter.
+        chunker_params: Additional parameters to pass to chonkie's SemanticChunker.
+    """
+
+    def __init__(
+        self,
+        embedder: Optional[Union[str, Embedder, BaseEmbeddings]] = None,
+        chunk_size: int = 5000,
+        similarity_threshold: float = 0.5,
+        similarity_window: int = 3,
+        min_sentences_per_chunk: int = 1,
+        min_characters_per_sentence: int = 24,
+        delimiters: Optional[List[str]] = None,
+        include_delimiters: Literal["prev", "next", None] = "prev",
+        skip_window: int = 0,
+        filter_window: int = 5,
+        filter_polyorder: int = 3,
+        filter_tolerance: float = 0.2,
+        chunker_params: Optional[Dict[str, Any]] = None,
+    ):
         if embedder is None:
             from agno.knowledge.embedder.openai import OpenAIEmbedder
 
@@ -19,50 +91,55 @@ class SemanticChunking(ChunkingStrategy):
         self.embedder = embedder
         self.chunk_size = chunk_size
         self.similarity_threshold = similarity_threshold
-        self.chunker = None  # Will be initialized lazily when needed
+        self.similarity_window = similarity_window
+        self.min_sentences_per_chunk = min_sentences_per_chunk
+        self.min_characters_per_sentence = min_characters_per_sentence
+        self.delimiters = delimiters if delimiters is not None else [". ", "! ", "? ", "\n"]
+        self.include_delimiters = include_delimiters
+        self.skip_window = skip_window
+        self.filter_window = filter_window
+        self.filter_polyorder = filter_polyorder
+        self.filter_tolerance = filter_tolerance
+        self.chunker_params = chunker_params
+        self.chunker: Optional[SemanticChunker] = None
 
     def _initialize_chunker(self):
         """Lazily initialize the chunker with chonkie dependency."""
-        if self.chunker is None:
-            try:
-                from chonkie import SemanticChunker
-            except ImportError:
-                raise ImportError(
-                    "`chonkie` is required for semantic chunking. "
-                    "Please install it using `pip install chonkie` to use SemanticChunking."
-                )
-
-            # Build arguments dynamically based on chonkie's supported signature
-            params: Dict[str, Any] = {
-                "chunk_size": self.chunk_size,
-                "threshold": self.similarity_threshold,
-            }
-
-            try:
-                sig = inspect.signature(SemanticChunker)
-                param_names = set(sig.parameters.keys())
-
-                # Prefer passing a callable to avoid Chonkie initializing its own client
-                if "embedding_fn" in param_names:
-                    params["embedding_fn"] = self.embedder.get_embedding  # type: ignore[attr-defined]
-                    # If chonkie allows specifying dimensions, provide them
-                    if "embedding_dimensions" in param_names and getattr(self.embedder, "dimensions", None):
-                        params["embedding_dimensions"] = self.embedder.dimensions  # type: ignore[attr-defined]
-                elif "embedder" in param_names:
-                    # Some versions may accept an embedder object directly
-                    params["embedder"] = self.embedder
-                else:
-                    # Fallback to model id
-                    params["embedding_model"] = getattr(self.embedder, "id", None) or "text-embedding-3-small"
-
-                self.chunker = SemanticChunker(**params)  # type: ignore
-            except Exception:
-                # As a final fallback, use the original behavior
-                self.chunker = SemanticChunker(  # type: ignore
-                    embedding_model=getattr(self.embedder, "id", None) or "text-embedding-3-small",
-                    chunk_size=self.chunk_size,
-                    threshold=self.similarity_threshold,
-                )
+        if self.chunker is not None:
+            return
+
+        # Determine embedding model based on type:
+        # - str: pass directly to chonkie (uses chonkie's built-in models)
+        # - BaseEmbeddings: pass directly to chonkie
+        # - Agno Embedder: wrap for chonkie compatibility
+        embedding_model: Union[str, BaseEmbeddings]
+        if isinstance(self.embedder, str):
+            embedding_model = self.embedder
+        elif isinstance(self.embedder, BaseEmbeddings):
+            embedding_model = self.embedder
+        elif isinstance(self.embedder, Embedder):
+            embedding_model = _get_chonkie_embedder_wrapper(self.embedder)
+        else:
+            raise ValueError("Invalid embedder type. Must be a string, BaseEmbeddings, or Embedder instance.")
+
+        _chunker_params: Dict[str, Any] = {
+            "embedding_model": embedding_model,
+            "chunk_size": self.chunk_size,
+            "threshold": self.similarity_threshold,
+            "similarity_window": self.similarity_window,
+            "min_sentences_per_chunk": self.min_sentences_per_chunk,
+            "min_characters_per_sentence": self.min_characters_per_sentence,
+            "delim": self.delimiters,
+            "include_delim": self.include_delimiters,
+            "skip_window": self.skip_window,
+            "filter_window": self.filter_window,
+            "filter_polyorder": self.filter_polyorder,
+            "filter_tolerance": self.filter_tolerance,
+        }
+        if self.chunker_params:
+            _chunker_params.update(self.chunker_params)
+
+        self.chunker = SemanticChunker(**_chunker_params)
 
     def chunk(self, document: Document) -> List[Document]:
         """Split document into semantic chunks using chonkie"""

agno/knowledge/reader/csv_reader.py

@@ -47,17 +47,16 @@ class CSVReader(Reader):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
                 log_debug(f"Reading: {file}")
-                file_content = file.open(newline="", mode="r", encoding=self.encoding or "utf-8")
+                csv_name = name or file.stem
+                file_content: Union[io.TextIOWrapper, io.StringIO] = file.open(
+                    newline="", mode="r", encoding=self.encoding or "utf-8"
+                )
             else:
-                log_debug(f"Reading retrieved file: {name or file.name}")
+                log_debug(f"Reading retrieved file: {getattr(file, 'name', 'BytesIO')}")
+                csv_name = name or getattr(file, "name", "csv_file").split(".")[0]
                 file.seek(0)
-                file_content = io.StringIO(file.read().decode("utf-8"))  # type: ignore
+                file_content = io.StringIO(file.read().decode("utf-8"))
 
-            csv_name = name or (
-                Path(file.name).stem
-                if isinstance(file, Path)
-                else (getattr(file, "name", "csv_file").split(".")[0] if hasattr(file, "name") else "csv_file")
-            )
             csv_content = ""
             with file_content as csvfile:
                 csv_reader = csv.reader(csvfile, delimiter=delimiter, quotechar=quotechar)
@@ -109,16 +108,12 @@ class CSVReader(Reader):
                 async with aiofiles.open(file, mode="r", encoding="utf-8", newline="") as file_content:
                     content = await file_content.read()
                     file_content_io = io.StringIO(content)
+                csv_name = name or file.stem
             else:
                 log_debug(f"Reading retrieved file async: {getattr(file, 'name', 'BytesIO')}")
                 file.seek(0)
                 file_content_io = io.StringIO(file.read().decode("utf-8"))
-
-            csv_name = name or (
-                Path(file.name).stem
-                if isinstance(file, Path)
-                else (getattr(file, "name", "csv_file").split(".")[0] if hasattr(file, "name") else "csv_file")
-            )
+                csv_name = name or getattr(file, "name", "csv_file").split(".")[0]
 
             file_content_io.seek(0)
             csv_reader = csv.reader(file_content_io, delimiter=delimiter, quotechar=quotechar)

agno/knowledge/reader/docx_reader.py

@@ -47,11 +47,9 @@ class DocxReader(Reader):
                 docx_document = DocxDocument(str(file))
                 doc_name = name or file.stem
             else:
-                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'docx_file')}")
+                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'BytesIO')}")
                 docx_document = DocxDocument(file)
-                doc_name = name or (
-                    getattr(file, "name", "docx_file").split(".")[0] if hasattr(file, "name") else "docx_file"
-                )
+                doc_name = name or getattr(file, "name", "docx_file").split(".")[0]
 
             doc_content = "\n\n".join([para.text for para in docx_document.paragraphs])
 

agno/knowledge/reader/field_labeled_csv_reader.py

@@ -106,17 +106,15 @@ class FieldLabeledCSVReader(Reader):
                 if not file.exists():
                     raise FileNotFoundError(f"Could not find file: {file}")
                 log_debug(f"Reading: {file}")
-                file_content = file.open(newline="", mode="r", encoding=self.encoding or "utf-8")
+                csv_name = name or file.stem
+                file_content: Union[io.TextIOWrapper, io.StringIO] = file.open(
+                    newline="", mode="r", encoding=self.encoding or "utf-8"
+                )
             else:
-                log_debug(f"Reading retrieved file: {name or file.name}")
+                log_debug(f"Reading retrieved file: {getattr(file, 'name', 'BytesIO')}")
+                csv_name = name or getattr(file, "name", "csv_file").split(".")[0]
                 file.seek(0)
-                file_content = io.StringIO(file.read().decode("utf-8"))  # type: ignore
-
-            csv_name = name or (
-                Path(file.name).stem
-                if isinstance(file, Path)
-                else (getattr(file, "name", "csv_file").split(".")[0] if hasattr(file, "name") else "csv_file")
-            )
+                file_content = io.StringIO(file.read().decode("utf-8"))
 
             documents = []
 
@@ -189,16 +187,12 @@ class FieldLabeledCSVReader(Reader):
                 async with aiofiles.open(file, mode="r", encoding=self.encoding or "utf-8", newline="") as file_content:
                     content = await file_content.read()
                     file_content_io = io.StringIO(content)
+                csv_name = name or file.stem
             else:
-                log_debug(f"Reading retrieved file async: {name or file.name}")
+                log_debug(f"Reading retrieved file async: {getattr(file, 'name', 'BytesIO')}")
+                csv_name = name or getattr(file, "name", "csv_file").split(".")[0]
                 file.seek(0)
-                file_content_io = io.StringIO(file.read().decode("utf-8"))  # type: ignore
-
-            csv_name = name or (
-                Path(file.name).stem
-                if isinstance(file, Path)
-                else (getattr(file, "name", "csv_file").split(".")[0] if hasattr(file, "name") else "csv_file")
-            )
+                file_content_io = io.StringIO(file.read().decode("utf-8"))
 
             file_content_io.seek(0)
             csv_reader = csv.reader(file_content_io, delimiter=delimiter, quotechar=quotechar)

agno/knowledge/reader/json_reader.py

@@ -1,6 +1,5 @@
 import asyncio
 import json
-from io import BytesIO
 from pathlib import Path
 from typing import IO, Any, List, Optional, Union
 from uuid import uuid4
@@ -42,17 +41,15 @@ class JSONReader(Reader):
                 if not path.exists():
                     raise FileNotFoundError(f"Could not find file: {path}")
                 log_debug(f"Reading: {path}")
-                json_name = name or path.name.split(".")[0]
-                json_contents = json.loads(path.read_text(self.encoding or "utf-8"))
-
-            elif isinstance(path, BytesIO):
-                json_name = name or path.name.split(".")[0]
-                log_debug(f"Reading uploaded file: {json_name}")
+                json_name = name or path.stem
+                json_contents = json.loads(path.read_text(encoding=self.encoding or "utf-8"))
+            elif hasattr(path, "seek") and hasattr(path, "read"):
+                log_debug(f"Reading uploaded file: {getattr(path, 'name', 'BytesIO')}")
+                json_name = name or getattr(path, "name", "json_file").split(".")[0]
                 path.seek(0)
                 json_contents = json.load(path)
-
             else:
-                raise ValueError("Unsupported file type. Must be Path or BytesIO.")
+                raise ValueError("Unsupported file type. Must be Path or file-like object.")
 
             if isinstance(json_contents, dict):
                 json_contents = [json_contents]
@@ -72,17 +69,12 @@ class JSONReader(Reader):
                     chunked_documents.extend(self.chunk_document(document))
                 return chunked_documents
             return documents
+        except (FileNotFoundError, ValueError, json.JSONDecodeError):
+            raise
         except Exception as e:
             log_error(f"Error reading: {path}: {e}")
             raise
 
     async def async_read(self, path: Union[Path, IO[Any]], name: Optional[str] = None) -> List[Document]:
-        """Asynchronously read JSON files.
-
-        Args:
-            path (Union[Path, IO[Any]]): Path to a JSON file or a file-like object
-
-        Returns:
-            List[Document]: List of documents from the JSON file
-        """
+        """Asynchronously read JSON files."""
         return await asyncio.to_thread(self.read, path, name)

agno/knowledge/reader/markdown_reader.py

@@ -69,8 +69,8 @@ class MarkdownReader(Reader):
                 file_name = name or file.stem
                 file_contents = file.read_text(encoding=self.encoding or "utf-8")
             else:
-                log_debug(f"Reading uploaded file: {file.name}")
-                file_name = name or file.name.split(".")[0]
+                log_debug(f"Reading uploaded file: {getattr(file, 'name', 'BytesIO')}")
+                file_name = name or getattr(file, "name", "file").split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
@@ -101,16 +101,16 @@ class MarkdownReader(Reader):
                         file_contents = await f.read()
                 except ImportError:
                     log_warning("aiofiles not installed, using synchronous file I/O")
-                    file_contents = file.read_text(self.encoding or "utf-8")
+                    file_contents = file.read_text(encoding=self.encoding or "utf-8")
             else:
-                log_debug(f"Reading uploaded file asynchronously: {file.name}")
-                file_name = name or file.name.split(".")[0]
+                log_debug(f"Reading uploaded file asynchronously: {getattr(file, 'name', 'BytesIO')}")
+                file_name = name or getattr(file, "name", "file").split(".")[0]
                 file.seek(0)
                 file_contents = file.read().decode(self.encoding or "utf-8")
 
             document = Document(
                 name=file_name,
-                id=str(uuid.uuid4()),  # Fixed an issue with the id creation
+                id=str(uuid.uuid4()),
                 content=file_contents,
             )
 

agno/knowledge/reader/pdf_reader.py

@@ -218,16 +218,13 @@ class BasePDFReader(Reader):
 
     def _get_doc_name(self, pdf_source: Union[str, Path, IO[Any]], name: Optional[str] = None) -> str:
         """Determines the document name from the source or a provided name."""
-        try:
-            if name:
-                return name
-            if isinstance(pdf_source, str):
-                return pdf_source.split("/")[-1].split(".")[0].replace(" ", "_")
-            # Assumes a file-like object with a .name attribute
-            return pdf_source.name.split(".")[0]
-        except Exception:
-            # The original code had a bug here, it should check `name` first.
-            return name or "pdf"
+        if name:
+            return name
+        if isinstance(pdf_source, str):
+            return Path(pdf_source).stem.replace(" ", "_")
+        if isinstance(pdf_source, Path):
+            return pdf_source.stem.replace(" ", "_")
+        return getattr(pdf_source, "name", "pdf_file").split(".")[0].replace(" ", "_")
 
     def _decrypt_pdf(self, doc_reader: DocumentReader, doc_name: str, password: Optional[str] = None) -> bool:
         if not doc_reader.is_encrypted:
@@ -341,8 +338,14 @@ class PDFReader(BasePDFReader):
         return [ContentType.PDF]
 
     def read(
-        self, pdf: Union[str, Path, IO[Any]], name: Optional[str] = None, password: Optional[str] = None
+        self,
+        pdf: Optional[Union[str, Path, IO[Any]]] = None,
+        name: Optional[str] = None,
+        password: Optional[str] = None,
     ) -> List[Document]:
+        if pdf is None:
+            log_error("No pdf provided")
+            return []
         doc_name = self._get_doc_name(pdf, name)
         log_debug(f"Reading: {doc_name}")