ag2 0.9.6__py3-none-any.whl → 0.9.8.post1__py3-none-any.whl

autogen/agents/experimental/deep_research/deep_research.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Optional, Union
+from typing import Any
 
 from .... import ConversableAgent
 from ....doc_utils import export_module
@@ -21,8 +21,8 @@ class DeepResearchAgent(ConversableAgent):
     def __init__(
         self,
         name: str,
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
-        system_message: Optional[Union[str, list[str]]] = DEFAULT_PROMPT,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
+        system_message: str | list[str] | None = DEFAULT_PROMPT,
         max_web_steps: int = 30,
         **kwargs: Any,
     ) -> None:

autogen/agents/experimental/discord/discord.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import Any, Optional
+from typing import Any
 
 from .... import ConversableAgent
 from ....doc_utils import export_module
@@ -24,7 +24,7 @@ class DiscordAgent(ConversableAgent):
     def __init__(
         self,
         name: str,
-        system_message: Optional[str] = None,
+        system_message: str | None = None,
         *,
         bot_token: str,
         channel_name: str,

autogen/agents/experimental/document_agent/chroma_query_engine.py

@@ -4,8 +4,9 @@
 
 import logging
 import os
+from collections.abc import Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any, Optional
 
 from pydantic import BaseModel
 
@@ -40,8 +41,7 @@ logger = logging.getLogger(__name__)
 @require_optional_import(["chromadb", "llama_index"], "rag")
 @export_module("autogen.agents.experimental")
 class VectorChromaQueryEngine:
-    """
-    This engine leverages Chromadb to persist document embeddings in a named collection
+    """This engine leverages Chromadb to persist document embeddings in a named collection
     and LlamaIndex's VectorStoreIndex to efficiently index and retrieve documents, and generate an answer in response
     to natural language queries. The Chromadb collection serves as the storage layer, while
     the collection name uniquely identifies the set of documents within the persistent database.
@@ -51,14 +51,14 @@ class VectorChromaQueryEngine:
 
     def __init__(  # type: ignore[no-any-unimported]
         self,
-        db_path: Optional[str] = None,
-        embedding_function: "Optional[EmbeddingFunction[Any]]" = None,
-        metadata: Optional[dict[str, Any]] = None,
+        db_path: str | None = None,
+        embedding_function: "EmbeddingFunction[Any] | None" = None,
+        metadata: dict[str, Any] | None = None,
         llm: Optional["LLM"] = None,
-        collection_name: Optional[str] = None,
+        collection_name: str | None = None,
     ) -> None:
-        """
-        Initializes the VectorChromaQueryEngine with db_path, metadata, and embedding function and llm.
+        """Initializes the VectorChromaQueryEngine with db_path, metadata, and embedding function and llm.
+
         Args:
             db_path: The file system path where Chromadb will store its persistent data.
                 If not specified, the default directory "./chroma" is used.
@@ -79,15 +79,12 @@ class VectorChromaQueryEngine:
             "hnsw:M": 32,
         }
         self.client = chromadb.PersistentClient(path=db_path or "./chroma")
-        self.collection_name: Optional[str] = collection_name
+        self.collection_name: str | None = collection_name
 
         self.connect_db()
 
     def connect_db(self, *args: Any, **kwargs: Any) -> bool:
-        """
-        Establish a connection to the Chromadb database and initialize the collection.
-        """
-
+        """Establish a connection to the Chromadb database and initialize the collection."""
         self.collection_name = self.collection_name or DEFAULT_COLLECTION_NAME
 
         if self._collection_exists(self.collection_name):
@@ -106,8 +103,7 @@ class VectorChromaQueryEngine:
         return True
 
     def query(self, question: str) -> str:
-        """
-        Retrieve information from indexed documents by processing a natural language query.
+        """Retrieve information from indexed documents by processing a natural language query.
 
         Args:
             question: A natural language query string used to search the indexed documents.
