dtflow 0.4.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

dtflow/schema.py

@@ -0,0 +1,508 @@
+"""
+Schema 验证模块
+
+提供轻量级的数据结构验证，支持字段路径语法。
+
+用法:
+    from dtflow import Schema, Field
+
+    # 定义 Schema
+    schema = Schema({
+        "messages": Field(type="list", required=True, min_length=1),
+        "messages[*].role": Field(type="str", choices=["user", "assistant", "system"]),
+        "messages[*].content": Field(type="str", min_length=1),
+        "score": Field(type="float", min=0, max=1),
+    })
+
+    # 验证单条数据
+    result = schema.validate(item)
+    if result.valid:
+        print("验证通过")
+    else:
+        print(f"验证失败: {result.errors}")
+
+    # 验证整个数据集
+    dt = DataTransformer.load("data.jsonl")
+    results = dt.validate_schema(schema)
+"""
+
+from dataclasses import dataclass, field as dataclass_field
+from typing import Any, Callable, Dict, List, Literal, Optional, Set, Union
+
+from .utils.field_path import get_field, _parse_path, _get_value_by_segments
+
+# 支持的类型
+FieldType = Literal["str", "int", "float", "bool", "list", "dict", "any"]
+
+# 类型映射
+_TYPE_MAP: Dict[str, type] = {
+    "str": str,
+    "int": int,
+    "float": (int, float),  # type: ignore  # float 也接受 int
+    "bool": bool,
+    "list": list,
+    "dict": dict,
+}
+
+
+@dataclass
+class ValidationError:
+    """单个验证错误"""
+
+    path: str  # 字段路径
+    message: str  # 错误信息
+    value: Any = None  # 实际值（可选）
+
+    def __str__(self) -> str:
+        if self.value is not None:
+            return f"{self.path}: {self.message} (got: {self.value!r})"
+        return f"{self.path}: {self.message}"
+
+
+@dataclass
+class ValidationResult:
+    """验证结果"""
+
+    valid: bool
+    errors: List[ValidationError] = dataclass_field(default_factory=list)
+
+    def __bool__(self) -> bool:
+        return self.valid
+
+    def __str__(self) -> str:
+        if self.valid:
+            return "ValidationResult(valid=True)"
+        error_strs = [str(e) for e in self.errors[:5]]
+        if len(self.errors) > 5:
+            error_strs.append(f"... and {len(self.errors) - 5} more errors")
+        return f"ValidationResult(valid=False, errors=[{', '.join(error_strs)}])"
+
+
+@dataclass
+class Field:
+    """
+    字段定义
+
+    Args:
+        type: 期望的类型，可选 "str", "int", "float", "bool", "list", "dict", "any"
+        required: 是否必填（默认 False，明确标记才是必填）
+        nullable: 是否允许 None（默认 False）
+        min: 最小值（数值类型）
+        max: 最大值（数值类型）
+        min_length: 最小长度（字符串或列表）
+        max_length: 最大长度（字符串或列表）
+        choices: 允许的值列表
+        pattern: 正则表达式模式（字符串类型）
+        custom: 自定义验证函数，接收值返回 True/False 或错误信息字符串
+
+    Examples:
+        >>> Field(type="str", required=True, min_length=1)
+        >>> Field(type="int", min=0, max=100)
+        >>> Field(type="str", choices=["user", "assistant", "system"])
+        >>> Field(type="float", min=0, max=1, nullable=True)
+    """
+
+    type: FieldType = "any"
+    required: bool = False  # 默认非必填，明确标记才是必填
+    nullable: bool = False
+    min: Optional[float] = None
+    max: Optional[float] = None
+    min_length: Optional[int] = None
+    max_length: Optional[int] = None
+    choices: Optional[List[Any]] = None
+    pattern: Optional[str] = None
+    custom: Optional[Callable[[Any], Union[bool, str]]] = None
+
+    def validate(self, value: Any, path: str = "") -> List[ValidationError]:
+        """
+        验证单个值
+
+        Args:
+            value: 要验证的值
+            path: 字段路径（用于错误信息）
+
+        Returns:
+            验证错误列表（空列表表示验证通过）
+        """
+        errors: List[ValidationError] = []
+
+        # 检查 None
+        if value is None:
+            if self.nullable:
+                return []  # None 是允许的，跳过后续检查
+            if self.required:
+                errors.append(ValidationError(path, "字段不能为 None", value))
+            return errors
+
+        # 类型检查
+        if self.type != "any":
+            expected_type = _TYPE_MAP.get(self.type)
+            if expected_type and not isinstance(value, expected_type):
+                errors.append(
+                    ValidationError(
+                        path, f"类型错误，期望 {self.type}，实际 {type(value).__name__}", value
+                    )
+                )
+                return errors  # 类型错误，跳过后续检查
+
+        # 数值范围检查
+        if isinstance(value, (int, float)) and not isinstance(value, bool):
+            if self.min is not None and value < self.min:
+                errors.append(ValidationError(path, f"值不能小于 {self.min}", value))
+            if self.max is not None and value > self.max:
+                errors.append(ValidationError(path, f"值不能大于 {self.max}", value))
+
+        # 长度检查
+        if isinstance(value, (str, list, tuple)):
+            length = len(value)
+            if self.min_length is not None and length < self.min_length:
+                errors.append(ValidationError(path, f"长度不能小于 {self.min_length}", length))
+            if self.max_length is not None and length > self.max_length:
+                errors.append(ValidationError(path, f"长度不能大于 {self.max_length}", length))
+
+        # 选项检查
+        if self.choices is not None and value not in self.choices:
+            errors.append(
+                ValidationError(path, f"值必须是 {self.choices} 之一", value)
+            )
+
+        # 正则表达式检查
+        if self.pattern is not None and isinstance(value, str):
+            import re
+
+            if not re.match(self.pattern, value):
+                errors.append(ValidationError(path, f"不匹配模式 {self.pattern}", value))
+
+        # 自定义验证
+        if self.custom is not None:
+            try:
+                result = self.custom(value)
+                if result is False:
+                    errors.append(ValidationError(path, "自定义验证失败", value))
+                elif isinstance(result, str):
+                    errors.append(ValidationError(path, result, value))
+            except Exception as e:
+                errors.append(ValidationError(path, f"自定义验证异常: {e}", value))
+
+        return errors
+
+
+class Schema:
+    """
+    数据结构验证 Schema
+
+    支持字段路径语法定义嵌套结构的验证规则。
+
+    Args:
+        fields: 字段定义字典，键为字段路径，值为 Field 对象
+
+    Examples:
+        >>> schema = Schema({
+        ...     "messages": Field(type="list", required=True, min_length=1),
+        ...     "messages[*].role": Field(type="str", choices=["user", "assistant", "system"]),
+        ...     "messages[*].content": Field(type="str", min_length=1),
+        ...     "score": Field(type="float", min=0, max=1, required=False),
+        ... })
+
+        >>> result = schema.validate({"messages": [{"role": "user", "content": "hello"}]})
+        >>> result.valid
+        True
+    """
+
+    def __init__(self, fields: Dict[str, Field]):
+        self._fields = fields
+        # 分离普通字段和展开字段（包含 [*]）
+        self._regular_fields: Dict[str, Field] = {}
+        self._expand_fields: Dict[str, Field] = {}
+
+        for path, field_def in fields.items():
+            if "[*]" in path:
+                self._expand_fields[path] = field_def
+            else:
+                self._regular_fields[path] = field_def
+
+    def validate(self, data: dict) -> ValidationResult:
+        """
+        验证单条数据
+
+        Args:
+            data: 要验证的字典数据
+
+        Returns:
+            ValidationResult 对象
+        """
+        if not isinstance(data, dict):
+            return ValidationResult(
+                valid=False,
+                errors=[ValidationError("", "数据必须是字典类型", type(data).__name__)],
+            )
+
+        errors: List[ValidationError] = []
+
+        # 验证普通字段
+        for path, field_def in self._regular_fields.items():
+            value = get_field(data, path)
+
+            # 字段不存在
+            if value is None and field_def.required:
+                # 区分「字段不存在」和「字段值为 None」
+                if not self._field_exists(data, path):
+                    errors.append(ValidationError(path, "必填字段缺失"))
+                    continue
+
+            field_errors = field_def.validate(value, path)
+            errors.extend(field_errors)
+
+        # 验证展开字段（包含 [*]）
+        for path, field_def in self._expand_fields.items():
+            expand_errors = self._validate_expand_field(data, path, field_def)
+            errors.extend(expand_errors)
+
+        return ValidationResult(valid=len(errors) == 0, errors=errors)
+
+    def _field_exists(self, data: dict, path: str) -> bool:
+        """检查字段是否存在（区分不存在和值为 None）"""
+        segments = _parse_path(path)
+        current = data
+
+        for seg in segments:
+            if current is None:
+                return False
+            if isinstance(seg, str):
+                if isinstance(current, dict):
+                    if seg not in current:
+                        return False
+                    current = current[seg]
+                else:
+                    return False
+            elif isinstance(seg, int):
+                if isinstance(current, (list, tuple)):
+                    try:
+                        current = current[seg]
+                    except IndexError:
+                        return False
+                else:
+                    return False
+
+        return True
+
+    def _validate_expand_field(
+        self, data: dict, path: str, field_def: Field
+    ) -> List[ValidationError]:
+        """验证包含 [*] 的展开字段"""
+        errors: List[ValidationError] = []
+
+        # 分割路径：[*] 之前的部分和之后的部分
+        parts = path.split("[*]", 1)
+        prefix = parts[0].rstrip(".")
+        suffix = parts[1].lstrip(".") if len(parts) > 1 else ""
+
+        # 获取数组
+        array = get_field(data, prefix) if prefix else data
+
+        if array is None:
+            # 如果前缀字段不存在，由普通字段验证处理
+            return errors
+
+        if not isinstance(array, (list, tuple)):
+            errors.append(ValidationError(prefix, "期望是数组类型", type(array).__name__))
+            return errors
+
+        # 对数组中的每个元素验证
+        for i, item in enumerate(array):
+            actual_path = f"{prefix}[{i}]" if prefix else f"[{i}]"
+
+            if suffix:
+                # 有后缀，获取嵌套值
+                value = get_field(item, suffix) if isinstance(item, dict) else None
+                actual_path = f"{actual_path}.{suffix}"
+            else:
+                value = item
+
+            field_errors = field_def.validate(value, actual_path)
+            errors.extend(field_errors)
+
+        return errors
+
+    def validate_batch(
+        self, data: List[dict], max_errors: int = 100
+    ) -> List[tuple]:
+        """
+        批量验证数据
+
+        Args:
+            data: 数据列表
+            max_errors: 最大错误数量（超过后停止）
+
+        Returns:
+            [(index, ValidationResult), ...] 失败记录列表
+        """
+        failed: List[tuple] = []
+        error_count = 0
+
+        for i, item in enumerate(data):
+            result = self.validate(item)
+            if not result.valid:
+                failed.append((i, result))
+                error_count += len(result.errors)
+                if error_count >= max_errors:
+                    break
+
+        return failed
+
+    def __repr__(self) -> str:
+        field_strs = [f"  {path}: {field_def}" for path, field_def in self._fields.items()]
+        return f"Schema({{\n" + ",\n".join(field_strs) + "\n}})"
+
+
+# ============================================================================
+# 预定义 Schema 模板
+# ============================================================================
+
+
+def openai_chat_schema(
+    min_messages: int = 1,
+    max_messages: Optional[int] = None,
+    roles: Optional[List[str]] = None,
+) -> Schema:
+    """
+    OpenAI Chat 格式的 Schema
+
+    Args:
+        min_messages: 最少消息数（默认 1）
+        max_messages: 最多消息数（默认不限）
+        roles: 允许的角色列表（默认 ["system", "user", "assistant"]）
+
+    Returns:
+        Schema 对象
+
+    Examples:
+        >>> schema = openai_chat_schema()
+        >>> result = schema.validate({"messages": [{"role": "user", "content": "hi"}]})
+    """
+    if roles is None:
+        roles = ["system", "user", "assistant"]
+
+    fields = {
+        "messages": Field(
+            type="list",
+            required=True,
+            min_length=min_messages,
+            max_length=max_messages,
+        ),
+        "messages[*].role": Field(type="str", required=True, choices=roles),
+        "messages[*].content": Field(type="str", required=True, min_length=1),
+    }
+
+    return Schema(fields)
+
+
+def alpaca_schema(
+    require_input: bool = False,
+    min_output_length: int = 1,
+) -> Schema:
+    """
+    Alpaca 格式的 Schema
+
+    Args:
+        require_input: input 字段是否必填（默认 False）
+        min_output_length: output 最小长度（默认 1）
+
+    Returns:
+        Schema 对象
+    """
+    return Schema(
+        {
+            "instruction": Field(type="str", required=True, min_length=1),
+            "input": Field(type="str", required=require_input),
+            "output": Field(type="str", required=True, min_length=min_output_length),
+        }
+    )
+
+
+def dpo_schema(
+    min_chosen_length: int = 1,
+    min_rejected_length: int = 1,
+) -> Schema:
+    """
+    DPO 偏好对格式的 Schema
+
+    Args:
+        min_chosen_length: chosen 最小长度
+        min_rejected_length: rejected 最小长度
+
+    Returns:
+        Schema 对象
+    """
+    return Schema(
+        {
+            "prompt": Field(type="str", required=True, min_length=1),
+            "chosen": Field(type="str", required=True, min_length=min_chosen_length),
+            "rejected": Field(type="str", required=True, min_length=min_rejected_length),
+        }
+    )
+
+
+def sharegpt_schema(
+    min_conversations: int = 1,
+    human_role: str = "human",
+    gpt_role: str = "gpt",
+) -> Schema:
+    """
+    ShareGPT 多轮对话格式的 Schema
+
+    Args:
+        min_conversations: 最少对话轮数
+        human_role: 用户角色名
+        gpt_role: 助手角色名
+
+    Returns:
+        Schema 对象
+    """
+    return Schema(
+        {
+            "conversations": Field(
+                type="list", required=True, min_length=min_conversations
+            ),
+            "conversations[*].from": Field(
+                type="str", required=True, choices=[human_role, gpt_role]
+            ),
+            "conversations[*].value": Field(type="str", required=True, min_length=1),
+        }
+    )
+
+
+# ============================================================================
+# 便捷函数
+# ============================================================================
+
+
+def validate_data(data: Union[dict, List[dict]], schema: Schema) -> ValidationResult:
+    """
+    便捷函数：验证单条或多条数据
+
+    Args:
+        data: 单条数据（dict）或数据列表（List[dict]）
+        schema: Schema 对象
+
+    Returns:
+        ValidationResult（如果是列表，返回汇总结果）
+    """
+    if isinstance(data, dict):
+        return schema.validate(data)
+
+    # 批量验证
+    all_errors: List[ValidationError] = []
+    for i, item in enumerate(data):
+        result = schema.validate(item)
+        if not result.valid:
+            for err in result.errors:
+                all_errors.append(
+                    ValidationError(
+                        path=f"[{i}].{err.path}" if err.path else f"[{i}]",
+                        message=err.message,
+                        value=err.value,
+                    )
+                )
+
+    return ValidationResult(valid=len(all_errors) == 0, errors=all_errors)

