dtflow 0.5.8__py3-none-any.whl → 0.5.10__py3-none-any.whl

dtflow/eval.py

@@ -0,0 +1,276 @@
+"""
+评估指标计算模块
+
+提供分类任务的指标计算和评估报告导出：
+- MetricsCalculator: 计算 accuracy/precision/recall/F1/混淆矩阵
+- export_eval_report: 生成 metrics.md + result.jsonl + bad_case.jsonl
+
+依赖: scikit-learn, pandas
+安装: pip install dtflow[eval]
+"""
+
+import os
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Optional
+
+if TYPE_CHECKING:
+    from pandas import DataFrame
+
+
+def _check_eval_deps():
+    """检查 eval 依赖是否已安装"""
+    try:
+        import pandas  # noqa: F401
+        import sklearn  # noqa: F401
+    except ImportError as e:
+        missing = str(e).split("'")[1] if "'" in str(e) else str(e)
+        raise ImportError(
+            f"eval 功能需要额外依赖: {missing}\n" f"请运行: pip install dtflow[eval]"
+        ) from e
+
+
+class MetricsCalculator:
+    """分类指标计算器
+
+    基于 sklearn 计算 accuracy/precision/recall/F1/混淆矩阵/分类报告。
+
+    Args:
+        df: 包含预测列和标签列的 DataFrame
+        pred_col: 预测值列名
+        label_col: 标签值列名
+        include_macro_micro_avg: 是否在报告中包含 macro/micro 平均
+        remove_matrix_zero_row: 是否移除混淆矩阵中 support=0 的行
+    """
+
+    def __init__(
+        self,
+        df: "DataFrame",
+        pred_col: str = "predict",
+        label_col: str = "label",
+        include_macro_micro_avg: bool = False,
+        remove_matrix_zero_row: bool = False,
+    ):
+        _check_eval_deps()
+        self.df = df
+        self.y_pred = df[pred_col]
+        self.y_true = df[label_col]
+        self.all_labels = sorted(set(self.y_true.unique()).union(set(self.y_pred.unique())))
+        self.needed_labels = None
+        self.remove_matrix_zero_row = remove_matrix_zero_row
+        self.include_macro_micro_avg = include_macro_micro_avg
+        self.metrics = self._calculate_metrics()
+
+    def _calculate_metrics(self):
+        from sklearn.metrics import (
+            accuracy_score,
+            classification_report,
+            confusion_matrix,
+            precision_score,
+            recall_score,
+        )
+
+        accuracy = accuracy_score(self.y_true, self.y_pred)
+        precision = precision_score(
+            self.y_true, self.y_pred, labels=self.all_labels, average="weighted", zero_division=0
+        )
+        recall = recall_score(
+            self.y_true, self.y_pred, labels=self.all_labels, average="weighted", zero_division=0
+        )
+        conf_matrix = confusion_matrix(self.y_true, self.y_pred, labels=self.all_labels)
+        report = classification_report(
+            self.y_true, self.y_pred, labels=self.all_labels, output_dict=True, zero_division=0
+        )
+
+        # 默认只保留加权平均
+        if not self.include_macro_micro_avg:
+            report = {
+                label: metrics
+                for label, metrics in report.items()
+                if label in self.all_labels or label == "weighted avg"
+            }
+
+        # 去除 support=0 的类别（注意 accuracy 是 float 不是 dict）
+        report = {
+            label: metrics
+            for label, metrics in report.items()
+            if isinstance(metrics, dict) and metrics.get("support", 0) > 0
+        }
+
+        self.needed_labels = [label for label in report.keys() if label in self.all_labels]
+
+        # 可选移除混淆矩阵中不需要的行
+        needed_idx_list = [self.all_labels.index(label) for label in self.needed_labels]
+        if self.remove_matrix_zero_row:
+            conf_matrix = conf_matrix[needed_idx_list]
+
+        return {
+            "accuracy": accuracy,
+            "precision": precision,
+            "recall": recall,
+            "confusion_matrix": conf_matrix,
+            "classification_report": report,
+        }
+
+    def get_metrics(self):
+        return self.metrics
+
+    def format_classification_report_as_markdown(self):
+        """将分类报告格式化为 Markdown 表格"""
+        report = self.metrics["classification_report"]
+        header = "| Label | Precision | Recall | F1-score | Support |\n"
+        separator = "|-------|-----------|--------|----------|---------|\n"
+        rows = []
+        for label, metrics in report.items():
+            if isinstance(metrics, dict):
+                rows.append(
+                    f"| {label} | {metrics['precision']:.2f} | {metrics['recall']:.2f} "
+                    f"| {metrics['f1-score']:.2f} | {metrics['support']:.0f} |"
+                )
+        return header + separator + "\n".join(rows)
+
+    def _clean_label_for_markdown(self, label, max_length=20):
+        """清理标签文本，使其适合 Markdown 表格显示"""
+        label = str(label).replace("\n", " ")
+        label = label.replace("|", "\\|")
+        label = label.replace("-", "\\-")
+        label = label.replace("<", "&lt;")
+        label = label.replace(">", "&gt;")
+        if len(label) > max_length:
+            label = label[:max_length] + "..."
+        label = label.strip()
+        if not label:
+            label = "(empty)"
+        return label
+
+    def format_confusion_matrix_as_markdown(self, max_label_length=20):
+        """将混淆矩阵格式化为 Markdown 表格"""
+        matrix = self.metrics["confusion_matrix"]
+
+        if self.remove_matrix_zero_row:
+            labels = self.needed_labels
+        else:
+            labels = self.all_labels
+
+        processed_labels = [self._clean_label_for_markdown(lb, max_label_length) for lb in labels]
+
+        header = "| 真实值/预测值 | " + " | ".join(processed_labels) + " |\n"
+        separator_parts = [":---:"] * (len(processed_labels) + 1)
+        separator = "| " + " | ".join(separator_parts) + " |\n"
+
+        rows = []
+        for i, row in enumerate(matrix):
+            row_label = self._clean_label_for_markdown(labels[i], max_label_length)
+            formatted_row = [f"{num:,}" for num in row]
+            rows.append(f"| {row_label} | " + " | ".join(formatted_row) + " |")
+
+        return header + separator + "\n".join(rows)
+
+
+def export_eval_report(
+    df: "DataFrame",
+    pred_col: str,
+    label_col: str,
+    record_folder: str = "record",
+    input_name: Optional[str] = None,
+):
+    """生成评估报告并保存到指定目录
+
+    输出文件：
+    - metrics.md: 指标概览 + 分类报告 + 混淆矩阵
+    - result.jsonl: 完整预测结果
+    - bad_case.jsonl: 预测错误样本
+
+    Args:
+        df: 包含预测和标签的 DataFrame
+        pred_col: 预测值列名
+        label_col: 标签值列名
+        record_folder: 输出根目录
+        input_name: 输入文件名（用于子目录命名）
+    """
+    from rich.console import Console
+    from rich.markdown import Markdown
+
+    calculator = MetricsCalculator(df, pred_col=pred_col, label_col=label_col)
+    metrics = calculator.get_metrics()
+
+    # 用 Rich Table 构建指标概览（替代 tabulate）
+    from rich.table import Table
+
+    overview_table = Table(title="指标概览", show_header=True)
+    overview_table.add_column("Accuracy", justify="center")
+    overview_table.add_column("Precision", justify="center")
+    overview_table.add_column("Recall", justify="center")
+    overview_table.add_row(
+        f"{metrics['accuracy']:.4f}",
+        f"{metrics['precision']:.4f}",
+        f"{metrics['recall']:.4f}",
+    )
+
+    # 构建 Markdown 报告内容
+    md = (
+        f"\n\n### 指标概览\n\n"
+        f"| Accuracy | Precision | Recall |\n"
+        f"|----------|-----------|--------|\n"
+        f"| {metrics['accuracy']:.4f} | {metrics['precision']:.4f} | {metrics['recall']:.4f} |"
+    )
+    metrics_md = calculator.format_classification_report_as_markdown()
+    confusion_md = calculator.format_confusion_matrix_as_markdown()
+    md += f"\n\n### Classification Report\n{metrics_md}\n" f"\n### Confusion Matrix\n{confusion_md}"
+
+    # 创建输出目录（带序号和时间戳）
+    now = datetime.now().strftime("%Y%m%d-%H-%M-%S")
+    record_path = Path(record_folder)
+    if input_name:
+        record_path = record_path / input_name
+
+    if record_path.exists():
+        existing = [d.name for d in record_path.iterdir() if d.is_dir()]
+        max_idx = 0
+        for name in existing:
+            parts = name.split("-", 1)
+            if parts[0].isdigit():
+                max_idx = max(max_idx, int(parts[0]))
+        idx = max_idx + 1
+    else:
+        idx = 1
+
+    record_path = record_path / f"{idx}-{now}"
+    record_path.mkdir(parents=True, exist_ok=True)
+
+    # 终端输出
+    console = Console()
+    console.print(overview_table)
+    console.print(Markdown(md))
+
+    # 保存文件
+    with open(os.path.join(record_path, "metrics.md"), "w", encoding="utf-8") as f:
+        f.write(md)
+
+    bad_case_df = df[df[pred_col] != df[label_col]]
+
+    # 保存 JSONL
+    df.to_json(
+        os.path.join(record_path, "result.jsonl"),
+        orient="records",
+        lines=True,
+        force_ascii=False,
+    )
+    bad_case_df.to_json(
+        os.path.join(record_path, "bad_case.jsonl"),
+        orient="records",
+        lines=True,
+        force_ascii=False,
+    )
+
+    # 尝试保存 CSV
+    try:
+        df.to_csv(os.path.join(record_path, "result.csv"), index=False)
+        bad_case_df.to_csv(os.path.join(record_path, "bad_case.csv"), index=False)
+    except Exception:
+        pass
+
+    console.print(f"\n[green]报告已保存到: {record_path}[/green]")
+    console.print(f"[dim]  - metrics.md ({len(df)} 条数据, {len(bad_case_df)} 条错误)[/dim]")
+
+    return record_path

