@dazitech/cli 3.0.9 → 3.1.1

package/dist/examples/onto//350/256/276/345/244/207/350/277/220/350/220/245/README.md

@@ -0,0 +1,24 @@
+# 设备运营 · 化工设备运营分析
+
+## 基本信息
+
+| 字段 | 内容 |
+| --- | --- |
+| 数据空间 | 分类测试01 |
+| 数据空间 ID | `space_cate_test01` |
+| 示例 ID | `equip-ops`（见 `../index.yaml` / `index.json`） |
+
+## 目录
+
+| 路径 | 说明 |
+| --- | --- |
+| [plans/化工设备运营分析本体方案.md](./plans/化工设备运营分析本体方案.md) | **规划正文**（OEE、停机等） |
+| `setup/` | `equip_ops_ontology_init.py`、`equip_ops_seed_data.py`、`equip_ops_category_mount.py` |
+| `functions/` | 11 个 `equip_ops_fn_*.py`、`test_arguments/` |
+
+## 使用
+
+- **规划阶段**：推荐阅读（含 Cube + 冗余字段策略 + 11 函数清单）
+- **实施阶段**：init 不含 `apply_registry`；见 `equip_ops_category_mount.py`
+
+规范指南：`资源/docs/onto/本体规划指南.md`

package/dist/examples/onto//350/256/276/345/244/207/350/277/220/350/220/245/functions/equip_ops_fn_availability_analysis.py

@@ -0,0 +1,84 @@
+"""可用率与停机结构分析 equip_ops.fn.availability_analysis
+
+参数：start_date, end_date, plant_id（可选）
+返回：planned_downtime_hours, unplanned_downtime_hours, runtime_hours, availability, load_rate
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_availability_analysis.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.availability_analysis
+"""
+
+TEST_ARGUMENTS = {
+    "v": 1,
+    "arguments": {"start_date": "2025-01-01", "end_date": "2026-06-30"},
+    "object_type_code": "EquipmentAnalysis",
+}
+
+
+def _build_ops_where(start_date, end_date, plant_id=None):
+    clauses = []
+    if start_date and end_date:
+        clauses.append(f"calendar_date >= '{start_date}' AND calendar_date <= '{end_date}'")
+    if plant_id:
+        clauses.append(f"plant_id = '{plant_id}'")
+    return ("WHERE " + " AND ".join(clauses)) if clauses else ""
+
+
+def _ontology_fn_body(p):
+    params = dict(p.get_params() or {})
+    start_date = params.get("start_date", "")
+    end_date = params.get("end_date", "")
+    plant_id = params.get("plant_id") or None
+    where_clause = _build_ops_where(start_date, end_date, plant_id)
+
+    sql = f"""
+    SELECT
+        sum(planned_downtime_min) AS sum_planned_downtime_min,
+        sum(unplanned_downtime_min) AS sum_unplanned_downtime_min,
+        sum(runtime_min) AS sum_runtime_min,
+        sum(calendar_minutes - planned_downtime_min) AS sum_available_min
+    FROM fact_equipment_daily_ops
+    {where_clause}
+    """
+
+    rows = p.sql.query(sql)
+    row = rows[0] if rows else {}
+
+    sum_runtime = float(row.get("sum_runtime_min") or 0)
+    sum_available = float(row.get("sum_available_min") or 0)
+    availability = sum_runtime / sum_available if sum_available > 0 else 0.0
+    load_rate = availability
+
+    data = [{
+        "planned_downtime_hours": round(float(row.get("sum_planned_downtime_min") or 0) / 60.0, 2),
+        "unplanned_downtime_hours": round(
+            float(row.get("sum_unplanned_downtime_min") or 0) / 60.0, 2
+        ),
+        "runtime_hours": round(sum_runtime / 60.0, 2),
+        "availability": round(availability, 4),
+        "load_rate": round(load_rate, 4),
+    }]
+
+    return p.function_result(
+        columns=[
+            "planned_downtime_hours", "unplanned_downtime_hours",
+            "runtime_hours", "availability", "load_rate",
+        ],
+        data=data,
+        row_count=1,
+    )
+
+
+def main():
+    s = space.get(ctx.space_id or "")
+    _Ports = type(
+        "_Ports",
+        (),
+        {
+            "get_params": lambda self: dict(ctx.params or {}),
+            "function_result": lambda self, **kw: onto.function_result(**kw),
+        },
+    )
+    p = _Ports()
+    p.sql = s.sql
+    return _ontology_fn_body(p)

