@dazitech/cli 3.1.0 → 3.1.1

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)

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

@@ -0,0 +1,126 @@
+"""OEE 分解分析 equip_ops.fn.oee_analysis
+
+参数：start_date, end_date, equipment_id（可选）, group_by=plant|unit|equipment|equip_type
+返回：group_id, group_name, availability, performance, quality, oee, runtime_hours, output_qty
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_oee_analysis.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.oee_analysis
+"""
+
+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)"),
+    "equip_type": ("equip_type_id", "any(category)"),
+}
+
+
+def _build_ops_where(start_date, end_date, plant_id=None, equipment_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}'")
+    if equipment_id:
+        clauses.append(f"equipment_id = '{equipment_id}'")
+    return ("WHERE " + " AND ".join(clauses)) if clauses else ""
+
+
+def _calc_oee_metrics(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 {
+        "availability": round(availability, 4),
+        "performance": round(performance, 4),
+        "quality": round(quality, 4),
+        "oee": round(oee, 4),
+        "runtime_hours": round(sum_runtime / 60.0, 2),
+        "output_qty": round(sum_actual, 2),
+    }
+
+
+def _ontology_fn_body(p):
+    params = dict(p.get_params() or {})
+    start_date = params.get("start_date", "")
+    end_date = params.get("end_date", "")
+    equipment_id = params.get("equipment_id") or None
+    group_by = params.get("group_by", "plant")
+    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, equipment_id=equipment_id)
+
+    sql = f"""
+    SELECT
+        {group_id_col} AS group_id,
+        {group_name_expr} AS group_name,
+        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}
+    GROUP BY {group_id_col}
+    ORDER BY group_id
+    """
+
+    result = p.sql.query(sql)
+    if not result:
+        return p.function_result(
+            columns=[
+                "group_id", "group_name", "availability", "performance",
+                "quality", "oee", "runtime_hours", "output_qty",
+            ],
+            data=[],
+            row_count=0,
+        )
+
+    data = []
+    for row in result:
+        metrics = _calc_oee_metrics(row)
+        data.append({
+            "group_id": str(row.get("group_id") or ""),
+            "group_name": str(row.get("group_name") or ""),
+            **metrics,
+        })
+
+    return p.function_result(
+        columns=[
+            "group_id", "group_name", "availability", "performance",
+            "quality", "oee", "runtime_hours", "output_qty",
+        ],
+        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_plan_vs_actual.py

@@ -0,0 +1,105 @@
+"""运行计划对比 equip_ops.fn.plan_vs_actual
+
+参数：fiscal_year, fiscal_month, plan_version, plant_id（可选）
+JOIN fact_equipment_plan 与 fact_equipment_daily_ops
+返回：planned vs actual runtime/output/energy, execution_rate
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_plan_vs_actual.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.plan_vs_actual
+"""
+
+TEST_ARGUMENTS = {
+    "v": 1,
+    "arguments": {
+        "fiscal_year": 2026,
+        "fiscal_month": 6,
+        "plan_version": "2026月度计划",
+    },
+    "object_type_code": "PlanAnalysis",
+}
+
+
+def _ontology_fn_body(p):
+    params = dict(p.get_params() or {})
+    fiscal_year = int(params.get("fiscal_year", 2026))
+    fiscal_month = int(params.get("fiscal_month", 1))
+    plan_version = params.get("plan_version", "2026月度计划")
+    plant_id = params.get("plant_id") or None
+
+    plant_cond = "" if not plant_id else f"AND p.plant_id = '{plant_id}'"
+
+    sql = f"""
+    SELECT
+        sum(p.planned_runtime_min) AS planned_runtime_min,
+        sum(p.planned_output_qty) AS planned_output_qty,
+        sum(p.planned_energy) AS planned_energy,
+        sum(o.runtime_min) AS actual_runtime_min,
+        sum(o.actual_output_qty) AS actual_output_qty,
+        sum(o.energy_consumption) AS actual_energy
+    FROM fact_equipment_plan AS p
+    LEFT JOIN fact_equipment_daily_ops AS o
+        ON p.equipment_id = o.equipment_id AND p.date_key = o.date_key
+    WHERE p.fiscal_year = {fiscal_year}
+        AND p.fiscal_month = {fiscal_month}
+        AND p.plan_version = '{plan_version}'
+        {plant_cond}
+    """
+
+    rows = p.sql.query(sql)
+    row = rows[0] if rows else {}
+
+    planned_runtime = float(row.get("planned_runtime_min") or 0)
+    planned_output = float(row.get("planned_output_qty") or 0)
+    planned_energy = float(row.get("planned_energy") or 0)
+    actual_runtime = float(row.get("actual_runtime_min") or 0)
+    actual_output = float(row.get("actual_output_qty") or 0)
+    actual_energy = float(row.get("actual_energy") or 0)
+
+    runtime_rate = actual_runtime / planned_runtime if planned_runtime > 0 else 0.0
+    output_rate = actual_output / planned_output if planned_output > 0 else 0.0
+    energy_rate = actual_energy / planned_energy if planned_energy > 0 else 0.0
+    execution_rate = (runtime_rate + output_rate + energy_rate) / 3.0
+
+    data = [{
+        "fiscal_year": fiscal_year,
+        "fiscal_month": fiscal_month,
+        "plan_version": plan_version,
+        "planned_runtime_hours": round(planned_runtime / 60.0, 2),
+        "actual_runtime_hours": round(actual_runtime / 60.0, 2),
+        "runtime_execution_rate": round(runtime_rate, 4),
+        "planned_output_qty": round(planned_output, 2),
+        "actual_output_qty": round(actual_output, 2),
+        "output_execution_rate": round(output_rate, 4),
+        "planned_energy": round(planned_energy, 2),
+        "actual_energy": round(actual_energy, 2),
+        "energy_execution_rate": round(energy_rate, 4),
+        "execution_rate": round(execution_rate, 4),
+    }]
+
+    return p.function_result(
+        columns=[
+            "fiscal_year", "fiscal_month", "plan_version",
+            "planned_runtime_hours", "actual_runtime_hours", "runtime_execution_rate",
+            "planned_output_qty", "actual_output_qty", "output_execution_rate",
+            "planned_energy", "actual_energy", "energy_execution_rate",
+            "execution_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_top_fault_equipment.py

@@ -0,0 +1,104 @@
+"""故障 TOP 设备 equip_ops.fn.top_fault_equipment
+
+参数：start_date, end_date, limit=10, plant_id（可选）
+按非计划停机时长 TOP 设备
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_top_fault_equipment.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.top_fault_equipment
+"""
+
+TEST_ARGUMENTS = {
+    "v": 1,
+    "arguments": {
+        "start_date": "2025-01-01",
+        "end_date": "2026-06-30",
+        "limit": 10,
+    },
+    "object_type_code": "EquipmentAnalysis",
+}
+
+
+def _build_where(start_date, end_date, plant_id=None):
+    clauses = ["e.is_planned = 0"]
+    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)
+
+
+def _ontology_fn_body(p):
+    params = dict(p.get_params() or {})
+    start_date = params.get("start_date", "")
+    end_date = params.get("end_date", "")
+    limit = int(params.get("limit", 10) or 10)
+    plant_id = params.get("plant_id") or None
+    where_clause = _build_where(start_date, end_date, plant_id)
+
+    sql = f"""
+    SELECT
+        e.equipment_id,
+        any(e.equipment_code) AS equipment_code,
+        any(e.equipment_name) AS equipment_name,
+        any(eq.plant_name) AS plant_name,
+        any(eq.unit_name) AS unit_name,
+        sum(e.duration_min) AS downtime_min,
+        count() AS event_count
+    FROM fact_downtime_event AS e
+    LEFT JOIN dim_equipment AS eq ON e.equipment_id = eq.equipment_id
+    {where_clause}
+    GROUP BY e.equipment_id
+    ORDER BY downtime_min DESC
+    LIMIT {limit}
+    """
+
+    result = p.sql.query(sql)
+    if not result:
+        return p.function_result(
+            columns=[
+                "rank", "equipment_id", "equipment_code", "equipment_name",
+                "plant_name", "unit_name", "downtime_hours", "event_count",
+            ],
+            data=[],
+            row_count=0,
+        )
+
+    data = []
+    for rank, row in enumerate(result, start=1):
+        data.append({
+            "rank": rank,
+            "equipment_id": str(row.get("equipment_id") or ""),
+            "equipment_code": str(row.get("equipment_code") or ""),
+            "equipment_name": str(row.get("equipment_name") or ""),
+            "plant_name": str(row.get("plant_name") or ""),
+            "unit_name": str(row.get("unit_name") or ""),
+            "downtime_hours": round(float(row.get("downtime_min") or 0) / 60.0, 2),
+            "event_count": int(row.get("event_count") or 0),
+        })
+
+    return p.function_result(
+        columns=[
+            "rank", "equipment_id", "equipment_code", "equipment_name",
+            "plant_name", "unit_name", "downtime_hours", "event_count",
+        ],
+        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_unit_comparison.py

@@ -0,0 +1,120 @@
+"""工艺单元对标 equip_ops.fn.unit_comparison
+
+参数：start_date, end_date, metric=oee|availability|output, plant_id（可选）
+按工艺单元对标排名
+
+发布：
+  dazi onto script publish 项目/DAZI_TEST/本体/ontos/设备运营/functions/equip_ops_fn_unit_comparison.py \
+    --space space_cate_test01 --register-function-id equip_ops.fn.unit_comparison
+"""
+
+TEST_ARGUMENTS = {
+    "v": 1,
+    "arguments": {
+        "start_date": "2025-01-01",
+        "end_date": "2026-06-30",
+        "metric": "oee",
+    },
+    "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 _calc_metric(row, metric):
+    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
+    if metric == "availability":
+        return round(availability, 4)
+    if metric == "output":
+        return round(sum_actual, 2)
+    return 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", "")
+    metric = params.get("metric", "oee")
+    plant_id = params.get("plant_id") or None
+    where_clause = _build_ops_where(start_date, end_date, plant_id)
+
+    sql = f"""
+    SELECT
+        unit_id,
+        any(unit_name) AS unit_name,
+        any(plant_name) AS plant_name,
+        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}
+    GROUP BY unit_id
+    """
+
+    result = p.sql.query(sql)
+    if not result:
+        return p.function_result(
+            columns=["rank", "unit_id", "unit_name", "plant_name", "metric", "metric_value"],
+            data=[],
+            row_count=0,
+        )
+
+    scored = []
+    for row in result:
+        scored.append({
+            "unit_id": str(row.get("unit_id") or ""),
+            "unit_name": str(row.get("unit_name") or ""),
+            "plant_name": str(row.get("plant_name") or ""),
+            "metric_value": _calc_metric(row, metric),
+        })
+
+    scored.sort(key=lambda x: x["metric_value"], reverse=True)
+
+    data = []
+    for rank, item in enumerate(scored, start=1):
+        data.append({
+            "rank": rank,
+            "unit_id": item["unit_id"],
+            "unit_name": item["unit_name"],
+            "plant_name": item["plant_name"],
+            "metric": metric,
+            "metric_value": item["metric_value"],
+        })
+
+    return p.function_result(
+        columns=["rank", "unit_id", "unit_name", "plant_name", "metric", "metric_value"],
+        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)