Module

def build_xy(
    attributes,
    rows,
    target_names: set[str],
) -> tuple[np.ndarray, np.ndarray]:
    attr_names = [a[0] for a in attributes]

    target_idx = find_target_index(attributes, target_names)
    if target_idx is None:
        raise ValueError(
            f"Target feature not found among dataset attributes "
            f"(default_target_attribute={target_names!r})."
        )

    arr = np.array(rows, dtype=object)

    feature_idxs = [i for i in range(len(attr_names)) if i != target_idx]

    X_full = pd.DataFrame({attr_names[i]: arr[:, i] for i in feature_idxs})
    y_raw = arr[:, target_idx]

    if _numeric_column(y_raw):
        y = np.asarray(
            [np.nan if v is None else float(v) for v in y_raw]
        )
    else:
        y = pd.Categorical(y_raw).codes.astype(float)

    string_cols = X_full.select_dtypes(
        include=["object", "string"],
    ).columns
    multi_word_cols = [
        c
        for c in string_cols
        if X_full[c].dropna().astype(str).str.contains(r"\s").any()
    ]
    X_clean = X_full.drop(columns=multi_word_cols)

    for col in X_clean.select_dtypes(
        include=["object", "string"],
    ).columns:
        values = X_full[col].tolist()
        if _numeric_column(values):
            X_clean[col] = [
                np.nan if v is None else float(v) for v in values
            ]
        else:
            X_clean[col] = pd.Categorical(
                X_full[col],
            ).codes.astype(float)

    return X_clean.to_numpy(dtype=float), y

def compute_dataset_qualities(
    attributes,
    rows,
    target_names: set[str],
) -> list[Quality]:
    attr_types = [a[1] for a in attributes]

    target_idx = find_target_index(attributes, target_names)

    n_instances = len(rows)
    n_features = len(attributes)

    target_type_spec = attr_types[target_idx] if target_idx is not None else None
    target_is_numeric = isinstance(target_type_spec, str) and (
        target_type_spec.upper() in NUMERIC_TYPES
    )

    qualities: list[Quality] = []

    def add(name: str, value: float | None) -> None:
        qualities.append(Quality(name=name, value=value))

    # --- Counts / dimensions ---
    add("NumberOfInstances", float(n_instances))
    add("NumberOfFeatures", float(n_features))

    if target_idx is None or target_is_numeric:
        add("NumberOfClasses", None)
    else:
        target_col = (row[target_idx] for row in rows)
        distinct = {v for v in target_col if v is not None}
        add("NumberOfClasses", float(len(distinct)))

    add(
        "Dimensionality",
        n_features / n_instances if n_instances else None,
    )

    # --- Missing values ---
    n_missing = 0
    rows_with_missing = 0
    for row in rows:
        row_missing = sum(1 for v in row if v is None)
        n_missing += row_missing
        if row_missing:
            rows_with_missing += 1

    add(
        "NumberOfInstancesWithMissingValues",
        float(rows_with_missing),
    )
    add("NumberOfMissingValues", float(n_missing))
    add(
        "PercentageOfInstancesWithMissingValues",
        _pct(rows_with_missing, n_instances),
    )
    add(
        "PercentageOfMissingValues",
        _pct(n_missing, n_instances * n_features),
    )

    # --- Feature types ---
    n_numeric = 0
    n_symbolic = 0
    n_binary = 0
    for i, type_spec in enumerate(attr_types):
        if isinstance(type_spec, list):
            n_symbolic += 1
            if len(type_spec) == 2:
                n_binary += 1
        elif (
            isinstance(
                type_spec,
                str,
            )
            and type_spec.upper() in NUMERIC_TYPES
        ):
            n_numeric += 1
            col = (row[i] for row in rows)
            if len({v for v in col if v is not None}) == 2:
                n_binary += 1

    add("NumberOfNumericFeatures", float(n_numeric))
    add("NumberOfSymbolicFeatures", float(n_symbolic))
    add("NumberOfBinaryFeatures", float(n_binary))
    add(
        "PercentageOfNumericFeatures",
        _pct(n_numeric, n_features),
    )
    add(
        "PercentageOfSymbolicFeatures",
        _pct(n_symbolic, n_features),
    )
    add(
        "PercentageOfBinaryFeatures",
        _pct(n_binary, n_features),
    )

    # --- Class distribution ---
    if target_idx is None or target_is_numeric:
        add("MajorityClassSize", None)
        add("MinorityClassSize", None)
        add("MajorityClassPercentage", None)
        add("MinorityClassPercentage", None)
    else:
        target_col = (row[target_idx] for row in rows)
        counts = Counter(v for v in target_col if v is not None)
        if counts:
            total = sum(counts.values())
            majority = max(counts.values())
            minority = min(counts.values())
            add("MajorityClassSize", float(majority))
            add("MinorityClassSize", float(minority))
            add(
                "MajorityClassPercentage",
                majority / total * 100,
            )
            add(
                "MinorityClassPercentage",
                minority / total * 100,
            )
        else:
            add("MajorityClassSize", None)
            add("MinorityClassSize", None)
            add("MajorityClassPercentage", None)
            add("MinorityClassPercentage", None)

    add(
        "AutoCorrelation",
        _autocorrelation(rows, target_idx, target_is_numeric, n_instances),
    )

    return qualities

def find_target_index(attributes, target_names: set[str]) -> int | None:
    """Index of the first attribute whose name is in ``target_names``.

    ``None`` means the dataset has no usable target: either no
    ``default_target_attribute`` was set, or its name(s) match no attribute.
    Callers use this to decide up front whether supervised extraction
    (pymfe, landmarkers) is possible at all.
    """
    attr_names = [a[0] for a in attributes]
    target_idxs = [i for i, n in enumerate(attr_names) if n in target_names]
    return target_idxs[0] if target_idxs else None