package/dist/examples/onto//350/256/276/345/244/207/350/277/220/350/220/245/functions/equip_ops_fn_downtime_breakdown.py

@@ -0,0 +1,119 @@
+"""停机原因结构分析 equip_ops.fn.downtime_breakdown
+
+参数：start_date, end_date, reason_level=2, plant_id（可选）
+JOIN dim_downtime_reason，返回 reason_code, reason_name, reason_category,
+is_planned, downtime_hours, event_count, share_pct
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_downtime_breakdown.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.downtime_breakdown
+"""
+
+TEST_ARGUMENTS = {
+    "v": 1,
+    "arguments": {
+        "start_date": "2025-01-01",
+        "end_date": "2026-06-30",
+        "reason_level": 2,
+    },
+    "object_type_code": "EquipmentAnalysis",
+}
+
+
+def _build_where(start_date, end_date, plant_id=None):
+    clauses = []
+    if start_date and end_date:
+        clauses.append(
+            f"e.start_time >= '{start_date} 00:00:00' AND e.start_time <= '{end_date} 23:59:59'"
+        )
+    if plant_id:
+        clauses.append(f"e.plant_id = '{plant_id}'")
+    return ("WHERE " + " AND ".join(clauses)) if clauses else ""
+
+
+def _ontology_fn_body(p):
+    params = dict(p.get_params() or {})
+    start_date = params.get("start_date", "")
+    end_date = params.get("end_date", "")
+    reason_level = int(params.get("reason_level", 2) or 2)
+    plant_id = params.get("plant_id") or None
+    where_clause = _build_where(start_date, end_date, plant_id)
+
+    if reason_level <= 1:
+        group_cols = "dr.reason_category"
+        select_cols = """
+            dr.reason_category AS reason_code,
+            dr.reason_category AS reason_name,
+            dr.reason_category AS reason_category,
+            max(dr.is_planned) AS is_planned
+        """
+    else:
+        group_cols = "dr.reason_code, dr.reason_name, dr.reason_category, dr.is_planned"
+        select_cols = """
+            dr.reason_code AS reason_code,
+            dr.reason_name AS reason_name,
+            dr.reason_category AS reason_category,
+            dr.is_planned AS is_planned
+        """
+
+    sql = f"""
+    SELECT
+        {select_cols},
+        sum(e.duration_min) AS downtime_min,
+        count() AS event_count
+    FROM fact_downtime_event AS e
+    INNER JOIN dim_downtime_reason AS dr ON e.reason_id = dr.reason_id
+    {where_clause}
+    GROUP BY {group_cols}
+    ORDER BY downtime_min DESC
+    """
+
+    result = p.sql.query(sql)
+    if not result:
+        return p.function_result(
+            columns=[
+                "reason_code", "reason_name", "reason_category",
+                "is_planned", "downtime_hours", "event_count", "share_pct",
+            ],
+            data=[],
+            row_count=0,
+        )
+
+    total_min = sum(float(r.get("downtime_min") or 0) for r in result)
+    data = []
+    for row in result:
+        downtime_min = float(row.get("downtime_min") or 0)
+        share_pct = downtime_min / total_min if total_min > 0 else 0.0
+        data.append({
+            "reason_code": str(row.get("reason_code") or ""),
+            "reason_name": str(row.get("reason_name") or ""),
+            "reason_category": str(row.get("reason_category") or ""),
+            "is_planned": int(row.get("is_planned") or 0),
+            "downtime_hours": round(downtime_min / 60.0, 2),
+            "event_count": int(row.get("event_count") or 0),
+            "share_pct": round(share_pct, 4),
+        })
+
+    return p.function_result(
+        columns=[
+            "reason_code", "reason_name", "reason_category",
+            "is_planned", "downtime_hours", "event_count", "share_pct",
+        ],
+        data=data,
+        row_count=len(data),
+    )
+
+
+def main():
+    s = space.get(ctx.space_id or "")
+    _Ports = type(
+        "_Ports",
+        (),
+        {
+            "get_params": lambda self: dict(ctx.params or {}),
+            "function_result": lambda self, **kw: onto.function_result(**kw),
+        },
+    )
+    p = _Ports()
+    p.sql = s.sql
+    return _ontology_fn_body(p)