@@ -126,11 +122,10 @@ class VectorChromaQueryEngine:
 
     def add_docs(
         self,
-        new_doc_dir: Optional[Union[Path, str]] = None,
-        new_doc_paths_or_urls: Optional[Sequence[Union[Path, str]]] = None,
+        new_doc_dir: Path | str | None = None,
+        new_doc_paths_or_urls: Sequence[Path | str] | None = None,
     ) -> None:
-        """
-        Add additional documents to the existing vector index.
+        """Add additional documents to the existing vector index.
 
         Loads new Docling-parsed Markdown files from a specified directory or a list of file paths
         and inserts them into the current index for future queries.
@@ -149,10 +144,9 @@ class VectorChromaQueryEngine:
             self.index.insert(doc)
 
     def _load_doc(  # type: ignore[no-any-unimported]
-        self, input_dir: Optional[Union[Path, str]], input_docs: Optional[Sequence[Union[Path, str]]]
+        self, input_dir: Path | str | None, input_docs: Sequence[Path | str] | None
     ) -> list["LlamaDocument"]:
-        """
-        Load documents from a directory and/or a list of file paths.
+        """Load documents from a directory and/or a list of file paths.
 
         This helper method reads Docling-parsed Markdown files using LlamaIndex's
         SimpleDirectoryReader. It supports multiple file [formats]((https://docs.llamaindex.ai/en/stable/module_guides/loading/simpledirectoryreader/#supported-file-types)),
@@ -194,8 +188,7 @@ class VectorChromaQueryEngine:
     def _create_index(  # type: ignore[no-any-unimported]
         self, collection: "Collection"
     ) -> "VectorStoreIndex":
-        """
-        Build a vector index for document retrieval using a Chromadb collection.
+        """Build a vector index for document retrieval using a Chromadb collection.
 
         Wraps the provided Chromadb collection into a vector store and uses LlamaIndex's
         StorageContext to create a VectorStoreIndex from the collection.
@@ -214,8 +207,7 @@ class VectorChromaQueryEngine:
         return index
 
     def _collection_exists(self, collection_name: str) -> bool:
-        """
-        Check if a collection with the given name exists in the database.
+        """Check if a collection with the given name exists in the database.
 
         Args:
             collection_name (str): The name of the collection to check.
@@ -227,8 +219,7 @@ class VectorChromaQueryEngine:
         return any(col == collection_name for col in existing_collections)
 
     def get_collection_name(self) -> str:
-        """
-        Get the name of the collection used by the query engine.
+        """Get the name of the collection used by the query engine.
 
         Returns:
             The name of the collection.
@@ -245,8 +236,8 @@ class VectorChromaQueryEngine:
 
     def init_db(
         self,
-        new_doc_dir: Optional[Union[Path, str]] = None,
-        new_doc_paths_or_urls: Optional[Sequence[Union[Path, str]]] = None,
+        new_doc_dir: Path | str | None = None,
+        new_doc_paths_or_urls: Sequence[Path | str] | None = None,
         *args: Any,
         **kwargs: Any,
     ) -> bool:
@@ -262,30 +253,25 @@ class AnswerWithCitations(BaseModel):  # type: ignore[no-any-unimported]
 @require_optional_import(["chromadb", "llama_index"], "rag")
 @export_module("autogen.agents.experimental")
 class VectorChromaCitationQueryEngine(VectorChromaQueryEngine):
-    """
-    This engine leverages VectorChromaQueryEngine and CitationQueryEngine to answer queries with citations.
-    """
+    """This engine leverages VectorChromaQueryEngine and CitationQueryEngine to answer queries with citations."""
 
     def __init__(  # type: ignore[no-any-unimported]
         self,
-        db_path: Optional[str] = None,
-        embedding_function: "Optional[EmbeddingFunction[Any]]" = None,
-        metadata: Optional[dict[str, Any]] = None,
+        db_path: str | None = None,
+        embedding_function: "EmbeddingFunction[Any] | None" = None,
+        metadata: dict[str, Any] | None = None,
         llm: Optional["LLM"] = None,
-        collection_name: Optional[str] = None,
+        collection_name: str | None = None,
         enable_query_citations: bool = False,
         citation_chunk_size: int = 512,
     ) -> None:
-        """
-        see parent class VectorChromaQueryEngine.
-        """
+        """See parent class VectorChromaQueryEngine."""
         super().__init__(db_path, embedding_function, metadata, llm, collection_name)
         self.enable_query_citations = enable_query_citations
         self.citation_chunk_size = citation_chunk_size
 
     def query_with_citations(self, query: str) -> AnswerWithCitations:
-        """
-        Query the index with the given query and return the answer along with citations.
+        """Query the index with the given query and return the answer along with citations.
 
         Args:
             query (str): The query to be answered.
@@ -294,7 +280,6 @@ class VectorChromaCitationQueryEngine(VectorChromaQueryEngine):
         Returns:
             AnswerWithCitations: An object containing the answer and citations.
         """
-
         query_engine = CitationQueryEngine.from_args(
             index=self.index,
             citation_chunk_size=self.citation_chunk_size,

autogen/agents/experimental/document_agent/docling_doc_ingest_agent.py

@@ -4,7 +4,7 @@
 
 import logging
 from pathlib import Path
-from typing import Literal, Optional, Union
+from typing import Literal
 
 from .... import ConversableAgent
 from ....agentchat.contrib.rag.query_engine import RAGQueryEngine
@@ -30,22 +30,19 @@ You are an expert in parsing and understanding text. You can use {DOCLING_PARSE_
 
 @export_module("autogen.agents.experimental")
 class DoclingDocIngestAgent(ConversableAgent):
-    """
-    A DoclingDocIngestAgent is a swarm agent that ingests documents using the docling_parse_docs tool.
-    """
+    """A DoclingDocIngestAgent is a swarm agent that ingests documents using the docling_parse_docs tool."""
 
     def __init__(
         self,
-        name: Optional[str] = None,
-        llm_config: Optional[Union[LLMConfig, dict, Literal[False]]] = None,  # type: ignore[type-arg]
-        parsed_docs_path: Optional[Union[Path, str]] = None,
-        query_engine: Optional[RAGQueryEngine] = None,
+        name: str | None = None,
+        llm_config: LLMConfig | dict | Literal[False] | None = None,  # type: ignore[type-arg]
+        parsed_docs_path: Path | str | None = None,
+        query_engine: RAGQueryEngine | None = None,
         return_agent_success: str = "TaskManagerAgent",
         return_agent_error: str = "ErrorManagerAgent",
-        collection_name: Optional[str] = None,
+        collection_name: str | None = None,
     ):
-        """
-        Initialize the DoclingDocIngestAgent.
+        """Initialize the DoclingDocIngestAgent.
 
         Args:
             name: The name of the DoclingDocIngestAgent.
@@ -64,8 +61,7 @@ class DoclingDocIngestAgent(ConversableAgent):
         self._query_engine = query_engine or VectorChromaQueryEngine(collection_name=collection_name)
 
         def data_ingest_task(context_variables: ContextVariables) -> ReplyResult:
-            """
-            A tool for Swarm agent to ingests documents using the docling_parse_docs to parse documents to markdown
+            """A tool for Swarm agent to ingests documents using the docling_parse_docs to parse documents to markdown
             and add them to the docling_query_engine.
 
             Args:
@@ -74,7 +70,6 @@ class DoclingDocIngestAgent(ConversableAgent):
             Returns:
             ReplyResult: The result of the task.
             """
-
             try:
                 input_file_path = ""
                 tasks = context_variables.get("DocumentsToIngest", [])

autogen/agents/experimental/document_agent/document_agent.py

@@ -5,7 +5,7 @@
 import logging
 from copy import deepcopy
 from pathlib import Path
-from typing import Annotated, Any, Optional, Union, cast
+from typing import Annotated, Any, cast
 
 from pydantic import BaseModel, Field
 
@@ -123,7 +123,7 @@ class DocumentTask(BaseModel):
 class DocumentTriageAgent(ConversableAgent):
     """The DocumentTriageAgent is responsible for deciding what type of task to perform from user requests."""
 
-    def __init__(self, llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None):
+    def __init__(self, llm_config: LLMConfig | dict[str, Any] | None = None):
         # Add the structured message to the LLM configuration
         structured_config_list = deepcopy(llm_config)
         structured_config_list["response_format"] = DocumentTask  # type: ignore[index]
@@ -145,20 +145,19 @@ class DocumentTriageAgent(ConversableAgent):
 
 @export_module("autogen.agents.experimental")
 class DocAgent(ConversableAgent):
-    """
-    The DocAgent is responsible for ingest and querying documents.
+    """The DocAgent is responsible for ingest and querying documents.
 
     Internally, it generates a group chat with a set of agents to ingest, query, and summarize.
     """
 
     def __init__(
         self,
-        name: Optional[str] = None,
-        llm_config: Optional[Union[LLMConfig, dict[str, Any]]] = None,
-        system_message: Optional[str] = None,
-        parsed_docs_path: Optional[Union[str, Path]] = None,
-        collection_name: Optional[str] = None,
-        query_engine: Optional[RAGQueryEngine] = None,
+        name: str | None = None,
+        llm_config: LLMConfig | dict[str, Any] | None = None,
+        system_message: str | None = None,
+        parsed_docs_path: str | Path | None = None,
+        collection_name: str | None = None,
+        query_engine: RAGQueryEngine | None = None,
     ):
         """Initialize the DocAgent.
 
@@ -564,14 +563,14 @@ class DocAgent(ConversableAgent):
         self.register_reply([Agent, None], DocAgent.generate_inner_group_chat_reply)
 
         self.documents_ingested: list[str] = []
-        self._group_chat_context_variables: Optional[ContextVariables] = None
+        self._group_chat_context_variables: ContextVariables | None = None
 
     def generate_inner_group_chat_reply(
         self,
-        messages: Optional[Union[list[dict[str, Any]], str]] = None,
-        sender: Optional[Agent] = None,
-        config: Optional[OpenAIWrapper] = None,
-    ) -> tuple[bool, Optional[Union[str, dict[str, Any]]]]:
+        messages: list[dict[str, Any]] | str | None = None,
+        sender: Agent | None = None,
+        config: OpenAIWrapper | None = None,
+    ) -> tuple[bool, str | dict[str, Any] | None]:
         """Reply function that generates the inner group chat reply for the DocAgent.
 
         Args:
@@ -628,7 +627,7 @@ class DocAgent(ConversableAgent):
 
         return True, chat_result.summary
 
-    def _get_document_input_message(self, messages: Optional[Union[list[dict[str, Any]], str]]) -> str:  # type: ignore[type-arg]
+    def _get_document_input_message(self, messages: list[dict[str, Any]] | str | None) -> str:  # type: ignore[type-arg]
         """Gets and validates the input message(s) for the document agent.
 
         Args:

autogen/agents/experimental/document_agent/document_conditions.py

@@ -2,7 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
-from typing import TYPE_CHECKING, Any, List, cast
+from typing import TYPE_CHECKING, Any, cast
 
 from ....agentchat.group.available_condition import AvailableCondition
 from .document_utils import Ingest, Query
@@ -40,9 +40,9 @@ class SummaryTaskAvailableCondition(AvailableCondition):
             True if all conditions are met (ready for summary), False otherwise
         """
         # Get variables from context with appropriate casting
-        documents_to_ingest: List[Ingest] = cast(List[Ingest], agent.context_variables.get(self.documents_var, []))
+        documents_to_ingest: list[Ingest] = cast(list[Ingest], agent.context_variables.get(self.documents_var, []))
 
-        queries_to_run: List[Query] = cast(List[Query], agent.context_variables.get(self.queries_var, []))
+        queries_to_run: list[Query] = cast(list[Query], agent.context_variables.get(self.queries_var, []))
 
         completed_task_count = bool(agent.context_variables.get(self.completed_var, 0))
 

autogen/agents/experimental/document_agent/document_utils.py

@@ -5,7 +5,7 @@
 import logging
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Any
 from urllib.parse import urlparse
 
 from pydantic import BaseModel, Field
@@ -244,7 +244,7 @@ def _is_valid_extension_for_file_type(extension: str, file_type: InputFormat) ->
 
 
 @require_optional_import(["selenium", "webdriver_manager", "requests"], "rag")
-def download_url(url: Any, output_dir: Optional[Union[str, Path]] = None) -> Path:
+def download_url(url: Any, output_dir: str | Path | None = None) -> Path:
     """Download the content of a URL and save it as a file.
 
     For direct file URLs (.md, .pdf, .docx, etc.), downloads the raw file.
@@ -296,7 +296,7 @@ def download_url(url: Any, output_dir: Optional[Union[str, Path]] = None) -> Pat
     return _download_binary_file(url=final_url, output_dir=output_dir)
 
 
-def list_files(directory: Union[Path, str]) -> list[Path]:
+def list_files(directory: Path | str) -> list[Path]:
     """Recursively list all files in a directory.
 
     This function will raise an exception if the directory does not exist.
@@ -310,9 +310,8 @@ def list_files(directory: Union[Path, str]) -> list[Path]:
 
 
 @export_module("autogen.agents.experimental.document_agent")
-def handle_input(input_path: Union[Path, str], output_dir: Union[Path, str] = "./output") -> list[Path]:
+def handle_input(input_path: Path | str, output_dir: Path | str = "./output") -> list[Path]:
     """Process the input string and return the appropriate file paths"""
-
     output_dir = preprocess_path(str_or_path=output_dir, is_dir=True, mk_path=True)
     if isinstance(input_path, str) and is_url(input_path):
         _logger.info("Detected URL. Downloading content...")
@@ -336,9 +335,7 @@ def handle_input(input_path: Union[Path, str], output_dir: Union[Path, str] = ".
 
 
 @export_module("autogen.agents.experimental.document_agent")
-def preprocess_path(
-    str_or_path: Union[Path, str], mk_path: bool = False, is_file: bool = False, is_dir: bool = True
-) -> Path:
+def preprocess_path(str_or_path: Path | str, mk_path: bool = False, is_file: bool = False, is_dir: bool = True) -> Path:
     """Preprocess the path for file operations.
 
     Args:
@@ -350,7 +347,6 @@ def preprocess_path(
     Returns:
         Path: The preprocessed path.
     """
-
     # Convert the input to a Path object if it's a string
     temp_path = Path(str_or_path)
 

autogen/agents/experimental/document_agent/inmemory_query_engine.py

@@ -5,8 +5,9 @@
 import copy
 import json
 import os
+from collections.abc import Sequence
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
 
@@ -38,15 +39,14 @@ class QueryAnswer(BaseModel):
 
 @export_module("autogen.agents.experimental")
 class InMemoryQueryEngine:
-    """
-    This engine stores ingested documents in memory and then injects them into an internal agent's system message for answering queries.
+    """This engine stores ingested documents in memory and then injects them into an internal agent's system message for answering queries.
 
     This implements the autogen.agentchat.contrib.rag.RAGQueryEngine protocol.
     """
 
     def __init__(
         self,
-        llm_config: Union[LLMConfig, dict[str, Any]],
+        llm_config: LLMConfig | dict[str, Any],
     ) -> None:
         # Deep copy the llm config to avoid changing the original
         structured_config = copy.deepcopy(llm_config)
@@ -65,7 +65,6 @@ class InMemoryQueryEngine:
 
     def query(self, question: str, *args: Any, **kwargs: Any) -> str:
         """Run a query against the ingested documents and return the answer."""
-
         # If no documents have been ingested, return an empty response
         if not self._ingested_documents:
             return QUERY_NO_INGESTIONS_REPLY
@@ -116,11 +115,10 @@ class InMemoryQueryEngine:
 
     def add_docs(
         self,
-        new_doc_dir: Optional[Union[Path, str]] = None,
-        new_doc_paths_or_urls: Optional[Sequence[Union[Path, str]]] = None,
+        new_doc_dir: Path | str | None = None,
+        new_doc_paths_or_urls: Sequence[Path | str] | None = None,
     ) -> None:
-        """
-        Add additional documents to the in-memory store
+        """Add additional documents to the in-memory store
 
         Loads new Docling-parsed Markdown files from a specified directory or a list of file paths
         and inserts them into the in-memory store.
@@ -135,11 +133,8 @@ class InMemoryQueryEngine:
         new_doc_paths = new_doc_paths_or_urls or []
         self._load_doc(input_dir=new_doc_dir, input_docs=new_doc_paths)
 
-    def _load_doc(
-        self, input_dir: Optional[Union[Path, str]], input_docs: Optional[Sequence[Union[Path, str]]]
-    ) -> None:
-        """
-        Load documents from a directory and/or a list of file paths into the in-memory store.
+    def _load_doc(self, input_dir: Path | str | None, input_docs: Sequence[Path | str] | None) -> None:
+        """Load documents from a directory and/or a list of file paths into the in-memory store.
 
         This helper method reads files using native Python file operations and stores them
         in the in-memory document store. It supports reading text-based files, with the primary
@@ -179,16 +174,15 @@ class InMemoryQueryEngine:
                     raise ValueError(f"Document file not found: {doc_path}")
                 self._read_and_store_file(doc_path)
 
-    def _read_and_store_file(self, file_path: Union[Path, str]) -> None:
-        """
-        Read a file and store its content in the in-memory document store.
+    def _read_and_store_file(self, file_path: Path | str) -> None:
+        """Read a file and store its content in the in-memory document store.
 
         Args:
             file_path (Union[Path, str]): Path to the file to be read
         """
         file_path = Path(file_path)
         try:
-            with open(file_path, "r", encoding="utf-8") as file:
+            with open(file_path, encoding="utf-8") as file:
                 content = file.read()
 
             # Store the document in the in-memory store
@@ -199,8 +193,8 @@ class InMemoryQueryEngine:
 
     def init_db(
         self,
-        new_doc_dir: Optional[Union[Path, str]] = None,
-        new_doc_paths_or_urls: Optional[Sequence[Union[Path, str]]] = None,
+        new_doc_dir: Path | str | None = None,
+        new_doc_paths_or_urls: Sequence[Path | str] | None = None,
         *args: Any,
         **kwargs: Any,
     ) -> bool:

autogen/agents/experimental/document_agent/parser_utils.py

@@ -7,7 +7,7 @@ import logging
 import os
 import time
 from pathlib import Path
-from typing import Annotated, Optional, Union
+from typing import Annotated
 
 from ....doc_utils import export_module
 from ....import_utils import optional_import_block, require_optional_import
@@ -27,9 +27,9 @@ logger.setLevel(logging.DEBUG)
 @require_optional_import(["docling"], "rag")
 @export_module("autogen.agents.experimental.document_agent")
 def docling_parse_docs(  # type: ignore[no-any-unimported]
-    input_file_path: Annotated[Union[Path, str], "Path to the input file or directory"],
-    output_dir_path: Annotated[Optional[Union[Path, str]], "Path to the output directory"] = None,
-    output_formats: Annotated[Optional[list[str]], "List of output formats (markdown, json)"] = None,
+    input_file_path: Annotated[Path | str, "Path to the input file or directory"],
+    output_dir_path: Annotated[Path | str | None, "Path to the output directory"] = None,
+    output_formats: Annotated[list[str] | None, "List of output formats (markdown, json)"] = None,
     table_output_format: str = "html",
 ) -> list[Path]:
     """Convert documents into a Deep Search document format using EasyOCR

autogen/agents/experimental/document_agent/url_utils.py

@@ -3,7 +3,7 @@
 # SPDX-License-Identifier: Apache-2.0
 
 from enum import Enum
-from typing import Any, Optional, Tuple
+from typing import Any
 from urllib.parse import urlparse
 
 from ....import_utils import optional_import_block, require_optional_import
@@ -84,9 +84,7 @@ ExtensionToFormat = {
 
 
 class URLAnalyzer:
-    """
-    A class that analyzes URLs to determine if they point to web pages or files.
-    """
+    """A class that analyzes URLs to determine if they point to web pages or files."""
 
     # Mapping of input formats to their corresponding MIME types
     FormatToMimeType: dict[InputFormat, list[str]] = {
@@ -125,22 +123,20 @@ class URLAnalyzer:
                 MimeTypeToFormat[mime_type] = format_type
 
     def __init__(self, url: str):
-        """
-        Initialize the URLAnalyzer with a URL.
+        """Initialize the URLAnalyzer with a URL.
 
         Args:
             url (str): The URL to analyze
         """
         self.url = url
-        self.analysis_result: Optional[dict[str, Any]] = None
-        self.final_url: Optional[str] = None
+        self.analysis_result: dict[str, Any] | None = None
+        self.final_url: str | None = None
         self.redirect_chain: list[str] = []
 
     def analyze(
         self, test_url: bool = False, follow_redirects: bool = True, prioritize_extension: bool = True
     ) -> dict[str, Any]:
-        """
-        Analyze the URL to determine if it points to a web page or a file.
+        """Analyze the URL to determine if it points to a web page or a file.
 
         Args:
             test_url (bool): Whether to test the URL by making a request
@@ -213,8 +209,7 @@ class URLAnalyzer:
         return result
 
     def _analyze_by_extension(self, url: str) -> dict[str, Any]:
-        """
-        Analyze URL based on its file extension.
+        """Analyze URL based on its file extension.
 
         Args:
             url (str): The URL to analyze
@@ -247,9 +242,8 @@ class URLAnalyzer:
         }
 
     @require_optional_import(["requests"], "rag")
-    def _analyze_by_request(self, follow_redirects: bool = True) -> Optional[dict[str, Any]]:
-        """
-        Analyze URL by making a HEAD request to check Content-Type.
+    def _analyze_by_request(self, follow_redirects: bool = True) -> dict[str, Any] | None:
+        """Analyze URL by making a HEAD request to check Content-Type.
 
         Args:
             follow_redirects (bool): Whether to follow redirects
@@ -346,9 +340,8 @@ class URLAnalyzer:
             # If the request fails for any other reason
             return {"is_file": False, "file_type": InputFormat.INVALID, "mime_type": None, "error": str(e)}
 
-    def get_result(self) -> Optional[dict[str, Any]]:
-        """
-        Get the last analysis result, or None if the URL hasn't been analyzed yet.
+    def get_result(self) -> dict[str, Any] | None:
+        """Get the last analysis result, or None if the URL hasn't been analyzed yet.
 
         Returns:
             Optional[dict]: The analysis result or None
@@ -356,8 +349,7 @@ class URLAnalyzer:
         return self.analysis_result
 
     def get_redirect_info(self) -> dict[str, Any]:
-        """
-        Get information about redirects that occurred during the last request.
+        """Get information about redirects that occurred during the last request.
 
         Returns:
             dict: Information about redirects
@@ -380,9 +372,8 @@ class URLAnalyzer:
         }
 
     @require_optional_import(["requests"], "rag")
-    def follow_redirects(self) -> Tuple[str, list[str]]:
-        """
-        Follow redirects for the URL without analyzing content types.
+    def follow_redirects(self) -> tuple[str, list[str]]:
+        """Follow redirects for the URL without analyzing content types.
 
         Returns:
             Tuple[str, list[str]]: The final URL and the redirect chain