lysync 1.0.0__py3-none-any.whl

lysync/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

lysync/apps.py

@@ -0,0 +1,25 @@
+from django.apps import AppConfig
+
+
+class LysyncConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "lysync"
+
+    def ready(self):
+        # 确保内置自定义函数（process / collect）完成注册
+        import lysync.funcs  # noqa: F401
+        # 收集 Celery 任务定义
+        import lysync.tasks  # noqa: F401
+
+        # 注册数据源信号（post_save / 批量更新连接检查）
+        import lysync.signals  # noqa: F401  (触发 post_save 注册)
+
+
+        # 初始化周期性任务（导出 / 中断校验）
+        try:
+            from lysync.tasks import init_periodic_tasks
+
+            init_periodic_tasks()
+        except Exception:
+            # 在缺少 django_celery_beat 或还未迁移的环境中静默忽略
+            pass

lysync/export/__init__.py

@@ -0,0 +1,10 @@
+"""导出功能包：采集 -> 处理 -> 写入目标库。
+
+子模块各自独立导入即可（避免在本 __init__ 中提前引入需要 Django 的子模块）：
+
+* ``from lysync.export.collector import collect``
+* ``from lysync.export.processor import run_field_process_list, run_dataset_process_list``
+* ``from lysync.export.writer import write_rows_to_target``
+* ``from lysync.export.engine import exec_sync_export_task_item, exec_sync_export_check_item``
+* ``from lysync.export.utils import fetch_data_from_temp_db, render_sql_template, ...``
+"""

lysync/export/collector.py

@@ -0,0 +1,72 @@
+"""数据采集层。
+
+根据 :class:`~lysync.models.SyncDataSource` 的类型，从外部数据库（SQL）或
+自定义采集函数（``custom_func``）获取原始数据，返回 ``list[dict]``。
+
+数据库采集改为 **按天（前闭后开）** 同步：``SyncExportTask.sql`` 即 jinja2 模板，
+由 :func:`~lysync.export.utils.render_sql_template` 注入 ``start_time`` /
+``end_time``（均为 ``datetime``，区间为 ``[start_time, end_time)``）渲染成最终 SQL。
+区间过滤逻辑由模板内 SQL 自己实现（不再使用 sqlglot 追加分页参数）。
+
+返回的字典键名应与目标模型字段（``SyncModelField.field_name``）保持一致。
+"""
+from __future__ import annotations
+
+from lysync.funcs.registry import get_collect_func
+from lysync.models import SyncDataSource, SyncExportTask
+from lysync.export.utils import fetch_data_from_temp_db, render_sql_template
+
+
+def collect_from_db(data_source: SyncDataSource, sql: str, start_time, end_time):
+    """从数据库采集：用 jinja2 渲染 SQL 模板（注入 ``start_time`` / ``end_time``）。"""
+    exec_sql = render_sql_template(sql, start_time, end_time)
+    rows = fetch_data_from_temp_db(
+        data_source.db_type,
+        data_source.db_host,
+        data_source.db_port,
+        data_source.db_user,
+        data_source.db_password,
+        data_source.db_name,
+        data_source.db_options,
+        exec_sql,
+    )
+    return rows or [], exec_sql
+
+
+def collect_custom(
+    data_source: SyncDataSource,
+    task: SyncExportTask = None,
+    start_time=None,
+    end_time=None,
+    **extra_kwargs,
+):
+    """调用自定义采集函数，并把 ``start_time`` / ``end_time`` 透传进去。
+
+    自定义函数签名：``func(start_time=..., end_time=..., **kwargs) -> list[dict]``。
+    """
+    if not data_source.custom_func:
+        raise ValueError("数据源未配置 custom_func（自定义采集函数名称）")
+    func = get_collect_func(data_source.custom_func)
+
+    kwargs = {}
+    if isinstance(data_source.custom_func_kwargs, dict):
+        kwargs.update(data_source.custom_func_kwargs)
+    if task is not None and isinstance(task.custom_func_kwargs, dict):
+        kwargs.update(task.custom_func_kwargs)
+    kwargs.update(start_time=start_time, end_time=end_time)
+    kwargs.update(extra_kwargs)
+
+    rows = func(**kwargs)
+    if not isinstance(rows, list):
+        raise TypeError(f"自定义采集函数 {data_source.custom_func} 应返回 list[dict]，实际返回 {type(rows)}")
+    return rows, None
+
+
+def collect(task: SyncExportTask, start_time=None, end_time=None, **extra_kwargs):
+    """统一采集入口。返回 ``(rows, exec_sql)``。"""
+    data_source = task.data_source
+    if data_source.source_type == SyncDataSource.SOURCE_TYPE_CUSTOM:
+        return collect_custom(data_source, task, start_time=start_time, end_time=end_time, **extra_kwargs)
+    if not task.sql:
+        raise ValueError("数据库类型数据源必须配置 SQL")
+    return collect_from_db(data_source, task.sql, start_time, end_time)