package/dist/examples/onto//350/256/276/345/244/207/350/277/220/350/220/245/functions/equip_ops_fn_energy_intensity.py

@@ -0,0 +1,98 @@
+"""能耗强度分析 equip_ops.fn.energy_intensity
+
+参数：start_date, end_date, group_by=plant|unit|equipment, plant_id（可选）
+返回：group_id, group_name, energy_total, output_qty, energy_per_output
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_energy_intensity.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.energy_intensity
+"""
+
+TEST_ARGUMENTS = {
+    "v": 1,
+    "arguments": {
+        "start_date": "2025-01-01",
+        "end_date": "2026-06-30",
+        "group_by": "plant",
+    },
+    "object_type_code": "EquipmentAnalysis",
+}
+
+_GROUP_BY_MAP = {
+    "plant": ("plant_id", "any(plant_name)"),
+    "unit": ("unit_id", "any(unit_name)"),
+    "equipment": ("equipment_id", "any(equipment_name)"),
+}
+
+
+def _build_ops_where(start_date, end_date, plant_id=None):
+    clauses = []
+    if start_date and end_date:
+        clauses.append(f"calendar_date >= '{start_date}' AND calendar_date <= '{end_date}'")
+    if plant_id:
+        clauses.append(f"plant_id = '{plant_id}'")
+    return ("WHERE " + " AND ".join(clauses)) if clauses else ""
+
+
+def _ontology_fn_body(p):
+    params = dict(p.get_params() or {})
+    start_date = params.get("start_date", "")
+    end_date = params.get("end_date", "")
+    group_by = params.get("group_by", "plant")
+    plant_id = params.get("plant_id") or None
+    group_id_col, group_name_expr = _GROUP_BY_MAP.get(group_by, _GROUP_BY_MAP["plant"])
+    where_clause = _build_ops_where(start_date, end_date, plant_id)
+
+    sql = f"""
+    SELECT
+        {group_id_col} AS group_id,
+        {group_name_expr} AS group_name,
+        sum(energy_consumption) AS energy_total,
+        sum(actual_output_qty) AS output_qty
+    FROM fact_equipment_daily_ops
+    {where_clause}
+    GROUP BY {group_id_col}
+    ORDER BY energy_total DESC
+    """
+
+    result = p.sql.query(sql)
+    if not result:
+        return p.function_result(
+            columns=["group_id", "group_name", "energy_total", "output_qty", "energy_per_output"],
+            data=[],
+            row_count=0,
+        )
+
+    data = []
+    for row in result:
+        energy_total = float(row.get("energy_total") or 0)
+        output_qty = float(row.get("output_qty") or 0)
+        energy_per_output = energy_total / output_qty if output_qty > 0 else 0.0
+        data.append({
+            "group_id": str(row.get("group_id") or ""),
+            "group_name": str(row.get("group_name") or ""),
+            "energy_total": round(energy_total, 2),
+            "output_qty": round(output_qty, 2),
+            "energy_per_output": round(energy_per_output, 4),
+        })
+
+    return p.function_result(
+        columns=["group_id", "group_name", "energy_total", "output_qty", "energy_per_output"],
+        data=data,
+        row_count=len(data),
+    )
+
+
+def main():
+    s = space.get(ctx.space_id or "")
+    _Ports = type(
+        "_Ports",
+        (),
+        {
+            "get_params": lambda self: dict(ctx.params or {}),
+            "function_result": lambda self, **kw: onto.function_result(**kw),
+        },
+    )
+    p = _Ports()
+    p.sql = s.sql
+    return _ontology_fn_body(p)

package/dist/examples/onto//350/256/276/345/244/207/350/277/220/350/220/245/functions/equip_ops_fn_get_summary.py