{dtflow-0.4.3.dist-info → dtflow-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dtflow
-Version: 0.4.3
+Version: 0.5.0
 Summary: A flexible data transformation tool for ML training formats (SFT, RLHF, Pretrain)
 Project-URL: Homepage, https://github.com/yourusername/DataTransformer
 Project-URL: Documentation, https://github.com/yourusername/DataTransformer#readme
@@ -129,7 +129,7 @@ dt.filter(lambda x: x.language == "zh")
 ### 数据验证
 
 ```python
-# 验证数据，返回不通过的记录列表
+# 简单验证，返回不通过的记录列表
 errors = dt.validate(lambda x: len(x.messages) >= 2)
 
 if errors:
@@ -137,6 +137,53 @@ if errors:
         print(f"第 {e.index} 行: {e.error}")
 ```
 
+### Schema 验证
+
+使用 Schema 进行结构化数据验证：
+
+```python
+from dtflow import Schema, Field, openai_chat_schema
+
+# 使用预设 Schema
+result = dt.validate_schema(openai_chat_schema)
+print(result)  # ValidationResult(valid=950, invalid=50, errors=[...])
+
+# 自定义 Schema
+schema = Schema({
+    "messages": Field(type="list", required=True, min_length=1),
+    "messages[*].role": Field(type="str", choices=["user", "assistant", "system"]),
+    "messages[*].content": Field(type="str", min_length=1),
+    "score": Field(type="float", min=0, max=1),
+})
+
+result = dt.validate_schema(schema)
+
+# 过滤出有效数据
+valid_dt = dt.validate_schema(schema, filter_invalid=True)
+valid_dt.save("valid.jsonl")
+```
+
+**预设 Schema**：
+
+| Schema 名称 | 用途 |
+|------------|------|
+| `openai_chat_schema` | OpenAI messages 格式验证 |
+| `alpaca_schema` | Alpaca instruction/output 格式 |
+| `sharegpt_schema` | ShareGPT conversations 格式 |
+| `dpo_schema` | DPO prompt/chosen/rejected 格式 |
+
+**Field 参数**：
+
+| 参数 | 说明 | 示例 |
+|------|------|------|
+| `type` | 类型验证 | `"str"`, `"int"`, `"float"`, `"bool"`, `"list"`, `"dict"` |
+| `required` | 是否必填 | `True` / `False` |
+| `min` / `max` | 数值范围 | `min=0, max=1` |
+| `min_length` / `max_length` | 长度范围 | `min_length=1` |
+| `choices` | 枚举值 | `choices=["user", "assistant"]` |
+| `pattern` | 正则匹配 | `pattern=r"^\d{4}-\d{2}-\d{2}$"` |
+| `custom` | 自定义验证 | `custom=lambda x: x > 0` |
+
 ### 数据转换
 
 ```python
@@ -286,6 +333,58 @@ dt.transform(to_swift_vlm(images_field="images")).save("swift_vlm.jsonl")
 # 输出: {"messages": [...], "images": ["/path/to/img.jpg"]}
 ```
 
+### 训练框架一键导出
+
+将数据导出为目标训练框架可直接使用的格式，自动生成配置文件：
+
+```python
+from dtflow import DataTransformer
+
+dt = DataTransformer.load("data.jsonl")
+
+# 1. 检查框架兼容性
+result = dt.check_compatibility("llama-factory")
+print(result)
+# ✅ 兼容 - LLaMA-Factory (openai_chat)
+# 或
+# ❌ 不兼容 - 错误: xxx
+
+# 2. 一键导出到 LLaMA-Factory
+files = dt.export_for("llama-factory", "./llama_ready/")
+# 生成文件:
+# - ./llama_ready/custom_dataset.json      # 数据文件
+# - ./llama_ready/dataset_info.json        # 数据集配置
+# - ./llama_ready/train_args.yaml          # 训练参数模板
+
+# 3. 导出到 ms-swift
+files = dt.export_for("swift", "./swift_ready/")
+# 生成: data.jsonl + train_swift.sh
+
+# 4. 导出到 Axolotl
+files = dt.export_for("axolotl", "./axolotl_ready/")
+# 生成: data.jsonl + config.yaml
+
+# 指定数据集名称
+dt.export_for("llama-factory", "./output/", dataset_name="my_sft_data")
+```
+
+**支持的框架**：
+
+| 框架 | 导出内容 | 使用方式 |
+|------|---------|---------|
+| `llama-factory` | data.json + dataset_info.json + train_args.yaml | `llamafactory-cli train train_args.yaml` |
+| `swift` | data.jsonl + train_swift.sh | `bash train_swift.sh` |
+| `axolotl` | data.jsonl + config.yaml | `accelerate launch -m axolotl.cli.train config.yaml` |
+
+**自动格式检测**：
+
+| 检测到的格式 | 数据结构 |
+|------------|---------|
+| `openai_chat` | `{"messages": [{"role": "user", ...}]}` |
+| `alpaca` | `{"instruction": ..., "output": ...}` |
+| `sharegpt` | `{"conversations": [{"from": "human", ...}]}` |
+| `dpo` | `{"prompt": ..., "chosen": ..., "rejected": ...}` |
+
 ### 其他操作
 
 ```python
@@ -361,6 +460,12 @@ dt concat a.jsonl b.jsonl -o merged.jsonl
 
 # 数据统计
 dt stats data.jsonl
+
+# 数据验证
+dt validate data.jsonl --preset=openai_chat           # 使用预设 schema 验证
+dt validate data.jsonl --preset=alpaca --verbose      # 详细输出
+dt validate data.jsonl --preset=sharegpt --filter-invalid -o valid.jsonl  # 过滤出有效数据
+dt validate data.jsonl --preset=dpo --max-errors=100  # 限制错误输出数量
 ```
 
 ### 字段路径语法

{dtflow-0.4.3.dist-info → dtflow-0.5.0.dist-info}/RECORD

@@ -1,15 +1,17 @@
-dtflow/__init__.py,sha256=F5fBna3PxmrOK34SnZxvolzmyi_pjIxNeDkNzGg8wvA,2347
-dtflow/__main__.py,sha256=vuX2--_gXI25vy-Xb1uqhURFzu05VeMUYxIJ2q-XE7M,11656
+dtflow/__init__.py,sha256=fOkG8g8VXS1HFk2ztmaJpjHBXmArHGBW8WE8tHPHXts,3031
+dtflow/__main__.py,sha256=ySpqvEn7k-vsrYFPx-8O6p-yx_24KccgnOSPd2XybhM,12572
 dtflow/converters.py,sha256=gyy-K15zjzGBawFnZa8D9JX37JZ47rey2GhjKa2pxFo,22081
-dtflow/core.py,sha256=5XivbEdcKMrj1wSfju6MDkqdCqkO_mRS-ALWJ3DOcKo,29937
+dtflow/core.py,sha256=HJAlxOaCtwvLOWF9JSC-2li3fsyRE2Q-H9unj9GQJ6M,35445
+dtflow/framework.py,sha256=jyICi_RWHjX7WfsXdSbWmP1SL7y1OWSPyd5G5Y-lvg4,17578
 dtflow/lineage.py,sha256=vQ06lxBHftu-Ma5HlISp3F2eiIvwagQSnUGaLeABDZY,12190
 dtflow/pipeline.py,sha256=zZaC4fg5vsp_30Fhbg75vu0yggsdvf28bWBiVDWzZ6Y,13901
 dtflow/presets.py,sha256=OP1nnM5NFk5Kli9FsXK0xAot48E5OQ6-VOIJT9ffXPg,5023
+dtflow/schema.py,sha256=IFcij22_UFKcgKT1YWwRg2QJO0vcAvCb1arZmsGByts,16824
 dtflow/streaming.py,sha256=jtWQjkhhZqfyzIaFskXNvooGAYDQBn1b6X8FHgaCZYk,22704
 dtflow/tokenizers.py,sha256=zxE6XZGjZ_DOGCjRSClI9xaAbFVf8FS6jwwssGoi_9U,18111
 dtflow/cli/__init__.py,sha256=QhZ-thgx9IBTFII7T_hdoWFUl0CCsdGQHN5ZEZw2XB0,423
 dtflow/cli/clean.py,sha256=y9VCRibgK1j8WIY3h0XZX0m93EdELQC7TdnseMWwS-0,17799
-dtflow/cli/commands.py,sha256=ExcD8Z_uXQhcewvgcPtIlPzsQG4QF93K8Bg6C3uUJHk,1094
+dtflow/cli/commands.py,sha256=ST65Ox_MKu-CKAtPVaxECAPXYOJiF7BhL32A4nsZZl0,1175
 dtflow/cli/common.py,sha256=FsDFVNcLj_874qSg2dGef4V7mqPU9THLchT8PxJpBt8,12955
 dtflow/cli/io_ops.py,sha256=BMDisP6dxzzmSjYwmeFwaHmpHHPqirmXAWeNTD-9MQM,13254
 dtflow/cli/lineage.py,sha256=_lNh35nF9AA0Zy6FyZ4g8IzrXH2ZQnp3inF-o2Hs1pw,1383
@@ -17,6 +19,7 @@ dtflow/cli/pipeline.py,sha256=QNEo-BJlaC1CVnVeRZr7TwfuZYloJ4TebIzJ5ALzry0,1426
 dtflow/cli/sample.py,sha256=vPTQlF0OXEry4QjO8uaD9vOae4AQbX9zDwVYOxg59ZI,10339
 dtflow/cli/stats.py,sha256=HByF0sFMqY1kM75dnjTcJbMKDdQNdOt4iDba4au_-pI,20495
 dtflow/cli/transform.py,sha256=w6xqMOxPxQvL2u_BPCfpDHuPSC9gmcqMPVN8s-B6bbY,15052
+dtflow/cli/validate.py,sha256=65aGVlMS_Rq0Ch0YQ-TclVJ03RQP4CnG137wthzb8Ao,4384
 dtflow/mcp/__init__.py,sha256=huEJ3rXDbxDRjsLPEvjNT2u3tWs6Poiv6fokPIrByjw,897
 dtflow/mcp/__main__.py,sha256=PoT2ZZmJq9xDZxDACJfqDW9Ld_ukHrGNK-0XUd7WGnY,448
 dtflow/mcp/cli.py,sha256=ck0oOS_642cNktxULaMRE7BJfMxsBCwotmCj3PSPwVk,13110
@@ -27,7 +30,7 @@ dtflow/storage/io.py,sha256=ZH2aSE-S89gpy3z4oTqhcqWf4u10OdkDoyul7o_YBDI,23374
 dtflow/utils/__init__.py,sha256=f8v9HJZMWRI5AL64Vjr76Pf2Na_whOF9nJBKgPbXXYg,429
 dtflow/utils/display.py,sha256=OeOdTh6mbDwSkDWlmkjfpTjy2QG8ZUaYU0NpHUWkpEQ,5881
 dtflow/utils/field_path.py,sha256=WcNA-LZh3H61a77FEzB_R7YAyyZl3M8ofdq05ytQGmI,7459
-dtflow-0.4.3.dist-info/METADATA,sha256=LdjtTbPEuHlqxthUuMX2lqrj2l2kBIfVf-u6jDZmCeI,18524
-dtflow-0.4.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-dtflow-0.4.3.dist-info/entry_points.txt,sha256=dadIDOK7Iu9pMxnMPBfpb4aAPe4hQbBOshpQYjVYpGc,44
-dtflow-0.4.3.dist-info/RECORD,,
+dtflow-0.5.0.dist-info/METADATA,sha256=chELFIevPb1h7ZydbWtH9rM7RiA2n3Ep-XWL1qbaHk0,22084
+dtflow-0.5.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dtflow-0.5.0.dist-info/entry_points.txt,sha256=dadIDOK7Iu9pMxnMPBfpb4aAPe4hQbBOshpQYjVYpGc,44
+dtflow-0.5.0.dist-info/RECORD,,