lysync/export/engine.py

@@ -0,0 +1,306 @@
+"""导出引擎（核心编排）。
+
+替代旧版“先导出 Excel 再二次处理”的流程：直接把源数据经 ``process_list`` 处理链
+加工后写入目标库（upsert）。
+
+与旧版的关键差异：
+* **按天同步**：每次执行只同步 ``SyncExportTask.data_start_date`` 这一天的数据。
+  ``SyncExportTask.sql`` 是 jinja2 模板，渲染时注入 ``start_time``（当天 00:00:00）
+  与 ``end_time``（次日 00:00:00），构成 **前闭后开** 区间 ``[start_time, end_time)``，
+  区间过滤由模板内 SQL 自己实现（不再用 sqlglot 追加分页参数）。
+* 执行完成后 ``data_start_date`` 推进到次日；若仍早于“今天”则 ``has_more=True``，
+  由上层 Celery 触发下一天的同步。
+* 数据变更检测按天进行：每次只处理当天的行，并通过 ``SyncDataFingerprint`` 比对指纹。
+
+处理顺序：``SyncModelField``（字段级） -> ``SyncModelType``（数据集级） ->
+``SyncExportTask``（数据集级）。
+
+对外主要函数：
+* :func:`exec_sync_export_task_item` —— 执行一天的导出任务。
+* :func:`exec_sync_export_check_item` —— 对已有导出记录做按天补录。
+"""
+from __future__ import annotations
+
+import datetime
+import uuid
+
+from celery.exceptions import SoftTimeLimitExceeded
+from django.conf import settings
+from django.utils import timezone
+from loguru import logger
+
+from lysync.models import (
+    EXPORT_RECORD_STATUS_FAIL,
+    EXPORT_RECORD_STATUS_RUNNING,
+    EXPORT_RECORD_STATUS_SUCCESS,
+    SyncDataSource,
+    SyncExportCheckRecord,
+    SyncExportRecord,
+    SyncExportTask,
+    SyncModelField,
+    SyncModelType,
+)
+from lysync.export.collector import collect
+from lysync.export.processor import run_dataset_process_list, run_field_process_list
+from lysync.export.utils import fetch_data_from_temp_db, render_sql_template
+from lysync.utils import local_today
+from lysync.export.writer import write_rows_to_target
+
+
+def _patch_logger(request_id=None):
+    try:
+        from util.middleware import get_request_id
+
+        return logger.patch(lambda record: record["extra"].update(**get_request_id()))
+    except Exception:
+        return logger
+
+
+def _day_bounds(data_start_date):
+    """将日期转换为当天 00:00:00 与次日 00:00:00 的 datetime（naive，本地时区语义）。"""
+    start_time = datetime.datetime(data_start_date.year, data_start_date.month, data_start_date.day)
+    end_time = start_time + datetime.timedelta(days=1)
+    return start_time, end_time
+
+
+def _last_unique_hash(processed_rows, unique_pairs, fields):
+    """取当天批次中“时间索引字段最大”的那条行的唯一标识。
+
+    优先使用配置了 ``is_datetime_index=True`` 的字段作为时间维度；若没有该字段或
+    批次为空，则回退到列表最后一条。
+    """
+    if not unique_pairs:
+        return None
+    dt_field = next((f.field_name for f in fields if getattr(f, "is_datetime_index", False)), None)
+    if not dt_field:
+        return unique_pairs[-1][0]
+
+    def _sortable(i):
+        v = processed_rows[i].get(dt_field)
+        if v is None:
+            return (1, 0)
+        if hasattr(v, "timestamp"):
+            return (0, v.timestamp())
+        try:
+            return (0, float(v))
+        except (TypeError, ValueError):
+            return (0, 0)
+
+    best = max(range(len(processed_rows)), key=_sortable)
+    return unique_pairs[best][0]
+
+
+def _process_rows(task: SyncExportTask, raw_rows):
+    """按处理顺序执行字段级 / 数据集级 process_list。
+
+    字段采集开关 ``is_import_column``：
+    * ``True``：从采集结果中保留其值，参与字段级处理并写入目标库。
+    * ``False``：**采集函数不应输出该字段的值**——其值由 ``SyncModelType`` 的
+      ``process_list``（数据集级）等逻辑负责计算 / 产出。因此在字段级处理前
+      将其从采集结果中剔除，字段级处理也跳过它。
+    """
+    model_type = task.model_type
+    fields = list(SyncModelField.objects.filter(model_type=model_type).order_by("id"))
+    import_fields = [f for f in fields if f.is_import_column]
+    non_import_names = {f.field_name for f in fields if not f.is_import_column}
+
+    # 剔除非导入列的值（收集函数不应输出该字段的值）
+    if non_import_names:
+        raw_rows = [{k: v for k, v in row.items() if k not in non_import_names} for row in raw_rows]
+
+    # 1) 字段级：仅对导入列逐字段处理值
+    processed = []
+    for raw in raw_rows:
+        row = dict(raw)  # 避免修改原始数据
+        for field in import_fields:
+            row[field.field_name] = run_field_process_list(
+                field.process_list, row.get(field.field_name), field.field_name
+            )
+        processed.append(row)
+
+    # 2) 数据集级：SyncModelType（此处可产出 is_import_column=False 的派生字段）
+    processed = run_dataset_process_list(model_type.process_list, processed)
+    # 3) 数据集级：SyncExportTask
+    processed = run_dataset_process_list(task.process_list, processed)
+    return processed
+
+
+def exec_sync_export_task_item(task: SyncExportTask, request_id=None):
+    """执行一天的导出任务（采集 -> 处理 -> 写入目标库）。
+
+    以 ``task.data_start_date`` 为当天，渲染 ``[start_time, end_time)`` 区间 SQL，
+    同步完成后把 ``data_start_date`` 推进到次日。
+
+    Returns:
+        ``(success: bool, message: str, has_more: bool)``，``has_more`` 表示是否还有
+        后续日期需要继续同步（``data_start_date`` 仍早于今天）。
+    """
+    request_id = request_id or uuid.uuid4().hex
+    log = _patch_logger(request_id)
+
+    task.last_export_time = timezone.now()
+    data_source = task.data_source
+    is_db = data_source.source_type != SyncDataSource.SOURCE_TYPE_CUSTOM
+
+    if not task.data_start_date:
+        msg = "请先配置 data_start_date（数据开始日期）后再执行同步"
+        log.warning(f"[{request_id}]{msg}: id={task.id}")
+        record = SyncExportRecord(
+            org_id=task.org_id, export_task=task, export_status=EXPORT_RECORD_STATUS_FAIL, message=msg
+        )
+        record.save()
+        return False, msg, False
+
+    start_time, end_time = _day_bounds(task.data_start_date)
+
+    record = SyncExportRecord()
+    record.org_id = task.org_id
+    record.export_task = task
+    record.data_date = task.data_start_date
+    record.export_status = EXPORT_RECORD_STATUS_RUNNING
+    try:
+        raw_rows, exec_sql = collect(task, start_time=start_time, end_time=end_time)
+        record.original_sql = task.sql or ""
+        record.exec_sql = exec_sql or ""
+        record.save()
+        task.save(update_fields=["last_export_time", "update_time"])
+
+        if not raw_rows:
+            log.info(f"[{request_id}]无新数据: id={task.id}, name={task.name}, date={task.data_start_date}")
+            record.export_status = EXPORT_RECORD_STATUS_SUCCESS
+            record.message = "无新数据"
+            record.save()
+            # 当天无数据也要推进到次日，避免死循环
+            task.data_start_date = end_time.date()
+            task.save(update_fields=["data_start_date", "last_export_time", "update_time"])
+            has_more = task.data_start_date < local_today()
+            return True, "无新数据", has_more
+
+        fields = list(SyncModelField.objects.filter(model_type=task.model_type).order_by("id"))
+        processed = _process_rows(task, raw_rows)
+        created, updated, unique_pairs = write_rows_to_target(task.model_type, processed, task, task.org_id)
+
+        record.export_status = EXPORT_RECORD_STATUS_SUCCESS
+        record.message = f"导入成功，新增 {created}，更新 {updated}"
+        record.export_count = len(processed)
+        record.export_total_count = len(processed)
+        record.export_unique_hash_list = [h for h, _ in unique_pairs]
+        record.save()
+
+        # 推进日期与位点
+        last_hash = _last_unique_hash(processed, unique_pairs, fields)
+        task.last_export_unique_hash = last_hash
+        task.data_start_date = end_time.date()
+        task.last_export_time = timezone.now()
+        task.save(
+            update_fields=["last_export_unique_hash", "data_start_date", "last_export_time", "update_time"]
+        )
+
+        has_more = task.data_start_date < local_today()
+        log.info(
+            f"[{request_id}]导出成功: id={task.id}, name={task.name}, date={record.data_date}, "
+            f"新增{created}, 更新{updated}"
+        )
+        return True, record.message, has_more
+    except SoftTimeLimitExceeded:
+        log.exception(f"[{request_id}]task_id={task.id}. 任务超时")
+        record.export_status = EXPORT_RECORD_STATUS_FAIL
+        record.message = "任务超时"
+        record.save()
+        return False, "任务超时", False
+    except Exception as e:
+        import traceback
+
+        bt = str(traceback.format_exc())
+        msg = "执行查询超时" if "SoftTimeLimitExceeded" in bt else str(e)
+        log.exception(f"[{request_id}]task_id={task.id}. 导出数据失败: {e}")
+        try:
+            record.export_status = EXPORT_RECORD_STATUS_FAIL
+            record.message = msg
+            record.save()
+        except Exception:
+            pass
+        return False, msg, False
+
+
+def exec_sync_export_check_item(export_record: SyncExportRecord, request_id=None):
+    """对已有导出记录做按天补录（重新同步该记录所属日期的数据并 upsert 变更行）。"""
+    request_id = request_id or uuid.uuid4().hex
+    log = _patch_logger(request_id)
+
+    export_task = export_record.export_task
+    data_source = export_task.data_source
+    is_db = data_source.source_type != SyncDataSource.SOURCE_TYPE_CUSTOM
+
+    check_record = SyncExportCheckRecord()
+    check_record.org_id = export_record.org_id
+    check_record.export_task = export_task
+    check_record.export_record = export_record
+    check_record.export_status = EXPORT_RECORD_STATUS_RUNNING
+    try:
+        if not export_record.data_date:
+            raise ValueError("导出记录缺少 data_date，无法按天补录")
+        start_time, end_time = _day_bounds(export_record.data_date)
+        if is_db:
+            exec_sql = render_sql_template(export_task.sql, start_time, end_time)
+            raw_rows = (
+                fetch_data_from_temp_db(
+                    data_source.db_type,
+                    data_source.db_host,
+                    data_source.db_port,
+                    data_source.db_user,
+                    data_source.db_password,
+                    data_source.db_name,
+                    data_source.db_options,
+                    exec_sql,
+                )
+                or []
+            )
+            check_record.original_sql = export_task.sql
+            check_record.exec_sql = exec_sql
+        else:
+            raw_rows, _ = collect(export_task, start_time=start_time, end_time=end_time)
+            check_record.original_sql = export_task.sql or ""
+            check_record.exec_sql = ""
+
+        check_record.save()
+        export_record.save(update_fields=["last_check_time", "update_time"])
+
+        if not raw_rows:
+            check_record.delete()
+            return True, None, False
+
+        processed = _process_rows(export_task, raw_rows)
+        created, updated, unique_pairs = write_rows_to_target(
+            export_task.model_type, processed, export_task, export_record.org_id
+        )
+
+        check_record.export_status = EXPORT_RECORD_STATUS_SUCCESS
+        check_record.message = "补录导入成功"
+        check_record.export_count = created + updated
+        check_record.export_unique_hash_list = [h for h, _ in unique_pairs]
+        check_record.save()
+
+        export_record.last_check_record_id = check_record.id
+        export_record.success_check_record_count = SyncExportCheckRecord.objects.filter(
+            export_record_id=export_record.id, export_status=EXPORT_RECORD_STATUS_SUCCESS
+        ).count()
+        export_record.save(
+            update_fields=["success_check_record_count", "last_check_record_id", "update_time"]
+        )
+        log.info(
+            f"[{request_id}]补录成功: id={export_record.id}, name={export_task.name}, 新增{created}, 更新{updated}"
+        )
+        return True, check_record.message, False
+    except SoftTimeLimitExceeded:
+        log.exception(f"[{request_id}]task_record_id={export_record.id}. 任务超时")
+        check_record.export_status = EXPORT_RECORD_STATUS_FAIL
+        check_record.message = "任务超时"
+        check_record.save()
+        return False, "任务超时", False
+    except Exception as e:
+        log.exception(f"[{request_id}]task_record_id={export_record.id}. 补录失败: {e}")
+        check_record.export_status = EXPORT_RECORD_STATUS_FAIL
+        check_record.message = str(e)
+        check_record.save()
+        return False, str(e), False

