xparse-client 0.2.8__py3-none-any.whl → 0.2.10__py3-none-any.whl

example/run_pipeline.py

@@ -84,7 +84,7 @@ def run_with_config():
 
 def run_with_manual_setup():
     """手动创建 Source、Destination 和 Pipeline"""
-    from xparse_client import ChunkConfig, EmbedConfig, ParseConfig, Stage, PipelineConfig, LocalDestination
+    from xparse_client import ChunkConfig, EmbedConfig, ParseConfig, Stage, PipelineConfig, LocalDestination, QdrantDestination
     
     # 创建 S3 数据源
     # source = S3Source(
@@ -132,7 +132,7 @@ def run_with_manual_setup():
         endpoint='https://s3.us-east-1.amazonaws.com',
         access_key='AKIA6QUE3TVZADUWA4PO',
         secret_key='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',
-        bucket='textin-xparse',
+        bucket='textin-test',
         prefix='',
         region='us-east-1'
     )
@@ -160,7 +160,8 @@ def run_with_manual_setup():
     # )
     # source = LocalSource(
     #     directory='/Users/ke_wang/Documents/doc',
-    #     pattern='*.pdf'  # 支持通配符: *.pdf, *.docx, **/*.txt
+    #     recursive=True,
+    #     pattern=['**/*.png']  # 支持通配符: *.pdf, *.docx, **/*.txt
     # )
     
     # 创建 Milvus 目的地
@@ -174,12 +175,12 @@ def run_with_manual_setup():
     #     output_dir='./result'
     # )
 
-    destination = MilvusDestination(
-        db_path='https://in03-5388093d0db1707.serverless.ali-cn-hangzhou.cloud.zilliz.com.cn', # zilliz连接地址
-        collection_name='textin_test_3_copy', # 数据库collection名称
-        dimension=1024,  # 向量维度，需与 embed API 返回一致
-        api_key='872c3f5b3f3995c80dcda5c3d34f1f608815aef7671b6ee391ab37e40e79c892ce56d9c8c6565a03a3fd66da7e11b67f384c5c46'  # Zilliz Cloud API Key
-    )
+    # destination = MilvusDestination(
+    #     db_path='https://in03-5388093d0db1707.serverless.ali-cn-hangzhou.cloud.zilliz.com.cn', # zilliz连接地址
+    #     collection_name='textin_test_3_copy', # 数据库collection名称
+    #     dimension=1024,  # 向量维度，需与 embed API 返回一致
+    #     api_key='872c3f5b3f3995c80dcda5c3d34f1f608815aef7671b6ee391ab37e40e79c892ce56d9c8c6565a03a3fd66da7e11b67f384c5c46'  # Zilliz Cloud API Key
+    # )
 
     # destination = S3Destination(
     #     endpoint='https://cos.ap-shanghai.myqcloud.com',
@@ -189,12 +190,19 @@ def run_with_manual_setup():
     #     prefix='result',
     #     region='ap-shanghai'
     # )
