datasentry-core 0.1.0__py3-none-any.whl

datasentry_core/detectors/datetime.py

@@ -0,0 +1,343 @@
+"""日期时间检测器（11.8，C-13 P0 化 6 个核心）：invalid/impossible/future/stale/mixed/duplicate。"""
+
+from __future__ import annotations
+
+import re
+from collections import Counter
+from typing import ClassVar
+
+from datasentry_core.detectors.base import DetectionContext
+from datasentry_core.detectors.common import (
+    DetectorBase,
+    datetime_columns,
+    make_candidate,
+    make_evidence,
+    quote_ident,
+    quote_re,
+    string_columns,
+)
+from datasentry_core.models.detector import DetectorCapabilities, IssueCandidate
+from datasentry_core.models.enums import EvidenceType, QualityDimension, Severity
+
+# 字符串日期列判定（列名特征；VARCHAR 列才适用 invalid/impossible/mixed）
+# 注意：时间戳列（created_at 等，物理 TIMESTAMP 或含时间值）不归此组，
+# 由 future/stale/duplicate 经 datetime_columns() 处理
+_DATE_HINTS = ("date", "dob", "birth")
+
+# stale_date 豁免列（历史数据字段，规格 11.8：由语义类型豁免；MVP 按列名特征）
+_STALE_EXEMPT_HINTS = ("birth", "dob", "founded", "hire", "established", "historical", "history")
+
+_ISO_RE = re.compile(r"^\d{4}-\d{2}-\d{2}$")
+_SLASH_RE = re.compile(r"^\d{1,2}/\d{1,2}/\d{4}$")
+_DOT_RE = re.compile(r"^\d{1,2}\.\d{1,2}\.\d{4}$")
+_COMPACT_RE = re.compile(r"^\d{8}$")
+
+_DATETIME_RE = r"^\d{4}-\d{2}-\d{2}$"
+
+
+def _date_hinted_string_columns(context: DetectionContext) -> list[str]:
+    return [col for col in string_columns(context) if any(h in col.lower() for h in _DATE_HINTS)]
+
+
+class InvalidDateDetector(DetectorBase):
+    """无效日期（11.8）：字符串日期列中不匹配 ISO 日期模式的值。"""
+
+    detector_id = "invalid_date"
+    display_name = "Invalid Date"
+    description = "Reports non-null string values that do not match a date pattern."
+    quality_dimension = QualityDimension.VALIDITY
+    capabilities: ClassVar[DetectorCapabilities] = DetectorCapabilities(supports_sql_pushdown=True)
+
+    def supports(self, context: DetectionContext) -> bool:
+        return bool(_date_hinted_string_columns(context))
+
+    def detect(self, context: DetectionContext) -> list[IssueCandidate]:
+        candidates: list[IssueCandidate] = []
+        for col in _date_hinted_string_columns(context):
+            q = quote_ident(col)
+            table = context.handle.sql_aggregate(
+                f"SELECT count(*) AS n FROM data "
+                f"WHERE {q} IS NOT NULL AND NOT regexp_matches(trim({q}), {quote_re(_DATETIME_RE)})"
+            ).table
+            count = int(table.column("n").to_pylist()[0])
+            if count > 0:
+                candidates.append(
+                    make_candidate(
+                        detector_id=self.detector_id,
+                        detector_version=self.detector_version,
+                        context=context,
+                        issue_type="invalid_date",
+                        columns=[col],
+                        affected_count=count,
+                        evidence=[
+                            make_evidence(
+                                detector_id=self.detector_id,
+                                detector_version=self.detector_version,
+                                evidence_type=EvidenceType.PATTERN_MATCH,
+                                description=f"{count} values fail ISO date pattern",
+                                data={"count": count, "pattern": _DATETIME_RE},
+                            )
+                        ],
+                        raw_score=count,
+                        confidence=0.9,
+                        severity=Severity.MEDIUM,
+                    )
+                )
+        return candidates
+
+
+class ImpossibleDateDetector(DetectorBase):
+    """不可能日期（11.8）：格式合法但日历不存在（如 2024-02-30）。"""
+
+    detector_id = "impossible_date"
+    display_name = "Impossible Date"
+    description = "Reports calendar-invalid dates (e.g. 2024-02-30)."
+    quality_dimension = QualityDimension.VALIDITY
+    capabilities: ClassVar[DetectorCapabilities] = DetectorCapabilities(supports_sql_pushdown=True)
+
+    def supports(self, context: DetectionContext) -> bool:
+        return bool(_date_hinted_string_columns(context))
+
+    def detect(self, context: DetectionContext) -> list[IssueCandidate]:
+        candidates: list[IssueCandidate] = []
+        for col in _date_hinted_string_columns(context):
+            q = quote_ident(col)
+            table = context.handle.sql_aggregate(
+                f"SELECT count(*) AS n FROM data "
+                f"WHERE {q} IS NOT NULL "
+                f"AND regexp_matches(trim({q}), {quote_re(_DATETIME_RE)}) "
+                f"AND try_strptime(trim({q}), '%Y-%m-%d') IS NULL"
+            ).table
+            count = int(table.column("n").to_pylist()[0])
+            if count > 0:
+                candidates.append(
+                    make_candidate(
+                        detector_id=self.detector_id,
+                        detector_version=self.detector_version,
+                        context=context,
+                        issue_type="impossible_date",
+                        columns=[col],
+                        affected_count=count,
+                        evidence=[
+                            make_evidence(
+                                detector_id=self.detector_id,
+                                detector_version=self.detector_version,
+                                evidence_type=EvidenceType.PATTERN_MATCH,
+                                description=f"{count} calendar-invalid dates",
+                                data={"count": count, "pattern": _DATETIME_RE},
+                            )
+                        ],
+                        raw_score=count,
+                        confidence=0.95,
+                        severity=Severity.HIGH,
+                    )
+                )
+        return candidates
+
+
+class FutureDateDetector(DetectorBase):
+    """未来日期（11.8）：date > now + 1 day（排除时区漂移）。"""
+
+    detector_id = "future_date"
+    display_name = "Future Date"
+    description = "Reports dates more than 1 day in the future."
+    quality_dimension = QualityDimension.VALIDITY
+    capabilities: ClassVar[DetectorCapabilities] = DetectorCapabilities(supports_sql_pushdown=True)
+    default_thresholds: ClassVar[dict[str, float | int | str]] = {"max_future_days": 1}
+
+    def detect(self, context: DetectionContext) -> list[IssueCandidate]:
+        candidates: list[IssueCandidate] = []
+        for col in datetime_columns(context):
+            q = quote_ident(col)
+            table = context.handle.sql_aggregate(
+                f"SELECT count(*) AS n FROM data "
+                f"WHERE {q} IS NOT NULL AND {q} > current_date + INTERVAL 1 DAY"
+            ).table
+            count = int(table.column("n").to_pylist()[0])
+            if count > 0:
+                candidates.append(
+                    make_candidate(
+                        detector_id=self.detector_id,
+                        detector_version=self.detector_version,
+                        context=context,
+                        issue_type="future_date",
+                        columns=[col],
+                        affected_count=count,
+                        evidence=[
+                            make_evidence(
+                                detector_id=self.detector_id,
+                                detector_version=self.detector_version,
+                                evidence_type=EvidenceType.CONSTRAINT_VIOLATION,
+                                description=f"{count} dates beyond today + 1 day",
+                                data={"count": count, "max_future_days": 1},
+                            )
+                        ],
+                        raw_score=count,
+                        confidence=0.9,
+                        severity=Severity.LOW,
+                    )
+                )
+        return candidates
+
+
+class StaleDateDetector(DetectorBase):
+    """过期日期（11.8）：date < now - 365d；历史数据字段按列名豁免。"""
+
+    detector_id = "stale_date"
+    display_name = "Stale Date"
+    description = "Reports dates older than 365 days (exempting historical fields)."
+    quality_dimension = QualityDimension.VALIDITY
+    capabilities: ClassVar[DetectorCapabilities] = DetectorCapabilities(supports_sql_pushdown=True)
+    default_thresholds: ClassVar[dict[str, float | int | str]] = {"max_age_days": 365}
+
+    def detect(self, context: DetectionContext) -> list[IssueCandidate]:
+        candidates: list[IssueCandidate] = []
+        for col in datetime_columns(context):
+            if any(h in col.lower() for h in _STALE_EXEMPT_HINTS):
+                continue
+            q = quote_ident(col)
+            table = context.handle.sql_aggregate(
+                f"SELECT count(*) AS n FROM data "
+                f"WHERE {q} IS NOT NULL AND {q} < current_date - INTERVAL 365 DAY"
+            ).table
+            count = int(table.column("n").to_pylist()[0])
+            if count > 0:
+                candidates.append(
+                    make_candidate(
+                        detector_id=self.detector_id,
+                        detector_version=self.detector_version,
+                        context=context,
+                        issue_type="stale_date",
+                        columns=[col],
+                        affected_count=count,
+                        evidence=[
+                            make_evidence(
+                                detector_id=self.detector_id,
+                                detector_version=self.detector_version,
+                                evidence_type=EvidenceType.CONSTRAINT_VIOLATION,
+                                description=f"{count} dates older than 365 days",
+                                data={"count": count, "max_age_days": 365},
+                            )
+                        ],
+                        raw_score=count,
+                        confidence=0.85,
+                        severity=Severity.LOW,
+                    )
+                )
+        return candidates
+
+
+def _classify_date(value: str) -> str:
+    v = value.strip()
+    if _ISO_RE.match(v):
+        return "iso"
+    if _SLASH_RE.match(v):
+        return "slash"
+    if _DOT_RE.match(v):
+        return "dot"
+    if _COMPACT_RE.match(v):
+        return "compact"
+    return "other"
+
+
+class MixedDateFormatDetector(DetectorBase):
+    """混合日期格式（11.8）：同一列 >=2 种解析格式且占比均 > 0.02，报告各格式占比。"""
+
+    detector_id = "mixed_date_format"
+    display_name = "Mixed Date Format"
+    description = "Reports columns with >=2 date formats each covering >2% of values."
+    quality_dimension = QualityDimension.VALIDITY
+    capabilities: ClassVar[DetectorCapabilities] = DetectorCapabilities(supports_sql_pushdown=True)
+    default_thresholds: ClassVar[dict[str, float | int | str]] = {"min_ratio": 0.02}
+
+    def supports(self, context: DetectionContext) -> bool:
+        return bool(_date_hinted_string_columns(context))
+
+    def detect(self, context: DetectionContext) -> list[IssueCandidate]:
+        candidates: list[IssueCandidate] = []
+        for col in _date_hinted_string_columns(context):
+            q = quote_ident(col)
+            table = context.handle.sql_aggregate(
+                f"SELECT {q} AS v FROM data WHERE {q} IS NOT NULL LIMIT 10000"
+            ).table
+            values = table.column("v").to_pylist()
+            if len(set(values)) < 10:
+                continue
+            counter: Counter[str] = Counter(_classify_date(str(v)) for v in values)
+            total = sum(counter.values())
+            formats = {fmt: count / total for fmt, count in counter.items() if fmt != "other"}
+            major = [fmt for fmt, ratio in formats.items() if ratio > 0.02]
+            if len(major) < 2:
+                continue
+            secondary = sum(counter[f] for f in formats if f not in (major[0],))
+            candidates.append(
+                make_candidate(
+                    detector_id=self.detector_id,
+                    detector_version=self.detector_version,
+                    context=context,
+                    issue_type="mixed_date_format",
+                    columns=[col],
+                    affected_count=secondary,
+                    evidence=[
+                        make_evidence(
+                            detector_id=self.detector_id,
+                            detector_version=self.detector_version,
+                            evidence_type=EvidenceType.STATISTICAL_MEASURE,
+                            description=f"{len(major)} date formats each >2%",
+                            data={"formats": {k: round(v, 4) for k, v in formats.items()}},
+                        )
+                    ],
+                    raw_score=len(major),
+                    confidence=0.85,
+                    severity=Severity.LOW,
+                )
+            )
+        return candidates
+
+
+class DuplicateTimestampDetector(DetectorBase):
+    """重复时间戳（11.8）：同一时间戳出现 > 2x；主键联合判断归 V1（无主键声明）。"""
+
+    detector_id = "duplicate_timestamp"
+    display_name = "Duplicate Timestamp"
+    description = "Reports timestamps appearing more than twice."
+    quality_dimension = QualityDimension.VALIDITY
+    capabilities: ClassVar[DetectorCapabilities] = DetectorCapabilities(supports_sql_pushdown=True)
+    default_thresholds: ClassVar[dict[str, float | int | str]] = {"max_duplicates": 2}
+
+    def detect(self, context: DetectionContext) -> list[IssueCandidate]:
+        candidates: list[IssueCandidate] = []
+        for col in datetime_columns(context):
+            q = quote_ident(col)
+            table = context.handle.sql_aggregate(
+                f"SELECT {q} AS v, count(*) AS n FROM data "
+                f"WHERE {q} IS NOT NULL GROUP BY {q} "
+                f"HAVING count(*) > 2 LIMIT 20"
+            ).table
+            counts = table.column("n").to_pylist()
+            if not counts:
+                continue
+            affected = sum(int(c) - 1 for c in counts)
+            candidates.append(
+                make_candidate(
+                    detector_id=self.detector_id,
+                    detector_version=self.detector_version,
+                    context=context,
+                    issue_type="duplicate_timestamp",
+                    columns=[col],
+                    affected_count=affected,
+                    evidence=[
+                        make_evidence(
+                            detector_id=self.detector_id,
+                            detector_version=self.detector_version,
+                            evidence_type=EvidenceType.DUPLICATE_MATCH,
+                            description=f"{len(counts)} timestamps appear more than twice",
+                            data={"groups": len(counts), "affected": affected},
+                        )
+                    ],
+                    raw_score=len(counts),
+                    confidence=0.9,
+                    severity=Severity.MEDIUM,
+                )
+            )
+        return candidates