dtflow/utils/text_parser.py

@@ -0,0 +1,124 @@
+"""
+文本清洗工具
+
+提供 LLM 输出的常见清洗函数：
+- strip_think_tags: 去除 <think>...</think> 思考链内容
+- extract_code_snippets: 提取 ``` 代码块
+- parse_generic_tags: 解析 <tag>content</tag> 格式标签
+"""
+
+import re
+from typing import Dict, List
+
+
+def strip_think_tags(text: str) -> str:
+    """去除 <think>...</think> 包裹的内容
+
+    Args:
+        text: 输入文本
+
+    Returns:
+        去除思考链后的文本
+
+    Examples:
+        >>> strip_think_tags("<think>让我想想...</think>答案是42")
+        '答案是42'
+    """
+    if not text:
+        return text
+    return re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
+
+
+def extract_code_snippets(text: str, strict: bool = True) -> List[Dict[str, str]]:
+    """提取 ``` 代码块
+
+    Args:
+        text: 输入文本
+        strict: True 仅匹配 ```lang...``` 格式，False 额外匹配 {...} 格式
+
+    Returns:
+        代码片段列表，每项为 {"language": ..., "code": ...}
+
+    Examples:
+        >>> extract_code_snippets("```json\\n{\"a\": 1}\\n```")
+        [{'language': 'json', 'code': '{"a": 1}'}]
+    """
+    pattern = r"```(\w+)?\s*([\s\S]*?)```"
+    matches = re.findall(pattern, text)
+
+    code_snippets = []
+    for lang, code in matches:
+        code_snippets.append(
+            {
+                "language": lang.strip() if lang else "unknown",
+                "code": code.strip(),
+            }
+        )
+
+    if not strict:
+        # 移除已匹配的 ``` 块，在剩余文本中匹配 { ... }
+        text = re.sub(pattern, "", text)
+        brace_matches = re.findall(r"\{[\s\S]*?\}", text)
+        for code in brace_matches:
+            code_snippets.append(
+                {
+                    "language": "unknown",
+                    "code": code.strip(),
+                }
+            )
+
+    return code_snippets
+
+
+def parse_generic_tags(text: str, strict: bool = False) -> Dict[str, str]:
+    """解析 XML 风格标签
+
+    支持两种模式：
+    - strict=True: 仅匹配闭合标签 <label>content</label>
+    - strict=False: 同时匹配开放式标签 <label>content，闭合标签优先
+
+    Args:
+        text: 输入文本
+        strict: 是否严格模式
+
+    Returns:
+        {标签名: 内容} 字典
+
+    Examples:
+        >>> parse_generic_tags("<标签>内容</标签>")
+        {'标签': '内容'}
+        >>> parse_generic_tags("<a>hello<b>world", strict=False)
+        {'a': 'hello', 'b': 'world'}
+    """
+    if not text:
+        return {}
+
+    result = {}
+
+    if strict:
+        pattern_closed = r"<([^>]+)>\s*(.*?)\s*</\1>"
+        matches = re.findall(pattern_closed, text, re.DOTALL)
+        for label, content in matches:
+            result[label.strip()] = content.strip()
+    else:
+        remaining_text = str(text)
+
+        # 1. 优先处理闭合标签
+        def process_closed_tag(match_obj):
+            label = match_obj.group(1).strip()
+            content = match_obj.group(2).strip()
+            result[label] = content
+            return ""
+
+        pattern_closed = r"<([^>]+)>\s*(.*?)\s*</\1>"
+        remaining_text = re.sub(pattern_closed, process_closed_tag, remaining_text, flags=re.DOTALL)
+
+        # 2. 在剩余文本中处理开放式标签
+        pattern_open = r"<([^>]+)>\s*(.*?)(?=<[^>]+>|$)"
+        matches_open = re.findall(pattern_open, remaining_text, re.DOTALL)
+        for label, content in matches_open:
+            label_stripped = label.strip()
+            if label_stripped not in result:
+                result[label_stripped] = content.strip()
+
+    return result