lysync/export/jinja_env.py

@@ -0,0 +1,110 @@
+"""统一的 Jinja2 环境（单例）。
+
+整个项目里所有 SQL 模板渲染共用同一个 :class:`jinja2.Environment`，便于：
+
+* **扩展内部函数 / 数据**：通过 :func:`register_global` / :func:`register_filter`
+  注册自定义全局函数与过滤器，模板内即可直接调用；渲染时也可通过
+  :func:`render_sql_template` 的关键字参数注入任意额外上下文。
+* **复用编译缓存**：``env.from_string(sql)`` 比每次 ``Template(sql).render`` 更高效，
+  且共享同一套全局/过滤器配置。
+* **统一配置**：SQL 模板不需要 HTML 自动转义，这里统一关闭，避免把 ``< > &`` 等符号转义。
+
+内置可用资源（模板内）：
+
+* 全局函数：``now()`` / ``utcnow()`` / ``today()`` 返回当前时间/日期；
+  ``sqlstr(value)`` 返回带单引号转义的 SQL 字面量。
+* 过滤器：``value | date(fmt)`` / ``value | strftime(fmt)`` 格式化日期；
+  ``value | sqlstr`` 等价于 ``sqlstr(value)``。
+
+扩展示例（在 app 启动时或任意可导入处调用）::
+
+    from lysync.export.jinja_env import register_global
+
+    def fiscal_year(dt):
+        return dt.year if dt.month >= 4 else dt.year - 1
+
+    register_global("fiscal_year", fiscal_year)
+
+之后模板即可使用 ``{{ start_time | fiscal_year }}``。
+"""
+from __future__ import annotations
+
+import datetime
+
+from jinja2 import Environment
+
+
+# SQL 模板不需要 HTML 自动转义；关闭以避免把 < > & 等符号转义成实体
+_AUTOESCAPE = False
+
+
+def _sqlstr(value):
+    """返回带单引号转义的 SQL 字符串字面量（最小实现，仅转义单引号）。"""
+    if value is None:
+        return "NULL"
+    return "'" + str(value).replace("'", "''") + "''"
+
+
+# 默认注入模板的内置全局函数
+_DEFAULT_GLOBALS = {
+    "now": datetime.datetime.now,
+    "utcnow": datetime.datetime.utcnow,
+    "today": datetime.date.today,
+    "sqlstr": _sqlstr,
+}
+
+# 默认注入模板的内置过滤器
+_DEFAULT_FILTERS = {
+    "date": lambda value, fmt="%Y-%m-%d": value.strftime(fmt) if isinstance(value, (datetime.datetime, datetime.date)) else (value or ""),
+    "strftime": lambda value, fmt="%Y-%m-%d": value.strftime(fmt) if isinstance(value, (datetime.datetime, datetime.date)) else (value or ""),
+    "sqlstr": _sqlstr,
+}
+
+
+_env = None
+
+
+def get_jinja_env() -> Environment:
+    """返回全局共享的 Jinja2 Environment（懒加载单例）。
+
+    首次调用时创建并注册内置全局函数 / 过滤器。后续可通过
+    :func:`register_global` / :func:`register_filter` 继续扩展。
+    """
+    global _env
+    if _env is None:
+        _env = Environment(autoescape=_AUTOESCAPE, trim_blocks=False, lstrip_blocks=False)
+        _env.globals.update(_DEFAULT_GLOBALS)
+        _env.filters.update(_DEFAULT_FILTERS)
+    return _env
+
+
+def register_global(name: str, func):
+    """注册一个模板可用的全局函数（覆盖同名项），之后可在模板中直接调用。"""
+    get_jinja_env().globals[name] = func
+
+
+def register_filter(name: str, func):
+    """注册一个模板可用的过滤器（覆盖同名项），之后可用 ``value | name`` 调用。"""
+    get_jinja_env().filters[name] = func
+
+
+def render_sql_template(sql, start_time=None, end_time=None, **context):
+    """使用统一 Jinja2 环境渲染 SQL 模板。
+
+    Args:
+        sql: jinja2 模板字符串（可含 ``{{ start_time }}`` / ``{{ end_time }}`` 等）。
+        start_time / end_time: 默认注入的上下文变量（多为 datetime，构成前闭后开区间）。
+        **context: 任意额外的模板上下文，覆盖/补充默认注入的变量。
+
+    Returns:
+        渲染后的 SQL 字符串。不存在 ``{{ }}`` 的普通 SQL 由原样返回，兼容旧写法。
+
+    模板内还可使用内置全局函数（``now()`` / ``today()`` / ``sqlstr()`` 等）与
+    过滤器（``|date`` / ``|strftime`` / ``|sqlstr``），并可通过
+    :func:`register_global` / :func:`register_filter` 扩展。
+    """
+    if not sql:
+        return sql
+    ctx = {"start_time": start_time, "end_time": end_time}
+    ctx.update(context)
+    return get_jinja_env().from_string(sql).render(**ctx)