@@ -0,0 +1,125 @@
+"""设备运营总览 equip_ops.fn.get_summary
+
+参数：start_date, end_date, plant_id（可选）
+返回：equipment_count, avg_availability, avg_oee, total_runtime_hours,
+      total_unplanned_downtime_hours, total_output_qty, total_energy,
+      energy_per_output, downtime_event_count
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_get_summary.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.get_summary
+"""
+
+TEST_ARGUMENTS = {
+    "v": 1,
+    "arguments": {"start_date": "2025-01-01", "end_date": "2026-06-30"},
+    "object_type_code": "EquipmentAnalysis",
+}
+
+
+def _build_ops_where(start_date, end_date, plant_id=None):
+    clauses = []
+    if start_date and end_date:
+        clauses.append(f"calendar_date >= '{start_date}' AND calendar_date <= '{end_date}'")
+    if plant_id:
+        clauses.append(f"plant_id = '{plant_id}'")
+    return ("WHERE " + " AND ".join(clauses)) if clauses else ""
+
+
+def _build_downtime_where(start_date, end_date, plant_id=None):
+    clauses = []
+    if start_date and end_date:
+        clauses.append(
+            f"toDate(start_time) >= '{start_date}' AND toDate(start_time) <= '{end_date}'"
+        )
+    if plant_id:
+        clauses.append(f"plant_id = '{plant_id}'")
+    return ("WHERE " + " AND ".join(clauses)) if clauses else ""
+
+
+def _calc_oee_from_sums(row):
+    sum_runtime = float(row.get("sum_runtime_min") or 0)
+    sum_available = float(row.get("sum_available_min") or 0)
+    sum_actual = float(row.get("sum_actual_output") or 0)
+    sum_qualified = float(row.get("sum_qualified_output") or 0)
+    sum_theoretical = float(row.get("sum_theoretical_output") or 0)
+    availability = sum_runtime / sum_available if sum_available > 0 else 0.0
+    quality = sum_qualified / sum_actual if sum_actual > 0 else 0.0
+    performance = sum_actual / sum_theoretical if sum_theoretical > 0 else 0.0
+    oee = availability * performance * quality
+    return round(availability, 4), round(oee, 4)
+
+
+def _ontology_fn_body(p):
+    params = dict(p.get_params() or {})
+    start_date = params.get("start_date", "")
+    end_date = params.get("end_date", "")
+    plant_id = params.get("plant_id") or None
+    where_clause = _build_ops_where(start_date, end_date, plant_id)
+
+    sql = f"""
+    SELECT
+        uniq(equipment_id) AS equipment_count,
+        sum(runtime_min) AS sum_runtime_min,
+        sum(calendar_minutes - planned_downtime_min) AS sum_available_min,
+        sum(actual_output_qty) AS sum_actual_output,
+        sum(qualified_output_qty) AS sum_qualified_output,
+        sumIf(runtime_min * ideal_cycle_rate, runtime_min > 0) AS sum_theoretical_output,
+        sum(unplanned_downtime_min) AS sum_unplanned_downtime_min,
+        sum(energy_consumption) AS sum_energy
+    FROM fact_equipment_daily_ops
+    {where_clause}
+    """
+
+    rows = p.sql.query(sql)
+    row = rows[0] if rows else {}
+    avg_availability, avg_oee = _calc_oee_from_sums(row)
+
+    sum_runtime = float(row.get("sum_runtime_min") or 0)
+    sum_actual = float(row.get("sum_actual_output") or 0)
+    sum_energy = float(row.get("sum_energy") or 0)
+    energy_per_output = sum_energy / sum_actual if sum_actual > 0 else 0.0
+
+    dt_where = _build_downtime_where(start_date, end_date, plant_id)
+    dt_sql = f"SELECT count() AS event_count FROM fact_downtime_event {dt_where}"
+    dt_rows = p.sql.query(dt_sql)
+    downtime_event_count = int((dt_rows[0] if dt_rows else {}).get("event_count") or 0)
+
+    data = [{
+        "equipment_count": int(row.get("equipment_count") or 0),
+        "avg_availability": avg_availability,
+        "avg_oee": avg_oee,
+        "total_runtime_hours": round(sum_runtime / 60.0, 2),
+        "total_unplanned_downtime_hours": round(
+            float(row.get("sum_unplanned_downtime_min") or 0) / 60.0, 2
+        ),
+        "total_output_qty": round(sum_actual, 2),
+        "total_energy": round(sum_energy, 2),
+        "energy_per_output": round(energy_per_output, 4),
+        "downtime_event_count": downtime_event_count,
+    }]
+
+    return p.function_result(
+        columns=[
+            "equipment_count", "avg_availability", "avg_oee", "total_runtime_hours",
+            "total_unplanned_downtime_hours", "total_output_qty", "total_energy",
+            "energy_per_output", "downtime_event_count",
+        ],
+        data=data,
+        row_count=1,
+    )
+
+
+def main():
+    s = space.get(ctx.space_id or "")
+    _Ports = type(
+        "_Ports",
+        (),
+        {
+            "get_params": lambda self: dict(ctx.params or {}),
+            "function_result": lambda self, **kw: onto.function_result(**kw),
+        },
+    )
+    p = _Ports()
+    p.sql = s.sql
+    return _ontology_fn_body(p)

