fix: resolve a flood of console warnings (#1089)

Author: iziang

aperag/flow/engine.py

@@ -378,7 +378,7 @@ def _bind_node_inputs(self, node: NodeInstance, runner_info: dict) -> tuple:
         resolved_inputs = self.resolve_expression(raw_inputs, node.id)
         input_model = runner_info["input_model"]
         try:
-            user_input = input_model.parse_obj(resolved_inputs)
+            user_input = input_model.model_validate(resolved_inputs)
         except Exception as e:
             raise ValidationError(f"Input validation error for node {node.id}: {e}")
         sys_input = SystemInput(**self.context.global_variables)
@@ -400,7 +400,7 @@ async def _execute_node(self, node: NodeInstance) -> None:
                     node.id,
                     node.type,
                     self.execution_id,
-                    {"node_type": node.type, "inputs": user_input.dict()},
+                    {"node_type": node.type, "inputs": user_input.model_dump()},
                 )
             )
             outputs = await runner.run(user_input, sys_input)

aperag/index/fulltext_index.py

@@ -37,14 +37,14 @@ def __init__(self, es_host: str = None):
         # Add timeout configuration for sync ES client
         self.es = Elasticsearch(
             self.es_host,
-            timeout=settings.es_timeout,  # Use timeout from settings
+            request_timeout=settings.es_timeout,  # Use timeout from settings
             max_retries=settings.es_max_retries,  # Use max retries from settings
             retry_on_timeout=True,  # Retry on timeout errors
         )
         # Add timeout configuration for async ES client using settings
         self.async_es = AsyncElasticsearch(
             self.es_host,
-            timeout=settings.es_timeout,  # Use timeout from settings
+            request_timeout=settings.es_timeout,  # Use timeout from settings
             max_retries=settings.es_max_retries,  # Use max retries from settings
             retry_on_timeout=True,  # Retry on timeout errors
         )
@@ -266,7 +266,7 @@ def __init__(self, ctx: Dict[str, Any]):
         # Add timeout configuration for ES client using settings
         self.client = AsyncElasticsearch(
             ctx.get("es_host", "http://127.0.0.1:9200"),
-            timeout=ctx.get("es_timeout", settings.es_timeout),  # Use timeout from context or settings
+            request_timeout=ctx.get("es_timeout", settings.es_timeout),  # Use timeout from context or settings
             max_retries=ctx.get("es_max_retries", settings.es_max_retries),  # Use max retries from context or settings
             retry_on_timeout=True,  # Retry on timeout errors
         )
@@ -291,7 +291,7 @@ async def extract(self, text):
                 logger.warning("index %s not exists", self.index_name)
                 return []
 
-            resp = await self.client.indices.analyze(index=self.index_name, body={"text": text}, analyzer="ik_smart")
+            resp = await self.client.indices.analyze(index=self.index_name, body={"text": text, "analyzer": "ik_smart"})
             tokens = {}
             for item in resp.body["tokens"]:
                 token = item["token"]
@@ -307,7 +307,7 @@ async def extract(self, text):
 
 es = Elasticsearch(
     settings.es_host,
-    timeout=settings.es_timeout,  # Use timeout from settings
+    request_timeout=settings.es_timeout,  # Use timeout from settings
     max_retries=settings.es_max_retries,  # Use max retries from settings
     retry_on_timeout=True,  # Retry on timeout errors
 )

aperag/schema/utils.py

@@ -20,7 +20,7 @@
 def parseCollectionConfig(config: str) -> CollectionConfig:
     try:
         config_dict = json.loads(config)
-        collection_config = CollectionConfig.parse_obj(config_dict)
+        collection_config = CollectionConfig.model_validate(config_dict)
         return collection_config
     except json.JSONDecodeError as e:
         raise ValueError(f"Invalid JSON string: {str(e)}")

aperag/service/collection_service.py

@@ -254,10 +254,10 @@ async def create_search(
             user=user,
             collection_id=collection_id,
             query=data.query,
-            vector_search=data.vector_search.dict() if data.vector_search else None,
-            fulltext_search=data.fulltext_search.dict() if data.fulltext_search else None,
-            graph_search=data.graph_search.dict() if data.graph_search else None,
-            items=[item.dict() for item in items],
+            vector_search=data.vector_search.model_dump() if data.vector_search else None,
+            fulltext_search=data.fulltext_search.model_dump() if data.fulltext_search else None,
+            graph_search=data.graph_search.model_dump() if data.graph_search else None,
+            items=[item.model_dump() for item in items],
         )
         return SearchResult(
             id=record.id,

aperag/utils/audit_decorator.py

@@ -31,24 +31,24 @@ def _extract_response_data(response: Any) -> Optional[Dict[str, Any]]:
         if isinstance(response, dict):
             return response
 
-        # If response has a dict() method (Pydantic models)
-        elif hasattr(response, "dict"):
-            return response.dict()
-
         # If response has a model_dump() method (Pydantic v2)
         elif hasattr(response, "model_dump"):
             return response.model_dump()
 
+        # If response has a dict() method (Pydantic models)
+        elif hasattr(response, "dict"):
+            return response.dict()
+
         # If response is a list of dicts or models
         elif isinstance(response, list):
             result = []
             for item in response:
                 if isinstance(item, dict):
                     result.append(item)
-                elif hasattr(item, "dict"):
-                    result.append(item.dict())
                 elif hasattr(item, "model_dump"):
                     result.append(item.model_dump())
+                elif hasattr(item, "dict"):
+                    result.append(item.dict())
                 else:
                     result.append(str(item))
             return {"items": result}
@@ -119,15 +119,15 @@ def _extract_request_data_from_args(request: Request, kwargs: dict) -> Optional[
 
             # Try to serialize the value
             try:
-                if hasattr(value, "dict"):  # Pydantic model
-                    serialized = value.dict()
-                    # Clean up the serialized data - remove null values and filter sensitive data
+                if hasattr(value, "model_dump"):  # Pydantic v2
+                    serialized = value.model_dump()
+                    # Clean up the serialized data
                     cleaned_data = _clean_data_for_audit(serialized)
                     if cleaned_data:  # Only add if there's actual data
                         parsed_data[key] = cleaned_data
-                elif hasattr(value, "model_dump"):  # Pydantic v2
-                    serialized = value.model_dump()
-                    # Clean up the serialized data
+                elif hasattr(value, "dict"):  # Pydantic model
+                    serialized = value.dict()
+                    # Clean up the serialized data - remove null values and filter sensitive data
                     cleaned_data = _clean_data_for_audit(serialized)
                     if cleaned_data:  # Only add if there's actual data
                         parsed_data[key] = cleaned_data

aperag/vectorstore/qdrant_connector.py

@@ -53,17 +53,17 @@ def search(self, query: QueryWithEmbedding, **kwargs):
         search_params = kwargs.get("search_params")
         score_threshold = kwargs.get("score_threshold", 0.1)
 
-        hits = self.client.search(
+        hits = self.client.query_points(
             collection_name=self.collection_name,
-            query_vector=query.embedding,
+            query=query.embedding,
             with_vectors=True,
             limit=query.top_k,
             consistency=consistency,
             search_params=search_params,
             score_threshold=score_threshold,
         )
 
-        results = [self._convert_scored_point_to_document_with_score(point) for point in hits]
+        results = [self._convert_scored_point_to_document_with_score(point) for point in hits.points]
         results = [result for result in results if result is not None]
 
         return QueryResult(