[CHORE]: x: T = None to x: Optional[T] = None (#24217)

api/controllers/console/apikey.py

-from typing import Any
+from typing import Any, Optional
 
 import flask_restful
 from flask_login import current_user
     method_decorators = [account_initialization_required, login_required, setup_required]
 
     resource_type: str | None = None
-    resource_model: Any = None
+    resource_model: Optional[Any] = None
     resource_id_field: str | None = None
     token_prefix: str | None = None
     max_keys = 10
     method_decorators = [account_initialization_required, login_required, setup_required]
 
     resource_type: str | None = None
-    resource_model: Any = None
+    resource_model: Optional[Any] = None
     resource_id_field: str | None = None
 
     def delete(self, resource_id, api_key_id):

api/core/app/entities/queue_entities.py

     """
 
     event: QueueEvent = QueueEvent.ERROR
-    error: Any = None
+    error: Optional[Any] = None
 
 
 class QueuePingEvent(AppQueueEvent):

api/core/app/task_pipeline/based_generate_task_pipeline.py

         elif isinstance(e, InvokeError | ValueError):
             err = e
         else:
-            err = Exception(e.description if getattr(e, "description", None) is not None else str(e))
+            description = getattr(e, "description", None)
+            err = Exception(description if description is not None else str(e))
 
         if not message_id or not session:
             return err

api/core/extension/extensible.py

 
 
 class ModuleExtension(BaseModel):
-    extension_class: Any = None
+    extension_class: Optional[Any] = None
     name: str
     label: Optional[dict] = None
     form_schema: Optional[list] = None

api/core/extension/extension.py

 
     def extension_class(self, module: ExtensionModule, extension_name: str) -> type:
         module_extension = self.module_extension(module, extension_name)
+        assert module_extension.extension_class is not None
         t: type = module_extension.extension_class
         return t
 

api/core/mcp/session/base_session.py

 from concurrent.futures import Future, ThreadPoolExecutor, TimeoutError
 from datetime import timedelta
 from types import TracebackType
-from typing import Any, Generic, Self, TypeVar
+from typing import Any, Generic, Optional, Self, TypeVar
 
 from httpx import HTTPStatusError
 from pydantic import BaseModel
         request: SendRequestT,
         result_type: type[ReceiveResultT],
         request_read_timeout_seconds: timedelta | None = None,
-        metadata: MessageMetadata = None,
+        metadata: Optional[MessageMetadata] = None,
     ) -> ReceiveResultT:
         """
         Sends a request and wait for a response. Raises an McpError if the

api/core/mcp/types.py

     """A message with specific metadata for transport-specific features."""
 
     message: JSONRPCMessage
-    metadata: MessageMetadata = None
+    metadata: Optional[MessageMetadata] = None
 
 
 class OAuthClientMetadata(BaseModel):

api/core/model_runtime/model_providers/__base/tokenizers/gpt2_tokenizer.py

 import logging
 from threading import Lock
-from typing import Any
+from typing import Any, Optional
 
 logger = logging.getLogger(__name__)
 
-_tokenizer: Any = None
+_tokenizer: Optional[Any] = None
 _lock = Lock()
 
 

api/core/rag/extractor/watercrawl/provider.py

 from collections.abc import Generator
 from datetime import datetime
-from typing import Any
+from typing import Any, Optional
 
 from core.rag.extractor.watercrawl.client import WaterCrawlAPIClient
 
     def __init__(self, api_key, base_url: str | None = None):
         self.client = WaterCrawlAPIClient(api_key, base_url)
 
-    def crawl_url(self, url, options: dict | Any = None) -> dict:
+    def crawl_url(self, url, options: Optional[dict | Any] = None) -> dict:
         options = options or {}
         spider_options = {
             "max_depth": 1,

api/extensions/ext_redis.py

 import ssl
 from collections.abc import Callable
 from datetime import timedelta
-from typing import TYPE_CHECKING, Any, Union
+from typing import TYPE_CHECKING, Any, Optional, Union
 
 import redis
 from redis import RedisError
     app.extensions["redis"] = redis_client
 
 
-def redis_fallback(default_return: Any = None):
+def redis_fallback(default_return: Optional[Any] = None):
     """
     decorator to handle Redis operation exceptions and return a default value when Redis is unavailable.
 

api/services/tools/tools_manage_service.py

 import logging
+from typing import Optional
 
 from core.tools.entities.api_entities import ToolProviderTypeApiLiteral
 from core.tools.tool_manager import ToolManager
 
 class ToolCommonService:
     @staticmethod
-    def list_tool_providers(user_id: str, tenant_id: str, typ: ToolProviderTypeApiLiteral = None):
+    def list_tool_providers(user_id: str, tenant_id: str, typ: Optional[ToolProviderTypeApiLiteral] = None):
         """
         list tool providers
 

api/services/workflow/workflow_converter.py

         )
 
         role_prefix = None
-        prompts: Any = None
+        prompts: Optional[Any] = None
 
         # Chat Model
         if model_config.mode == LLMMode.CHAT.value:

api/tests/integration_tests/vdb/__mock/baiduvectordb.py

 import os
 from collections import UserDict
+from typing import Optional
 from unittest.mock import MagicMock
 
 import pytest
     def mock_vector_db_client(
         self,
         config=None,
-        adapter: HTTPAdapter = None,
+        adapter: Optional[HTTPAdapter] = None,
     ):
         self.conn = MagicMock()
         self._config = MagicMock()

api/tests/integration_tests/vdb/__mock/tcvectordb.py

         key="",
         read_consistency: ReadConsistency = ReadConsistency.EVENTUAL_CONSISTENCY,
         timeout=10,
-        adapter: HTTPAdapter = None,
+        adapter: Optional[HTTPAdapter] = None,
         pool_size: int = 2,
         proxies: Optional[dict] = None,
         password: Optional[str] = None,
         shard: int,
         replicas: int,
         description: Optional[str] = None,
-        index: Index = None,
-        embedding: Embedding = None,
+        index: Optional[Index] = None,
+        embedding: Optional[Embedding] = None,
         timeout: Optional[float] = None,
         ttl_config: Optional[dict] = None,
-        filter_index_config: FilterIndexConfig = None,
+        filter_index_config: Optional[FilterIndexConfig] = None,
         indexes: Optional[list[IndexField]] = None,
     ) -> RPCCollection:
         return RPCCollection(
         database_name: str,
         collection_name: str,
         vectors: list[list[float]],
-        filter: Filter = None,
+        filter: Optional[Filter] = None,
         params=None,
         retrieve_vector: bool = False,
         limit: int = 10,
         collection_name: str,
         ann: Optional[Union[list[AnnSearch], AnnSearch]] = None,
         match: Optional[Union[list[KeywordSearch], KeywordSearch]] = None,
-        filter: Union[Filter, str] = None,
+        filter: Optional[Union[Filter, str]] = None,
         rerank: Optional[Rerank] = None,
         retrieve_vector: Optional[bool] = None,
         output_fields: Optional[list[str]] = None,
         database_name: str,
         collection_name: str,
         document_ids: Optional[list[str]] = None,
-        filter: Filter = None,
+        filter: Optional[Filter] = None,
         timeout: Optional[float] = None,
     ):
         return {"code": 0, "msg": "operation success"}