datasentry_core/detectors/initial/__init__.py

@@ -0,0 +1,117 @@
+"""首批确定性检测器（Step 6/13/14/15/16/17）：36 种（11.3~11.10 的子集，MVP 全表单表）。
+
+注册入口：register_default_detectors(registry)。
+后续步骤补齐剩余检测器（重复 Level 1、分布漂移等）。
+"""
+
+from __future__ import annotations
+
+from datasentry_core.detectors.base import Detector, DetectorRegistry
+from datasentry_core.detectors.cross_field import CrossFieldRuleDetector
+from datasentry_core.detectors.cross_table import ForeignKeyViolationDetector
+from datasentry_core.detectors.datetime import (
+    DuplicateTimestampDetector,
+    FutureDateDetector,
+    ImpossibleDateDetector,
+    InvalidDateDetector,
+    MixedDateFormatDetector,
+    StaleDateDetector,
+)
+from datasentry_core.detectors.initial.anomaly_ml import ModelOutlierDetector
+from datasentry_core.detectors.initial.categorical import (
+    CategoryExplosionDetector,
+    InconsistentCaseDetector,
+    RareCategoryDetector,
+    SuspiciousPlaceholderDetector,
+)
+from datasentry_core.detectors.initial.formula import FormulaInjectionDetector
+from datasentry_core.detectors.initial.missing import (
+    ExcessiveNullRateDetector,
+    SuspiciousMissingTokenDetector,
+)
+from datasentry_core.detectors.initial.numeric import (
+    HistogramRarityDetector,
+    IqrOutlierDetector,
+    ModifiedZScoreDetector,
+    PercentileOutlierDetector,
+    TailProbabilityDetector,
+)
+from datasentry_core.detectors.initial.textual import (
+    HiddenControlCharacterDetector,
+    InvalidEmailDetector,
+    InvalidIpDetector,
+    InvalidPhoneDetector,
+    InvalidUrlDetector,
+    LeadingTrailingWhitespaceDetector,
+    RepeatedWhitespaceDetector,
+    UnusualLengthDetector,
+)
+from datasentry_core.detectors.initial.uniqueness import (
+    FuzzyDuplicateDetector,
+    UniquenessViolationDetector,
+)
+from datasentry_core.detectors.missingness import (
+    ConditionalMissingnessDetector,
+    CorrelatedMissingnessDetector,
+    GroupMissingnessDetector,
+    SuddenMissingnessDetector,
+)
+from datasentry_core.detectors.textual_variants import (
+    FullwidthCharacterDetector,
+    InvalidNumericDetector,
+    MojibakeCharacterDetector,
+    SpellingVariantDetector,
+)
+
+
+def build_initial_detectors() -> list[Detector]:
+    """首批检测器实例列表（按执行顺序）。"""
+    return [
+        ExcessiveNullRateDetector(),
+        SuspiciousMissingTokenDetector(),
+        SuddenMissingnessDetector(),
+        GroupMissingnessDetector(),
+        ConditionalMissingnessDetector(),
+        CorrelatedMissingnessDetector(),
+        UniquenessViolationDetector(),
+        FuzzyDuplicateDetector(),
+        SuspiciousPlaceholderDetector(),
+        RareCategoryDetector(),
+        CategoryExplosionDetector(),
+        InconsistentCaseDetector(),
+        LeadingTrailingWhitespaceDetector(),
+        RepeatedWhitespaceDetector(),
+        HiddenControlCharacterDetector(),
+        UnusualLengthDetector(),
+        InvalidEmailDetector(),
+        InvalidPhoneDetector(),
+        InvalidUrlDetector(),
+        InvalidIpDetector(),
+        IqrOutlierDetector(),
+        PercentileOutlierDetector(),
+        ModifiedZScoreDetector(),
+        TailProbabilityDetector(),
+        HistogramRarityDetector(),
+        FormulaInjectionDetector(),
+        CrossFieldRuleDetector(),
+        InvalidDateDetector(),
+        ImpossibleDateDetector(),
+        FutureDateDetector(),
+        StaleDateDetector(),
+        MixedDateFormatDetector(),
+        DuplicateTimestampDetector(),
+        SpellingVariantDetector(),
+        FullwidthCharacterDetector(),
+        MojibakeCharacterDetector(),
+        InvalidNumericDetector(),
+        ForeignKeyViolationDetector(),
+        ModelOutlierDetector(),
+    ]
+
+
+def register_default_detectors(registry: DetectorRegistry) -> list[Detector]:
+    """向注册表注册首批检测器，返回已注册实例。"""
+    detectors = build_initial_detectors()
+    for detector in detectors:
+        registry.register(detector)
+    return detectors