lysync/export/processor.py

@@ -0,0 +1,40 @@
+"""数据处理链（``process_list``）执行层。
+
+处理顺序约定为：
+``SyncModelField``（字段级） -> ``SyncModelType``（数据集级） -> ``SyncExportTask``（数据集级）。
+
+* 字段级：对**单个字段的值**依次调用 ``process_list`` 中的每个函数，
+  签名 ``func(value, **kwargs) -> value``。
+* 数据集级：对**整批数据**（``list[dict]``）依次调用，签名 ``func(rows, **kwargs) -> rows``。
+"""
+from __future__ import annotations
+
+from lysync.funcs.registry import get_process_func
+
+
+def run_field_process_list(process_list, value, field_name=None):
+    """对单个字段值执行 ``process_list``。"""
+    if not process_list:
+        return value
+    for item in process_list:
+        name = item.get("func")
+        if not name:
+            continue
+        kwargs = item.get("kwargs") or {}
+        func, _scope = get_process_func(name)
+        value = func(value, **kwargs)
+    return value
+
+
+def run_dataset_process_list(process_list, rows):
+    """对整批数据执行 ``process_list``。"""
+    if not process_list:
+        return rows
+    for item in process_list:
+        name = item.get("func")
+        if not name:
+            continue
+        kwargs = item.get("kwargs") or {}
+        func, _scope = get_process_func(name)
+        rows = func(rows, **kwargs)
+    return rows