package/dist/examples/onto//350/256/276/345/244/207/350/277/220/350/220/245/functions/equip_ops_fn_maintenance_compliance.py

@@ -0,0 +1,77 @@
+"""维保达成分析 equip_ops.fn.maintenance_compliance
+
+参数：start_date, end_date, plant_id（可选）
+返回：schedule_rate, total_maint, on_schedule_count, overdue_count, total_cost
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_maintenance_compliance.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.maintenance_compliance
+"""
+
+TEST_ARGUMENTS = {
+    "v": 1,
+    "arguments": {"start_date": "2025-01-01", "end_date": "2026-06-30"},
+    "object_type_code": "EquipmentAnalysis",
+}
+
+
+def _build_where(start_date, end_date, plant_id=None):
+    clauses = []
+    if start_date and end_date:
+        clauses.append(f"plan_date >= '{start_date}' AND plan_date <= '{end_date}'")
+    if plant_id:
+        clauses.append(f"plant_id = '{plant_id}'")
+    return ("WHERE " + " AND ".join(clauses)) if clauses else ""
+
+
+def _ontology_fn_body(p):
+    params = dict(p.get_params() or {})
+    start_date = params.get("start_date", "")
+    end_date = params.get("end_date", "")
+    plant_id = params.get("plant_id") or None
+    where_clause = _build_where(start_date, end_date, plant_id)
+
+    sql = f"""
+    SELECT
+        count() AS total_maint,
+        sum(is_on_schedule) AS on_schedule_count,
+        countIf(status = '逾期') AS overdue_count,
+        sum(actual_cost) AS total_cost
+    FROM fact_maintenance_record
+    {where_clause}
+    """
+
+    rows = p.sql.query(sql)
+    row = rows[0] if rows else {}
+    total_maint = int(row.get("total_maint") or 0)
+    on_schedule_count = int(row.get("on_schedule_count") or 0)
+    schedule_rate = on_schedule_count / total_maint if total_maint > 0 else 0.0
+
+    data = [{
+        "schedule_rate": round(schedule_rate, 4),
+        "total_maint": total_maint,
+        "on_schedule_count": on_schedule_count,
+        "overdue_count": int(row.get("overdue_count") or 0),
+        "total_cost": round(float(row.get("total_cost") or 0), 2),
+    }]
+
+    return p.function_result(
+        columns=["schedule_rate", "total_maint", "on_schedule_count", "overdue_count", "total_cost"],
+        data=data,
+        row_count=1,
+    )
+
+
+def main():
+    s = space.get(ctx.space_id or "")
+    _Ports = type(
+        "_Ports",
+        (),
+        {
+            "get_params": lambda self: dict(ctx.params or {}),
+            "function_result": lambda self, **kw: onto.function_result(**kw),
+        },
+    )
+    p = _Ports()
+    p.sql = s.sql
+    return _ontology_fn_body(p)

package/dist/examples/onto//350/256/276/345/244/207/350/277/220/350/220/245/functions/equip_ops_fn_mom_analysis.py