datasentry_core/detectors/initial/anomaly_ml.py

@@ -0,0 +1,204 @@
+"""机器学习异常检测器（Step 42）：Isolation Forest / LOF，distribution_stability 维度。
+
+与统计法（IQR/z-score）互补：模型法捕获任意形状分布中的偏离点。
+每列独立建模（单变量）；超过 max_samples 时随机采样训练/打分
+（模型提示性信号，severity LOW，供人工确认，不冒充确证异常）。
+"""
+
+from __future__ import annotations
+
+import random
+from typing import ClassVar
+
+import numpy as np
+
+from datasentry_core.detectors.base import DetectionContext
+from datasentry_core.detectors.common import (
+    DetectorBase,
+    make_candidate,
+    make_evidence,
+)
+from datasentry_core.models.detector import DetectorCapabilities, IssueCandidate
+from datasentry_core.models.enums import EvidenceType, QualityDimension, Severity
+
+_NUMERIC_TYPES = frozenset(
+    {
+        "TINYINT",
+        "SMALLINT",
+        "INTEGER",
+        "BIGINT",
+        "HUGEINT",
+        "UTINYINT",
+        "USMALLINT",
+        "UINTEGER",
+        "UBIGINT",
+        "FLOAT",
+        "DOUBLE",
+        "DECIMAL",
+    }
+)
+
+_MAX_SAMPLES = 20_000
+_MIN_ANOMALIES = 3
+_MAX_EXAMPLES = 10
+
+
+def _infer_columns(context: DetectionContext) -> list[str]:
+    return [
+        col.name
+        for col in context.handle.schema().columns
+        if col.physical_type.upper() in _NUMERIC_TYPES
+    ]
+
+
+class ModelOutlierDetector(DetectorBase):
+    """单变量 IF/LOF 异常检测（distribution_stability）。
+
+    config["model"]: "isolation_forest"（默认）| "local_outlier_factor"。
+    anomaly_ratio：异常比例上限（默认 0.05），超过视为模型噪声不报。
+    """
+
+    detector_id = "model_outlier"
+    display_name = "Model Outlier (IF/LOF)"
+    description = (
+        "Flags points deviating from the main distribution using "
+        "Isolation Forest or LOF (single-column, sampled when large)."
+    )
+    quality_dimension = QualityDimension.DISTRIBUTION_STABILITY
+    capabilities: ClassVar[DetectorCapabilities] = DetectorCapabilities(
+        supports_sampling=True,
+        requires_row_materialization=True,
+    )
+    default_thresholds: ClassVar[dict[str, float | int | str]] = {
+        "model": "isolation_forest",
+        "max_samples": _MAX_SAMPLES,
+        "min_anomalies": _MIN_ANOMALIES,
+        "anomaly_ratio": 0.05,
+        "contamination": 0.02,
+    }
+
+    def __init__(self, model: str = "isolation_forest") -> None:
+        self._model = model
+
+    def supports(self, context: DetectionContext) -> bool:
+        return bool(_infer_columns(context))
+
+    def _detect_column(
+        self,
+        values: np.ndarray,
+        model: str,
+        max_samples: int,
+        seed: int,
+        contamination: float,
+    ) -> tuple[int, float, list[float]]:
+        """返回 (异常行数, 异常比例, 样例异常值)。"""
+        if len(values) < 8:
+            return 0, 0.0, []
+        rng = random.Random(seed)
+        if len(values) > max_samples:
+            values = np.array(rng.sample(list(values), max_samples))
+        from sklearn.ensemble import IsolationForest  # type: ignore[import-untyped]
+        from sklearn.neighbors import LocalOutlierFactor  # type: ignore[import-untyped]
+
+        x = values.reshape(-1, 1)
+        if model == "local_outlier_factor":
+            predictor = LocalOutlierFactor(
+                n_neighbors=min(20, max(5, len(x) // 10)),
+                contamination=contamination,
+                novelty=False,
+            )
+            pred = predictor.fit_predict(x)
+        else:
+            predictor = IsolationForest(
+                n_estimators=100,
+                contamination=contamination,
+                random_state=seed,
+                n_jobs=1,
+            )
+            pred = predictor.fit_predict(x)
+        anomaly_mask = pred == -1
+        count = int(anomaly_mask.sum())
+        if count == 0:
+            return 0, 0.0, []
+        examples = [float(v) for v in x[anomaly_mask][:_MAX_EXAMPLES, 0]]
+        return count, count / len(x), examples
+
+    def detect(self, context: DetectionContext) -> list[IssueCandidate]:
+        from datasentry_core.detectors.common import quote_ident
+
+        candidates: list[IssueCandidate] = []
+        model = context.config.detector_params.get("model") if context.config else None
+        model = model or self._model
+        max_samples = (
+            int(context.config.detector_params.get("max_samples", _MAX_SAMPLES))
+            if context.config
+            else _MAX_SAMPLES
+        )
+        min_anomalies = (
+            int(context.config.detector_params.get("min_anomalies", _MIN_ANOMALIES))
+            if context.config
+            else _MIN_ANOMALIES
+        )
+        max_ratio = (
+            float(context.config.detector_params.get("anomaly_ratio", 0.05))
+            if context.config
+            else 0.05
+        )
+        contamination = (
+            float(context.config.detector_params.get("contamination", 0.02))
+            if context.config
+            else 0.02
+        )
+        seed = context.config.seed if context.config else 42
+        for column in _infer_columns(context):
+            q = quote_ident(column)
+            try:
+                table = context.handle.sql_aggregate(
+                    f"SELECT {q} AS v FROM data WHERE {q} IS NOT NULL"
+                ).table
+            except Exception:
+                continue
+            values = np.asarray(table.column("v").to_pylist(), dtype=float)
+            values = values[np.isfinite(values)]
+            count, ratio, examples = self._detect_column(
+                values,
+                str(model),
+                max_samples,
+                seed,
+                contamination,
+            )
+            if count < min_anomalies or ratio > max_ratio:
+                continue
+            candidates.append(
+                make_candidate(
+                    detector_id=self.detector_id,
+                    detector_version=self.detector_version,
+                    context=context,
+                    issue_type="model_outlier",
+                    columns=[column],
+                    affected_count=count,
+                    evidence=[
+                        make_evidence(
+                            detector_id=self.detector_id,
+                            detector_version=self.detector_version,
+                            evidence_type=EvidenceType.STATISTICAL_MEASURE,
+                            description=(
+                                f"{model}: {count} anomalies out of "
+                                f"{len(values)} values ({ratio:.1%})"
+                            ),
+                            data={
+                                "model": model,
+                                "anomaly_count": count,
+                                "anomaly_ratio": round(ratio, 6),
+                                "total_values": len(values),
+                                "examples": [round(v, 4) for v in examples],
+                            },
+                        )
+                    ],
+                    raw_score=count,
+                    confidence=0.7,
+                    severity=Severity.LOW,
+                    fpr=0.3,
+                )
+            )
+        return candidates