+
+    destination = QdrantDestination(
+        url='https://1325db22-7dd8-4fc9-930b-f969d4963b3d.us-east-1-1.aws.cloud.qdrant.io:6333',
+        collection_name='textin1',
+        dimension=1024,
+        api_key='eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2Nlc3MiOiJtIn0.TGnFB1pAD7c7IqSOvTpgCPpHXSnnoKhWEQ5pQ8DrBnI',
+    )
     
     # 使用新的 stages 格式创建配置
     stages = [
         Stage(
             type='parse',
-            config=ParseConfig(provider='textin-lite')
+            config=ParseConfig(provider='paddle')
         ),
         Stage(
             type='chunk',
@@ -236,8 +244,8 @@ def run_with_manual_setup():
     )
     
     # 运行
-    config = pipeline.get_config()
-    print(json.dumps(config, ensure_ascii=False, indent=2))
+    # config = pipeline.get_config()
+    pipeline.run()
 
 
 # ============================================================================

example/run_pipeline_test.py

@@ -86,14 +86,14 @@ def run_with_manual_setup():
     from xparse_client import ChunkConfig, EmbedConfig, ParseConfig, Stage
     
     # 创建 S3 数据源
-    # source = S3Source(
-    #     endpoint='https://textin-minio-api.ai.intsig.net',
-    #     access_key='IEQspf8C7fVcgmp3AZWl',
-    #     secret_key='kLj96I8FGbIrPFW08meXivCy4AVdzBijOJWKWOt1',
-    #     bucket='textin-test',
-    #     prefix='',
-    #     region='us-east-1'
-    # )
+    source = S3Source(
+        endpoint='https://textin-minio-api.ai.intsig.net',
+        access_key='IEQspf8C7fVcgmp3AZWl',
+        secret_key='kLj96I8FGbIrPFW08meXivCy4AVdzBijOJWKWOt1',
+        bucket='textin-test',
+        prefix='',
+        region='us-east-1'
+    )
     source = S3Source(
         endpoint='https://s3.oss-cn-shanghai.aliyuncs.com',
         access_key='LTAI5tBgsaVfkbh9rbPyuB17',

xparse_client/__init__.py

@@ -10,7 +10,7 @@ logging.basicConfig(
 
 from .pipeline.config import ParseConfig, ChunkConfig, EmbedConfig, Stage, PipelineStats, PipelineConfig
 from .pipeline.sources import Source, S3Source, LocalSource, FtpSource, SmbSource
-from .pipeline.destinations import Destination, MilvusDestination, LocalDestination, S3Destination
+from .pipeline.destinations import Destination, MilvusDestination, QdrantDestination, LocalDestination, S3Destination
 from .pipeline.pipeline import Pipeline, create_pipeline_from_config
 
 __all__ = [
@@ -27,6 +27,7 @@ __all__ = [
     'SmbSource',
     'Destination',
     'MilvusDestination',
+    'QdrantDestination',
     'LocalDestination',
     'S3Destination',
     'Pipeline',

xparse_client/pipeline/destinations.py

@@ -13,7 +13,8 @@ from typing import List, Dict, Any
 
 from botocore.config import Config
 from pymilvus import MilvusClient
-
+from qdrant_client import QdrantClient
+from qdrant_client.models import Distance, VectorParams, PointStruct, PayloadSchemaType
 
 logger = logging.getLogger(__name__)
 
@@ -127,7 +128,7 @@ class MilvusDestination(Destination):
                         print(f"  ✓ 删除现有记录: record_id={record_id}, 删除 {deleted_count} 条")
                         logger.info(f"删除 Milvus 现有记录: record_id={record_id}, 删除 {deleted_count} 条")
                     else:
-                        print(f"  → 未找到现有记录: record_id={record_id}")
+                        print(f"  → 准备写入记录: record_id={record_id}")
                 except Exception as e:
                     print(f"  ! 删除现有记录失败: {str(e)}")
                     logger.warning(f"删除 Milvus 现有记录失败: record_id={record_id}, {str(e)}")
@@ -296,9 +297,190 @@ class S3Destination(Destination):
             return False
 
 
+class QdrantDestination(Destination):
+    """Qdrant 向量数据库目的地"""
+
+    def __init__(self, url: str, collection_name: str, dimension: int, api_key: str = None, prefer_grpc: bool = False):
+        """初始化 Qdrant 目的地
+        
+        Args:
+            url: Qdrant 服务地址（如 'http://localhost:6333' 或 'https://xxx.qdrant.io'）
+            collection_name: Collection 名称
+            dimension: 向量维度
+            api_key: API Key（可选，用于 Qdrant Cloud）
+            prefer_grpc: 是否优先使用 gRPC（默认 False，使用 HTTP）
+        """
+        
+        self.url = url
+        self.collection_name = collection_name
+        self.dimension = dimension
+        
+        client_kwargs = {'url': url}
+        if api_key:
+            client_kwargs['api_key'] = api_key
+        if prefer_grpc:
+            client_kwargs['prefer_grpc'] = True
+        
+        self.client = QdrantClient(**client_kwargs)
+        
+        # 检查或创建 collection
+        try:
+            collections = self.client.get_collections()
+            collection_exists = any(col.name == collection_name for col in collections.collections)
+            
+            if not collection_exists:
+                self.client.create_collection(
+                    collection_name=collection_name,
+                    vectors_config=VectorParams(
+                        size=dimension,
+                        distance=Distance.COSINE
+                    )
+                )
+                # 为 record_id 创建索引，用于过滤查询
+                try:
+                    self.client.create_payload_index(
+                        collection_name=collection_name,
+                        field_name="record_id",
+                        field_schema=PayloadSchemaType.KEYWORD
+                    )
+                    print(f"✓ Qdrant Collection 创建: {collection_name} (维度: {dimension})")
+                except Exception as e:
+                    logger.warning(f"创建 record_id 索引失败（可能已存在）: {str(e)}")
+                    print(f"✓ Qdrant Collection 创建: {collection_name} (维度: {dimension})")
+            else:
+                print(f"✓ Qdrant Collection 存在: {collection_name}")
+                # 确保 record_id 索引存在（如果不存在则创建）
+                try:
+                    self.client.create_payload_index(
+                        collection_name=collection_name,
+                        field_name="record_id",
+                        field_schema=PayloadSchemaType.KEYWORD
+                    )
+                except Exception as e:
+                    # 索引可能已存在，忽略错误
+                    logger.debug(f"record_id 索引可能已存在: {str(e)}")
+            
+            logger.info(f"Qdrant 连接成功: {url}/{collection_name}")
+        except Exception as e:
+            print(f"✗ Qdrant 连接失败: {str(e)}")
+            logger.error(f"Qdrant 连接失败: {str(e)}")
+            raise
+
+    def write(self, data: List[Dict[str, Any]], metadata: Dict[str, Any]) -> bool:
+        try:
+            # 如果 metadata 中有 record_id，先删除相同 record_id 的现有记录
+            record_id = metadata.get('record_id')
+            if record_id:
+                try:
+                    # 查询并删除相同 record_id 的所有记录
+                    # 使用字典格式的 filter（兼容性更好）
+                    scroll_result = self.client.scroll(
+                        collection_name=self.collection_name,
+                        scroll_filter={
+                            "must": [
+                                {
+                                    "key": "record_id",
+                                    "match": {"value": record_id}
+                                }
+                            ]
+                        },
+                        limit=10000  # 假设单次最多删除 10000 条
+                    )
+                    
+                    if scroll_result[0]:  # 有记录
+                        point_ids = [point.id for point in scroll_result[0]]
+                        self.client.delete(
+                            collection_name=self.collection_name,
+                            points_selector=point_ids
+                        )
+                        print(f"  ✓ 删除现有记录: record_id={record_id}, 删除 {len(point_ids)} 条")
+                        logger.info(f"删除 Qdrant 现有记录: record_id={record_id}, 删除 {len(point_ids)} 条")
+                    else:
+                        print(f"  → 准备写入记录: record_id={record_id}")
+                except Exception as e:
+                    print(f"  ! 删除现有记录失败: {str(e)}")
+                    logger.warning(f"删除 Qdrant 现有记录失败: record_id={record_id}, {str(e)}")
+                    # 继续执行写入，不因为删除失败而中断
+            else:
+                print(f"  → 没有 record_id")
+                logger.warning(f"没有 record_id")
+                return False
+            
+            points = []
+            for item in data:
+                # 获取元素级别的 metadata
+                element_metadata = item.get('metadata', {})
+                
+                if 'embeddings' in item and item['embeddings']:
+                    element_id = item.get('element_id') or item.get('id') or str(uuid.uuid4())
+                    
+                    # 构建 payload（元数据）
+                    payload = {
+                        'text': item.get('text', ''),
+                        'record_id': record_id,
+                    }
+                    
+                    # 合并文件级别的 metadata 和元素级别的 metadata
+                    # 文件级别的 metadata 优先级更高
+                    merged_metadata = {**element_metadata, **metadata}
+                    
+                    # 将 metadata 中的字段添加到 payload
+                    # 排除已存在的固定字段，避免冲突
+                    fixed_fields = {'embeddings', 'text', 'element_id', 'record_id', 'created_at', 'metadata'}
+                    for key, value in merged_metadata.items():
+                        if key not in fixed_fields:
+                            # 特殊处理 data_source 字段：如果是字典则递归展平
+                            if key == 'data_source' and isinstance(value, dict):
+                                # 递归展平 data_source 字典，包括嵌套的字典
+                                flattened = _flatten_dict(value, 'data_source', fixed_fields)
+                                payload.update(flattened)
+                            elif key == 'coordinates' and isinstance(value, list):
+                                payload[key] = value
+                            elif isinstance(value, (dict, list)):
+                                # Qdrant 支持 JSON 格式的 payload
+                                payload[key] = value
+                            else:
+                                payload[key] = value
+                    
+                    # 创建 Point（id 是必需的）
+                    # Qdrant 的 point id 可以是整数或 UUID 字符串
+                    # 如果 element_id 是 UUID 格式，直接使用；否则转换为 UUID5（基于 element_id 生成稳定的 UUID）
+                    try:
+                        # 尝试将 element_id 解析为 UUID
+                        point_id = str(uuid.UUID(element_id))
+                    except (ValueError, TypeError):
+                        # 如果不是有效的 UUID，使用 UUID5 基于 element_id 生成稳定的 UUID
+                        point_id = str(uuid.uuid5(uuid.NAMESPACE_URL, str(element_id)))
+                    
+                    point = PointStruct(
+                        id=point_id,
+                        vector=item['embeddings'],
+                        payload=payload
+                    )
+                    points.append(point)
+
+            if not points:
+                print(f"  ! 警告: 没有有效的向量数据")
+                return False
+
+            # 批量插入
+            self.client.upsert(
+                collection_name=self.collection_name,
+                points=points
+            )
+            print(f"  ✓ 写入 Qdrant: {len(points)} 条")
+            logger.info(f"写入 Qdrant 成功: {len(points)} 条")
+            return True
+        except Exception as e:
+            print(f"  ✗ 写入 Qdrant 失败: {str(e)}")
+            logger.error(f"写入 Qdrant 失败: {str(e)}")
+            return False
+
+
 __all__ = [
     'Destination',
     'MilvusDestination',
+    'QdrantDestination',
     'LocalDestination',
     'S3Destination',
 ]

xparse_client/pipeline/pipeline.py

@@ -12,7 +12,7 @@ import requests
 
 from .config import ParseConfig, ChunkConfig, EmbedConfig, Stage, PipelineStats, PipelineConfig
 from .sources import Source, S3Source, LocalSource, FtpSource, SmbSource
-from .destinations import Destination, MilvusDestination, LocalDestination, S3Destination
+from .destinations import Destination, MilvusDestination, QdrantDestination, LocalDestination, S3Destination
 
 
 logger = logging.getLogger(__name__)
@@ -145,6 +145,14 @@ class Pipeline:
                 'dimension': self.destination.dimension
             })
             # api_key 和 token 不在对象中保存，无法恢复
+        elif isinstance(self.destination, QdrantDestination):
+            config['destination'].update({
+                'url': self.destination.url,
+                'collection_name': self.destination.collection_name,
+                'dimension': self.destination.dimension,
+                'prefer_grpc': getattr(self.destination, 'prefer_grpc', False)
+            })
+            # api_key 不在对象中保存，无法恢复
         elif isinstance(self.destination, LocalDestination):
             config['destination'].update({
                 'output_dir': str(self.destination.output_dir)
@@ -503,6 +511,14 @@ def create_pipeline_from_config(config: Dict[str, Any]) -> Pipeline:
             api_key=dest_config.get('api_key'),
             token=dest_config.get('token')
         )
+    elif dest_config['type'] == 'qdrant':
+        destination = QdrantDestination(
+            url=dest_config['url'],
+            collection_name=dest_config['collection_name'],
+            dimension=dest_config['dimension'],
+            api_key=dest_config.get('api_key'),
+            prefer_grpc=dest_config.get('prefer_grpc', False)
+        )
     elif dest_config['type'] == 'local':
         destination = LocalDestination(
             output_dir=dest_config['output_dir']

xparse_client/pipeline/sources.py

@@ -11,7 +11,7 @@ from datetime import datetime, timezone
 from email.utils import parsedate_to_datetime
 from fnmatch import fnmatch
 from pathlib import Path
-from typing import List, Dict, Any, Tuple
+from typing import List, Dict, Any, Tuple, Optional
 
 from smb.SMBConnection import SMBConnection
 from botocore.config import Config
@@ -20,6 +20,56 @@ from botocore.config import Config
 logger = logging.getLogger(__name__)
 
 
+def _normalize_wildcard_patterns(pattern: Optional[List[str]]) -> Optional[List[str]]:
+    """规范化通配符模式列表
+    
+    Args:
+        pattern: 通配符模式列表，如果为 None 或空列表则返回 None（表示匹配所有文件）
+        
+    Returns:
+        通配符模式列表，如果 pattern 是 None、空列表或包含 "*" 则返回 None（表示匹配所有文件）
+    """
+    if pattern is None or not pattern:
+        return None  # None 表示匹配所有文件
+
+    if not isinstance(pattern, list):
+        raise ValueError(f"pattern 类型错误: {type(pattern)}")
+    
+    # 过滤空字符串并去除空格
+    normalized = [p.strip() for p in pattern if p and p.strip()]
+    
+    if not normalized:
+        return None
+    
+    # 如果包含 "*"，直接返回 None（匹配所有文件，减少后续开销）
+    if '*' in normalized:
+        return None
+    
+    return normalized
+
+
+def _match_file_extension(file_path: str, wildcard_patterns: Optional[List[str]]) -> bool:
+    """检查文件路径是否匹配通配符模式
+    
+    Args:
+        file_path: 文件路径
+        wildcard_patterns: 已规范化的通配符模式列表（如 ['*.pdf', '*.docx']）
+        
+    Returns:
+        如果匹配返回 True，否则返回 False
+    """
+    # 如果 wildcard_patterns 是 None 或空列表，匹配所有文件
+    if wildcard_patterns is None:
+        return True
+    
+    # 检查是否匹配任何一个通配符模式
+    for wildcard_pattern in wildcard_patterns:
+        if fnmatch(file_path, wildcard_pattern):
+            return True
+    
+    return False
+
+
 def _to_millis_timestamp_string(timestamp):
     """将时间戳转换为毫秒时间戳字符串
     
@@ -62,11 +112,11 @@ class S3Source(Source):
     """S3/MinIO 数据源"""
 
     def __init__(self, endpoint: str, access_key: str, secret_key: str,
-                 bucket: str, prefix: str = '', region: str = 'us-east-1', pattern: str = '*', recursive: bool = False):
+                 bucket: str, prefix: str = '', region: str = 'us-east-1', pattern: Optional[List[str]] = None, recursive: bool = False):
         self.endpoint = endpoint
         self.bucket = bucket
         self.prefix = prefix
-        self.pattern = pattern or '*'
+        self.pattern = _normalize_wildcard_patterns(pattern)  # 在初始化时规范化
         self.recursive = recursive
 
         if self.endpoint == 'https://textin-minio-api.ai.intsig.net':
@@ -108,7 +158,7 @@ class S3Source(Source):
                     key = obj['Key']
                     if key.endswith('/') or key.endswith('empty.tmp'):
                         continue
-                    if fnmatch(key, self.pattern):
+                    if _match_file_extension(key, self.pattern):
                         files.append(key)
             
             # 非递归模式下，CommonPrefixes 包含子目录，我们忽略它们
@@ -156,9 +206,9 @@ class S3Source(Source):
 class LocalSource(Source):
     """本地文件系统数据源"""
 
-    def __init__(self, directory: str, pattern: str = '*', recursive: bool = False):
+    def __init__(self, directory: str, pattern: Optional[List[str]] = None, recursive: bool = False):
         self.directory = Path(directory)
-        self.pattern = pattern or '*'
+        self.pattern = _normalize_wildcard_patterns(pattern)  # 在初始化时规范化
         self.recursive = recursive
 
         if not self.directory.exists():
@@ -168,20 +218,29 @@ class LocalSource(Source):
         logger.info(f"本地目录: {self.directory}")
 
     def list_files(self) -> List[str]:
+        all_files = []
+        # 匹配所有文件
         if self.recursive:
-            # 递归模式：使用 rglob
-            files = [
+            all_files.extend([
                 str(f.relative_to(self.directory))
-                for f in self.directory.rglob(self.pattern)
+                for f in self.directory.rglob('*')
                 if f.is_file()
-            ]
+            ])
         else:
-            # 非递归模式：只列出根目录下的文件，使用 glob
-            files = [
+            all_files.extend([
                 str(f.relative_to(self.directory))
-                for f in self.directory.glob(self.pattern)
+                for f in self.directory.glob('*')
                 if f.is_file()
-            ]
+            ])
+        
+        files = []
+        if self.pattern is not None:
+            for file in all_files:
+                if _match_file_extension(file, self.pattern):
+                    files.append(file)
+        else:
+            files.extend(all_files)
+        
         print(f"✓ 本地找到 {len(files)} 个文件")
         return files
 
@@ -217,12 +276,12 @@ class LocalSource(Source):
 class FtpSource(Source):
     """FTP 数据源"""
 
-    def __init__(self, host: str, port: int, username: str, password: str, pattern: str = '*', recursive: bool = False):
+    def __init__(self, host: str, port: int, username: str, password: str, pattern: Optional[List[str]] = None, recursive: bool = False):
         self.host = host
         self.port = port
         self.username = username
         self.password = password
-        self.pattern = pattern or '*'
+        self.pattern = _normalize_wildcard_patterns(pattern)  # 在初始化时规范化
         self.recursive = recursive
 
         self.client = ftplib.FTP()
@@ -288,12 +347,12 @@ class FtpSource(Source):
                             except:
                                 # 不是目录，是文件
                                 relative_path = full_path.lstrip('/')
-                                if fnmatch(relative_path, self.pattern):
+                                if _match_file_extension(relative_path, self.pattern):
                                     files.append(relative_path)
                         else:
                             # 是文件
                             relative_path = full_path.lstrip('/')
-                            if fnmatch(relative_path, self.pattern):
+                            if _match_file_extension(relative_path, self.pattern):
                                 files.append(relative_path)
                     
                     # 恢复原始目录
@@ -325,7 +384,7 @@ class FtpSource(Source):
                     item_type = item_info.get('type', 'unknown')
                     # 只添加文件，排除目录
                     if item_type == 'file' or (item_type == 'unknown' and not item_info.get('type', '').startswith('dir')):
-                        if fnmatch(item_name, self.pattern):
+                        if _match_file_extension(item_name, self.pattern):
                             files.append(item_name)
             except:
                 # 如果不支持 MLSD，使用 LIST 命令
@@ -341,7 +400,7 @@ class FtpSource(Source):
                                 continue
                             is_dir = parts[0].startswith('d')
                             # 只添加文件，排除目录
-                            if not is_dir and fnmatch(item_name, self.pattern):
+                            if not is_dir and _match_file_extension(item_name, self.pattern):
                                 files.append(item_name)
                 except:
                     # 最后回退到 nlst，通过尝试切换目录来判断是否为目录
@@ -357,7 +416,7 @@ class FtpSource(Source):
                             continue
                         except:
                             # 不能切换，说明是文件
-                            if fnmatch(item_name, self.pattern):
+                            if _match_file_extension(item_name, self.pattern):
                                 files.append(item_name)
             
             # 确保回到原始目录
@@ -405,7 +464,7 @@ class SmbSource(Source):
     """SMB/CIFS 数据源"""
 
     def __init__(self, host: str, share_name: str, username: str, password: str,
-                 domain: str = '', port: int = 445, path: str = '', pattern: str = '*', recursive: bool = False):
+                 domain: str = '', port: int = 445, path: str = '', pattern: Optional[List[str]] = None, recursive: bool = False):
         self.host = host
         self.share_name = share_name
         self.username = username
@@ -413,7 +472,7 @@ class SmbSource(Source):
         self.domain = domain
         self.port = port
         self.path = path.strip('/').strip('\\') if path else ''
-        self.pattern = pattern or '*'
+        self.pattern = _normalize_wildcard_patterns(pattern)  # 在初始化时规范化
         self.recursive = recursive
 
         self.conn = SMBConnection(
@@ -451,7 +510,7 @@ class SmbSource(Source):
                             _list_recursive(conn, share, item_path)
                         # 非递归模式：忽略子目录
                     else:
-                        if fnmatch(relative_path, self.pattern):
+                        if _match_file_extension(relative_path, self.pattern):
                             files.append(relative_path)
             except Exception as e:
                 logger.warning(f"列出路径失败 {current_path}: {str(e)}")

{xparse_client-0.2.8.dist-info → xparse_client-0.2.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xparse-client
-Version: 0.2.8
+Version: 0.2.10
 Summary: 面向Agent和RAG的新一代文档处理 AI Infra
 License-Expression: MIT
 Project-URL: Homepage, https://gitlab.intsig.net/xparse1/xparse-pipeline
@@ -13,6 +13,7 @@ Requires-Dist: boto3
 Requires-Dist: pymilvus[milvus_lite]
 Requires-Dist: requests
 Requires-Dist: pysmb
+Requires-Dist: qdrant-client
 Dynamic: license-file
 
 # xParse
@@ -24,7 +25,7 @@ xParse的同步pipeline实现，支持多种数据源与输出。
 ## 🌟 特点
 
 - **灵活的数据源**：支持兼容 S3 协议的对象存储、本地文件系统以及 FTP/SMB 协议文件系统
-- **灵活的输出**：支持 Milvus/Zilliz 向量数据库、兼容 S3 协议的对象存储以及本地文件系统
+- **灵活的输出**：支持 Milvus/Zilliz/Qdrant 向量数据库、兼容 S3 协议的对象存储以及本地文件系统
 - **统一 Pipeline API**：使用 `/api/xparse/pipeline` 一次性完成 parse → chunk → embed 全流程
 - **配置化处理**：支持灵活配置 parse、chunk、embed 参数
 - **详细统计信息**：返回每个阶段的处理统计数据
@@ -51,7 +52,7 @@ xParse的同步pipeline实现，支持多种数据源与输出。
                │ [embeddings + stats]
                ▼
        ┌──────────────┐
-       │ Destination  │  目的地（Milvus/Zilliz/本地）
+       │ Destination  │  目的地（Milvus/Zilliz/Qdrant/本地）
        └──────────────┘
 ```
 
@@ -69,7 +70,7 @@ pip install --upgrade xparse-client
 
 #### 代码配置
 ```python
-from xparse_client import ParseConfig, ChunkConfig, EmbedConfig, Stage, Pipeline, S3Source, MilvusDestination
+from xparse_client import ParseConfig, ChunkConfig, EmbedConfig, Stage, Pipeline, S3Source, MilvusDestination, QdrantDestination
 
 # 使用新的 stages 格式创建配置
 stages = [
@@ -173,7 +174,7 @@ source = S3Source(
     bucket='textin',
     prefix='',
     region='us-east-1',
-    pattern='*.pdf'  # 可选，使用 Shell 通配符过滤对象
+    pattern=['*.pdf']  # 可选，通配符模式列表，支持多个扩展名
 )
 ```
 请确保配置的访问凭证至少包括以下几项权限：
@@ -193,7 +194,7 @@ source = S3Source(
     bucket='textin',
     prefix='',
     region='cn-shanghai',
-    pattern='*.pdf'  # 可选，使用 Shell 通配符过滤对象
+    pattern=['*.pdf']  # 可选，通配符模式列表，支持多个扩展名
 )
 ```
 请确保配置的访问凭证至少包括以下几项权限：
@@ -214,7 +215,7 @@ source = S3Source(
     bucket='textin',
     prefix='',
     region='ap-shanghai',
-    pattern='*.pdf'  # 可选，使用 Shell 通配符过滤对象
+    pattern=['*.pdf']  # 可选，通配符模式列表，支持多个扩展名
 )
 ```
 
@@ -235,7 +236,7 @@ source = S3Source(
     bucket='textin',
     prefix='',
     region='cn-shanghai',
-    pattern='*.pdf'  # 可选，使用 Shell 通配符过滤对象
+    pattern=['*.pdf']  # 可选，通配符模式列表，支持多个扩展名
 )
 ```
 
@@ -257,7 +258,7 @@ source = S3Source(
     bucket='textin',
     prefix='',
     region='cn-east-3',
-    pattern='*.pdf'  # 可选，使用 Shell 通配符过滤对象
+    pattern=['*.pdf']  # 可选，通配符模式列表，支持多个扩展名
 )
 ```
 
@@ -279,7 +280,7 @@ source = S3Source(
     bucket='textin-xparse',
     prefix='',
     region='us-east-1',
-    pattern='*.pdf'  # 可选，使用 Shell 通配符过滤对象
+    pattern=['*.pdf']  # 可选，通配符模式列表，支持多个扩展名
 )
 ```
 请确保配置的访问凭证至少包括以下几项权限：
@@ -294,7 +295,7 @@ s3:GetObject
 ```python
 source = LocalSource(
     directory='./input',
-    pattern='*.pdf'  # 支持通配符: *.pdf, *.docx, **/*.txt
+    pattern=['*.pdf', '*.docx']  # 支持多个通配符模式列表
 )
 ```
 
@@ -306,7 +307,7 @@ source = FtpSource(
     port=21,
     username='', # 用户名，按照实际填写
     password='',  # 密码，按照实际填写
-    pattern='*.pdf'  # 可选，过滤指定类型文件
+    pattern=['*.pdf']  # 可选，通配符模式列表，过滤指定类型文件
 )
 ```
 
@@ -319,11 +320,11 @@ source = SmbSource(
     username='',  # 用户名，按照实际填写
     password='',  # 密码，按照实际填写
     domain='your-smb-domain',
-    pattern='**/*.pdf'  # 可选，支持多级匹配
+    pattern=['**/*.pdf']  # 可选，通配符模式列表，支持多级匹配
 )
 ```
 
-> 注 1：所有 Source 均支持 `pattern` 参数，使用 Shell 通配符（`*.pdf`、`**/*.txt` 等）来过滤需要处理的文件；默认为 `*`，即处理全部文件。
+> 注 1：所有 Source 均支持 `pattern` 参数，使用通配符模式列表（如 `['*.pdf', '*.docx']`）来过滤需要处理的文件。支持多个通配符模式，如果列表中包含 `'*'` 则匹配所有文件。默认为 `None`，即处理全部文件。
 
 > 注 2：所有 Source 均支持 `recursive` 参数，表示是否递归遍历，默认为 `False`。
 
@@ -354,6 +355,28 @@ destination = MilvusDestination(
 )
 ```
 
+#### Qdrant 向量存储
+
+```python
+destination = QdrantDestination(
+    url='http://localhost:6333',  # Qdrant 服务地址（本地或云端）
+    collection_name='my_collection',  # Collection 名称
+    dimension=1024,  # 向量维度，需与 embed API 返回一致
+    api_key='your-api-key',  # 可选，Qdrant Cloud API Key
+    prefer_grpc=False  # 可选，是否优先使用 gRPC（默认 False）
+)
+```
+
+**Qdrant Cloud 示例：**
+```python
+destination = QdrantDestination(
+    url='https://xxxxxxx.us-east-1-0.aws.cloud.qdrant.io',
+    collection_name='my_collection',
+    dimension=1024,
+    api_key='your-api-key'
+)
+```
+
 #### 本地文件系统目的地
 
 将在配置的本地文件地址中写入`json`文件。
@@ -533,7 +556,7 @@ source = S3Source(
     bucket='documents',
     prefix='pdfs/',
     region='us-east-1',
-    pattern='*.pdf',  # 仅处理匹配的文件
+    pattern=['*.pdf'],  # 仅处理匹配的文件
     recursive=False   # 不递归子目录
 )
 
@@ -597,7 +620,7 @@ from xparse_client import (
 # 手动创建 Pipeline
 source = LocalSource(
     directory='./test_files',
-    pattern='*.pdf',
+    pattern=['*.pdf'],
     recursive=False
 )
 
@@ -644,7 +667,7 @@ from xparse_client import (
 # 创建本地数据源
 source = LocalSource(
     directory='./test_files',
-    pattern='*.pdf',
+    pattern=['*.pdf'],
     recursive=False
 )
 
@@ -771,7 +794,7 @@ source = FtpSource(
     port=21,
     username='user',
     password='pass',
-    pattern='*.pdf',
+    pattern=['*.pdf'],
     recursive=False
 )
 
@@ -831,7 +854,7 @@ from xparse_client import (
 # 创建 Pipeline
 source = LocalSource(
     directory='./docs',
-    pattern='*.pdf',
+    pattern=['*.pdf'],
     recursive=False
 )
 

xparse_client-0.2.10.dist-info/RECORD

@@ -0,0 +1,13 @@
+example/run_pipeline.py,sha256=d4pPDqjiC9dPNh6nmArPOF7fPMY0a-jcvdgtNuV-_kM,15795
+example/run_pipeline_test.py,sha256=pxsNiq_LmP6M4R7tTuja0u-Lu7fW-wIBU1uBf0-agQI,14845
+xparse_client/__init__.py,sha256=C2XLxkCoONl6_B1FmDhWRw84TqOL4pZF20br-K26SSY,1721
+xparse_client/pipeline/__init__.py,sha256=TVlb2AGCNKP0jrv3p4ZLZCPKp68hTVMFi00DTdi6QAo,49
+xparse_client/pipeline/config.py,sha256=FFYq2a0dBWBEj70s2aInXOiQ5MwwHimd6SI2_tkp52w,4138
+xparse_client/pipeline/destinations.py,sha256=9UyZ8Ygjoe4yAq6-VZNZBoNYRbb3mahify3c1AdOHMY,20775
+xparse_client/pipeline/pipeline.py,sha256=ZspagUjiL5wnzGJq6A7riOU8qGXJMtg1fqPm9H09mkk,27272
+xparse_client/pipeline/sources.py,sha256=D-kLrSQ-qsFFFq7JC4sL3Y3Q3Q87Wcpv9R5K85YkDjE,22144
+xparse_client-0.2.10.dist-info/licenses/LICENSE,sha256=ckIP-MbocsP9nqYnta5KgfAicYF196B5TNdHIR6kOO0,1075
+xparse_client-0.2.10.dist-info/METADATA,sha256=gIY_PxB1pTxSlKJZjU7z1Iua6ZMtAfMfHFeztWp2zIw,28785
+xparse_client-0.2.10.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+xparse_client-0.2.10.dist-info/top_level.txt,sha256=bfX8BWo1sEEQVsI4Ql4Uu80vrfEh5zfajU9YqFTzxMo,22
+xparse_client-0.2.10.dist-info/RECORD,,

xparse_client-0.2.8.dist-info/RECORD

@@ -1,13 +0,0 @@
-example/run_pipeline.py,sha256=ybAWBPXcQClRk1HOMySLi9IUPIs1Qn-S5HXNLbNJHjs,15459
-example/run_pipeline_test.py,sha256=uIU09FTv_VnTQS1Lc94ydc3kaD86eHkaHQbVXpsGEcA,14861
-xparse_client/__init__.py,sha256=je1ena3HwLL4CRtLU4r6EAzoOIJthlPjTwshxZnzQDM,1677
-xparse_client/pipeline/__init__.py,sha256=TVlb2AGCNKP0jrv3p4ZLZCPKp68hTVMFi00DTdi6QAo,49
-xparse_client/pipeline/config.py,sha256=FFYq2a0dBWBEj70s2aInXOiQ5MwwHimd6SI2_tkp52w,4138
-xparse_client/pipeline/destinations.py,sha256=F0z1AgVIBOn0m32i4l7LCMkJE0IbBdlpykO_at_wLaE,11931
-xparse_client/pipeline/pipeline.py,sha256=IRTxN4YUJi9Wrm1G1ysGvcwsPsGh0inbquBH3nWYmAA,26477
-xparse_client/pipeline/sources.py,sha256=UeVbWv6n0wQkIZIBBhrFCiyydQX7cvwmkoMgcf12p9g,19940
-xparse_client-0.2.8.dist-info/licenses/LICENSE,sha256=ckIP-MbocsP9nqYnta5KgfAicYF196B5TNdHIR6kOO0,1075
-xparse_client-0.2.8.dist-info/METADATA,sha256=LX8TfLSbFZerGPhh16x5QK1lwrPh55CYKNLhr2kdBcY,27850
-xparse_client-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-xparse_client-0.2.8.dist-info/top_level.txt,sha256=bfX8BWo1sEEQVsI4Ql4Uu80vrfEh5zfajU9YqFTzxMo,22
-xparse_client-0.2.8.dist-info/RECORD,,