Chore : rm dead code detected by pylance (#24588)

api/controllers/console/workspace/tool_providers.py

     def get(self, provider):
         user = current_user
 
-        user_id = user.id
         tenant_id = user.current_tenant_id
 
         return jsonable_encoder(BuiltinToolManageService.get_builtin_tool_provider_info(tenant_id, provider))

api/core/indexing_runner.py

                         documents.append(document)
 
             # build index
-            # get the process rule
-            processing_rule = (
-                db.session.query(DatasetProcessRule)
-                .where(DatasetProcessRule.id == dataset_document.dataset_process_rule_id)
-                .first()
-            )
-
             index_type = dataset_document.doc_form
             index_processor = IndexProcessorFactory(index_type).init_index_processor()
             self._load(

api/core/llm_generator/llm_generator.py

     def instruction_modify_legacy(
         tenant_id: str, flow_id: str, current: str, instruction: str, model_config: dict, ideal_output: str | None
     ) -> dict:
-        app: App | None = db.session.query(App).where(App.id == flow_id).first()
         last_run: Message | None = (
             db.session.query(Message).where(Message.app_id == flow_id).order_by(Message.created_at.desc()).first()
         )

api/core/rag/datasource/vdb/oracle/oraclevector.py

         if not isinstance(top_k, int) or top_k <= 0 or top_k > 10000:
             top_k = 5  # Use default if invalid
         # just not implement fetch by score_threshold now, may be later
-        score_threshold = float(kwargs.get("score_threshold") or 0.0)
         if len(query) > 0:
             # Check which language the query is in
             zh_pattern = re.compile("[\u4e00-\u9fa5]+")

api/extensions/storage/clickzetta_volume/clickzetta_volume_storage.py

 
             # Get the actual volume path (may include dify_km prefix)
             volume_path = self._get_volume_path(filename, dataset_id)
-            actual_filename = volume_path.split("/")[-1] if "/" in volume_path else volume_path
 
             # For User Volume, use the full path with dify_km prefix
             if volume_prefix == "USER VOLUME":

api/extensions/storage/clickzetta_volume/file_lifecycle.py

 import json
 import logging
 from dataclasses import asdict, dataclass
-from datetime import datetime, timedelta
+from datetime import datetime
 from enum import Enum
 from typing import Any, Optional
 
                 versions.append(current_metadata)
 
             # 获取历史版本
-            version_pattern = f"{self._version_prefix}{filename}.v*"
             try:
                 version_files = self._storage.scan(self._dataset_id or "", files=True)
                 for file_path in version_files:
         """
         try:
             cleaned_count = 0
-            cutoff_date = datetime.now() - timedelta(days=max_age_days)
 
             # 获取所有版本文件
             try:

api/services/dataset_service.py

         with redis_client.lock(lock_name, timeout=20):
             index_node_id = str(uuid.uuid4())
             index_node_hash = helper.generate_text_hash(content)
-            child_chunk_count = (
-                db.session.query(ChildChunk)
-                .where(
-                    ChildChunk.tenant_id == current_user.current_tenant_id,
-                    ChildChunk.dataset_id == dataset.id,
-                    ChildChunk.document_id == document.id,
-                    ChildChunk.segment_id == segment.id,
-                )
-                .count()
-            )
             max_position = (
                 db.session.query(func.max(ChildChunk.position))
                 .where(

api/tasks/retry_document_indexing_task.py

 
     Usage: retry_document_indexing_task.delay(dataset_id, document_ids)
     """
-    documents: list[Document] = []
     start_at = time.perf_counter()
     try:
         dataset = db.session.query(Dataset).where(Dataset.id == dataset_id).first()