{dtflow-0.5.8.dist-info → dtflow-0.5.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dtflow
-Version: 0.5.8
+Version: 0.5.10
 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
@@ -44,6 +44,7 @@ Requires-Dist: flake8>=3.9.0; extra == 'dev'
 Requires-Dist: huggingface-hub>=0.20.0; extra == 'dev'
 Requires-Dist: isort>=5.9.0; extra == 'dev'
 Requires-Dist: mypy>=0.910; extra == 'dev'
+Requires-Dist: pandas>=1.3.0; extra == 'dev'
 Requires-Dist: pyarrow; extra == 'dev'
 Requires-Dist: pytest-cov>=2.12.0; extra == 'dev'
 Requires-Dist: pytest>=6.0.0; extra == 'dev'
@@ -57,10 +58,14 @@ Provides-Extra: docs
 Requires-Dist: myst-parser>=0.15.0; extra == 'docs'
 Requires-Dist: sphinx-rtd-theme>=0.5.0; extra == 'docs'
 Requires-Dist: sphinx>=4.0.0; extra == 'docs'
+Provides-Extra: eval
+Requires-Dist: pandas>=1.3.0; extra == 'eval'
+Requires-Dist: scikit-learn>=0.24.0; extra == 'eval'
 Provides-Extra: full
 Requires-Dist: datasets>=2.0.0; extra == 'full'
 Requires-Dist: datasketch>=1.5.0; extra == 'full'
 Requires-Dist: huggingface-hub>=0.20.0; extra == 'full'
+Requires-Dist: pandas>=1.3.0; extra == 'full'
 Requires-Dist: pyarrow; extra == 'full'
 Requires-Dist: rich>=10.0.0; extra == 'full'
 Requires-Dist: scikit-learn>=0.24.0; extra == 'full'
@@ -435,6 +440,13 @@ dt sample data.jsonl 1000 --by=messages.#         # 按消息数量分层采样
 dt sample data.jsonl --where="category=tech"      # 筛选后采样
 dt sample data.jsonl --where="messages.#>=2"      # 多条件筛选
 
+# 按行范围查看（Python 切片语法）
+dt slice data.jsonl 10:20                          # 第 10-19 行（0-based，左闭右开）
+dt slice data.jsonl :100                           # 前 100 行
+dt slice data.jsonl 100:                           # 第 100 行到末尾
+dt slice data.jsonl 10:20 -o sliced.jsonl          # 保存到文件
+dt slice data.jsonl 10:20 -f question,answer       # 只显示指定字段
+
 # 数据转换 - 预设模式
 dt transform data.jsonl --preset=openai_chat
 dt transform data.jsonl --preset=alpaca
@@ -469,6 +481,9 @@ dt clean data.jsonl --max-len=messages[-1].content:500  # 最后一条消息最
 dt clean data.jsonl --keep=question,answer          # 只保留这些字段
 dt clean data.jsonl --drop=metadata                 # 删除指定字段
 dt clean data.jsonl --strip                         # 去除字符串首尾空白
+dt clean data.jsonl --min-tokens=content:10          # 最少 10 tokens
+dt clean data.jsonl --max-tokens=content:1000        # 最多 1000 tokens
+dt clean data.jsonl --min-tokens=text:50 -m gpt-4    # 指定分词器
 
 # 数据去重
 dt dedupe data.jsonl                            # 全量精确去重
@@ -477,6 +492,17 @@ dt dedupe data.jsonl --key=meta.id              # 按嵌套字段去重
 dt dedupe data.jsonl --key=messages[0].content  # 按第一条消息内容去重
 dt dedupe data.jsonl --key=text --similar=0.8   # 相似度去重
 
+# 数据集切分
+dt split data.jsonl --ratio=0.8 --seed=42           # 二分: train/test
+dt split data.jsonl --ratio=0.7,0.15,0.15           # 三分: train/val/test
+dt split data.jsonl --ratio=0.8 -o /tmp/output      # 指定输出目录
+
+# 训练框架导出
+dt export data.jsonl --framework=llama-factory       # 导出到 LLaMA-Factory
+dt export data.jsonl -f swift -o ./swift_out         # 导出到 ms-swift
+dt export data.jsonl -f axolotl                      # 导出到 Axolotl
+dt export data.jsonl -f llama-factory --check        # 仅检查兼容性
+
 # 文件拼接
 dt concat a.jsonl b.jsonl -o merged.jsonl
 
@@ -522,6 +548,8 @@ CLI 命令中的字段参数支持嵌套路径语法，可访问深层嵌套的
 | `clean` | `--drop-empty=` | `--drop-empty=meta.source` |
 | `clean` | `--min-len=` | `--min-len=messages.#:2` |
 | `clean` | `--max-len=` | `--max-len=messages[-1].content:500` |
+| `clean` | `--min-tokens=` | `--min-tokens=content:10` |
+| `clean` | `--max-tokens=` | `--max-tokens=content:1000` |
 | `token-stats` | `--field=` | `--field=messages[-1].content` |
 | `diff` | `--key=` | `--key=meta.uuid` |
 

{dtflow-0.5.8.dist-info → dtflow-0.5.10.dist-info}/RECORD

@@ -1,8 +1,9 @@
-dtflow/SKILL.md,sha256=nh12TTq_eRzl5O2CTgsiS809BBVR49kmpZ8n7UprMHI,9552
-dtflow/__init__.py,sha256=tofhUr_PMnsONnB3Hu-mwUrD4Q3bV7Kw_0S6dQw6ig8,3031
-dtflow/__main__.py,sha256=p8oZKQhwq04shCB3y_pkXjf-SZ4PZvg5PXdyUP-5rYA,13497
+dtflow/SKILL.md,sha256=Oq8Kb5JghZMJ1WoP8OWhX3qAWaUY9Sip_iWAv8S2eMg,10567
+dtflow/__init__.py,sha256=2A-P6k9VBIWZXRgXwYPFOwHMCmgkfKZVYuGuBziqqhc,3032
+dtflow/__main__.py,sha256=_wrpYfOog6G83I17yuBe-hryBsaCrIwbXSEnzT-r28g,18008
 dtflow/converters.py,sha256=X3qeFD7FCOMnfiP3MicL5MXimOm4XUYBs5pczIkudU0,22331
 dtflow/core.py,sha256=qMo6B3LK--TWRK7ZBKObGcs3pKFnd0NPoaM0T8JC7Jw,38135
+dtflow/eval.py,sha256=_c-XP2zsOBznYltSyKEScOqvmPVX2orqepg5cNhXXB0,9836
 dtflow/framework.py,sha256=jyICi_RWHjX7WfsXdSbWmP1SL7y1OWSPyd5G5Y-lvg4,17578
 dtflow/lineage.py,sha256=jie3OL1qK90-_cOOqqLbhSJ1oGUktDM1x5HRpQ5Qiyc,12800
 dtflow/parallel.py,sha256=EnIdGEGMrZUNT2-CBIV93UFfpqr_jU_heqqvdGXcP-Y,3046
@@ -12,14 +13,17 @@ dtflow/schema.py,sha256=zCZNEAqTMT1BS_p2t0CYczR5S9rqyDREa7ZsYI5pFGA,19885
 dtflow/streaming.py,sha256=dxpNd1-Wz_PTLTdvM5qn06_2TJr5NRlIIuw0LOSS2Iw,24755
 dtflow/tokenizers.py,sha256=GFQsuLSLn2GHn2kaXhJkP8G85lgsdLzYtJNbppQhYPE,23408
 dtflow/cli/__init__.py,sha256=QhZ-thgx9IBTFII7T_hdoWFUl0CCsdGQHN5ZEZw2XB0,423
-dtflow/cli/clean.py,sha256=KuE9ODjD9gSZUIHaD2mQLTDO-1PDwN7EqUpj8EQfVCs,25663
-dtflow/cli/commands.py,sha256=zKUG-B9Az-spqyqM00cR8Sgc2UgeOPQDThJFHWDNO_w,1336
+dtflow/cli/clean.py,sha256=BEQQlH2q6luCbx51M3oxxOwcnwlOA8vo9WX3Fp7I6AY,29498
+dtflow/cli/commands.py,sha256=LvyDQ_nWUM7UlPDEFQadRdw5O2ZKDLgF41_xAJRhYxI,1583
 dtflow/cli/common.py,sha256=gCwnF5Sw2ploqfZJO_z3Ms9mR1HNT7Lj6ydHn0uVaIw,13817
+dtflow/cli/eval.py,sha256=c53kCRH86k2Q_6vESKFlcepcNnTpO9O68agWK4_oJj8,9582
+dtflow/cli/export.py,sha256=loRfVPwEVsDw3ZMKEYGp0Hy38kYZG2QT8JCMbz1dRzU,2156
 dtflow/cli/io_ops.py,sha256=BMDisP6dxzzmSjYwmeFwaHmpHHPqirmXAWeNTD-9MQM,13254
 dtflow/cli/lineage.py,sha256=_lNh35nF9AA0Zy6FyZ4g8IzrXH2ZQnp3inF-o2Hs1pw,1383
 dtflow/cli/pipeline.py,sha256=QNEo-BJlaC1CVnVeRZr7TwfuZYloJ4TebIzJ5ALzry0,1426
-dtflow/cli/sample.py,sha256=pubpx4AIzsarBEalD150MC2apYQSt4bal70IZkTfFO0,15475
+dtflow/cli/sample.py,sha256=etbro5I0pyNgn0Qfhp1M6Bh-95JN-AntDa5AwVe_oKY,18269
 dtflow/cli/skill.py,sha256=opiTEBejA7JHKrEMftMOPDQlOgZ4n59rwaHXGU1Nukk,2022
+dtflow/cli/split.py,sha256=96bhWnxHnjIqifoliLgciApkLbwQU8bWHovK8bcMk9g,3667
 dtflow/cli/stats.py,sha256=HkTZD80h4tzYXTtMnfpjLUMP6kl_es6ifcmExxzGdMU,31813
 dtflow/cli/transform.py,sha256=w6xqMOxPxQvL2u_BPCfpDHuPSC9gmcqMPVN8s-B6bbY,15052
 dtflow/cli/validate.py,sha256=Frs-jKcDHmYozpmIYZueDSX5o2i1Xn-WW81FGUyUrng,5796
@@ -29,7 +33,8 @@ dtflow/utils/__init__.py,sha256=Pn-ltwV04fBQmeZG7FxInDQmzH29LYOi90LgeLMEuQk,506
 dtflow/utils/display.py,sha256=OeOdTh6mbDwSkDWlmkjfpTjy2QG8ZUaYU0NpHUWkpEQ,5881
 dtflow/utils/field_path.py,sha256=K8nU196RxTSJ1OoieTWGcYOWl9KjGq2iSxCAkfjECuM,7621
 dtflow/utils/helpers.py,sha256=JXN176_B2pm53GLVyZ1wj3wrmBJG52Tkw6AMQSdj7M8,791
-dtflow-0.5.8.dist-info/METADATA,sha256=Tm_dfdQfGlShyDt95fNQ87JXiBRnf6mfDgx827h3Rnc,24487
-dtflow-0.5.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-dtflow-0.5.8.dist-info/entry_points.txt,sha256=dadIDOK7Iu9pMxnMPBfpb4aAPe4hQbBOshpQYjVYpGc,44
-dtflow-0.5.8.dist-info/RECORD,,
+dtflow/utils/text_parser.py,sha256=0t2TMOSha4dTiDu9H4ygdb67cI20zhtBH1XavDspL_g,3727
+dtflow-0.5.10.dist-info/METADATA,sha256=OGefMoe17by5IbxdxZgqoJ1Y6OWPt_iGEFM4KgltRZw,26023
+dtflow-0.5.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+dtflow-0.5.10.dist-info/entry_points.txt,sha256=dadIDOK7Iu9pMxnMPBfpb4aAPe4hQbBOshpQYjVYpGc,44
+dtflow-0.5.10.dist-info/RECORD,,