@@ -0,0 +1,118 @@
+"""环比分析 equip_ops.fn.mom_analysis
+
+参数：start_date, end_date, metric=oee|availability|output, unit_id（可选）
+对比上一同等长度期间，返回 current / previous / mom
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_mom_analysis.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.mom_analysis
+"""
+
+from datetime import datetime, timedelta
+
+TEST_ARGUMENTS = {
+    "v": 1,
+    "arguments": {
+        "start_date": "2025-01-01",
+        "end_date": "2026-06-30",
+        "metric": "availability",
+    },
+    "object_type_code": "EquipmentAnalysis",
+}
+
+
+def _build_ops_where(start_date, end_date, unit_id=None):
+    clauses = []
+    if start_date and end_date:
+        clauses.append(f"calendar_date >= '{start_date}' AND calendar_date <= '{end_date}'")
+    if unit_id:
+        clauses.append(f"unit_id = '{unit_id}'")
+    return ("WHERE " + " AND ".join(clauses)) if clauses else ""
+
+
+def _query_period_metrics(p, start_date, end_date, unit_id):
+    where_clause = _build_ops_where(start_date, end_date, unit_id)
+    sql = f"""
+    SELECT
+        sum(runtime_min) AS sum_runtime_min,
+        sum(calendar_minutes - planned_downtime_min) AS sum_available_min,
+        sum(actual_output_qty) AS sum_actual_output,
+        sum(qualified_output_qty) AS sum_qualified_output,
+        sumIf(runtime_min * ideal_cycle_rate, runtime_min > 0) AS sum_theoretical_output
+    FROM fact_equipment_daily_ops
+    {where_clause}
+    """
+    rows = p.sql.query(sql)
+    row = rows[0] if rows else {}
+    sum_runtime = float(row.get("sum_runtime_min") or 0)
+    sum_available = float(row.get("sum_available_min") or 0)
+    sum_actual = float(row.get("sum_actual_output") or 0)
+    sum_qualified = float(row.get("sum_qualified_output") or 0)
+    sum_theoretical = float(row.get("sum_theoretical_output") or 0)
+    availability = sum_runtime / sum_available if sum_available > 0 else 0.0
+    quality = sum_qualified / sum_actual if sum_actual > 0 else 0.0
+    performance = sum_actual / sum_theoretical if sum_theoretical > 0 else 0.0
+    oee = availability * performance * quality
+    return {
+        "oee": round(oee, 4),
+        "availability": round(availability, 4),
+        "output": round(sum_actual, 2),
+    }
+
+
+def _calc_mom(current, previous):
+    if previous == 0:
+        return 0.0 if current == 0 else None
+    return round((current - previous) / previous, 4)
+
+
+def _ontology_fn_body(p):
+    params = dict(p.get_params() or {})
+    start_date = params.get("start_date") or "2025-01-01"
+    end_date = params.get("end_date") or "2026-06-30"
+    metric = params.get("metric", "oee")
+    unit_id = params.get("unit_id") or None
+
+    start_dt = datetime.strptime(start_date, "%Y-%m-%d")
+    end_dt = datetime.strptime(end_date, "%Y-%m-%d")
+    period_days = (end_dt - start_dt).days + 1
+    prev_end_dt = start_dt - timedelta(days=1)
+    prev_start_dt = prev_end_dt - timedelta(days=period_days - 1)
+    prev_start = prev_start_dt.strftime("%Y-%m-%d")
+    prev_end = prev_end_dt.strftime("%Y-%m-%d")
+
+    current_metrics = _query_period_metrics(p, start_date, end_date, unit_id)
+    previous_metrics = _query_period_metrics(p, prev_start, prev_end, unit_id)
+
+    current_value = current_metrics.get(metric, 0)
+    previous_value = previous_metrics.get(metric, 0)
+    mom = _calc_mom(current_value, previous_value)
+
+    result = {
+        "metric": metric,
+        "period": f"{start_date} ~ {end_date}",
+        "previous_period": f"{prev_start} ~ {prev_end}",
+        "current": current_value,
+        "previous": previous_value,
+        "mom": mom,
+    }
+    return p.function_result(
+        columns=["metric", "period", "previous_period", "current", "previous", "mom"],
+        data=[result],
+        row_count=1,
+    )
+
+
+def main():
+    s = space.get(ctx.space_id or "")
+    _Ports = type(
+        "_Ports",
+        (),
+        {
+            "get_params": lambda self: dict(ctx.params or {}),
+            "function_result": lambda self, **kw: onto.function_result(**kw),
+        },
+    )
+    p = _Ports()
+    p.sql = s.sql
+    return _ontology_fn_body(p)