alfa vs beta

import re
import unicodedata


def slugify(text: str, separator: str = "-") -> str:
    normalized = unicodedata.normalize("NFKD", text)
    ascii_text = normalized.encode("ascii", "ignore").decode("ascii").lower()
    parts = re.split(r"[^a-z0-9]+", ascii_text)
    return separator.join(part for part in parts if part)

........                                                                 [100%]
8 passed in 0.06s

import re
import unicodedata


def slugify(text: str, separator: str = "-") -> str:
    """Convierte ``text`` en un slug apto para URL."""
    # 1. Quitar tildes y diacríticos: "Canción" -> "Cancion".
    text = unicodedata.normalize("NFKD", text)
    text = text.encode("ascii", "ignore").decode("ascii")

    # 2. Eliminar todo lo que no sea letra, dígito, espacio o guion.
    text = re.sub(r"[^\w\s-]", "", text).strip().lower()

    # 3. Colapsar espacios, guiones y guiones bajos en un único separador.
    text = re.sub(r"[\s_-]+", separator, text)

    # 4. Nunca empezar ni terminar con el separador.
    return text.strip(separator)

....FF..                                                                 [100%]
================================== FAILURES ===================================
_______________________ test_punto_entre_digitos_separa _______________________
test_task.py:22: in test_punto_entre_digitos_separa
    assert slugify("Python 3.12 en 2026") == "python-3-12-en-2026"
E   AssertionError: assert 'python-312-en-2026' == 'python-3-12-en-2026'
E     
E     - python-3-12-en-2026
E     ?         -
E     + python-312-en-2026
_______________________ test_barra_y_guion_bajo_separan _______________________
test_task.py:26: in test_barra_y_guion_bajo_separan
    assert slugify("Entrada/Salida") == "entrada-salida"
E   AssertionError: assert 'entradasalida' == 'entrada-salida'
E     
E     - entrada-salida
E     ?        -
E     + entradasalida
=========================== short test summary info ===========================
FAILED test_task.py::test_punto_entre_digitos_separa - AssertionError: assert...
FAILED test_task.py::test_barra_y_guion_bajo_separan - AssertionError: assert...
2 failed, 6 passed in 0.15s

def merge_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
    for start, end in intervals:
        if start > end:
            raise ValueError(f"Intervalo inválido: ({start}, {end})")

    merged: list[tuple[int, int]] = []
    for start, end in sorted(intervals):
        if merged and start <= merged[-1][1]:
            last_start, last_end = merged[-1]
            merged[-1] = (last_start, max(last_end, end))
        else:
            merged.append((start, end))
    return merged

........                                                                 [100%]
8 passed in 0.06s

def merge_intervals(intervals: list[tuple[int, int]]) -> list[tuple[int, int]]:
    """Fusiona intervalos cerrados que se solapan o comparten un extremo."""
    if not intervals:
        return []

    # Validamos antes de hacer nada para no devolver resultados parciales.
    for interval in intervals:
        start, end = interval
        if start > end:
            raise ValueError(f"El intervalo {interval!r} tiene inicio > fin")

    # sorted() crea una lista nueva, así que la entrada no se modifica.
    ordered = sorted(intervals, key=lambda item: item[0])

    result: list[tuple[int, int]] = [tuple(ordered[0])]
    for start, end in ordered[1:]:
        current_start, current_end = result[-1]
        if start <= current_end:  # se solapan o se tocan
            result[-1] = (current_start, max(current_end, end))
        else:
            result.append((start, end))
    return result

........                                                                 [100%]
8 passed in 0.06s

import re

_SECONDS = {"d": 86_400, "h": 3_600, "m": 60, "s": 1}
_FORMAT = re.compile(r"(?:\s*\d+[dhms])+\s*", re.IGNORECASE)
_COMPONENT = re.compile(r"(\d+)([dhms])", re.IGNORECASE)


def parse_duration(text: str) -> int:
    if not _FORMAT.fullmatch(text):
        raise ValueError(f"Duración no válida: {text!r}")

    total = 0
    seen: set[str] = set()
    for number, unit in _COMPONENT.findall(text):
        unit = unit.lower()
        if unit in seen:
            raise ValueError(f"Unidad repetida: {unit!r}")
        seen.add(unit)
        total += int(number) * _SECONDS[unit]
    return total

...............F                                                         [100%]
================================== FAILURES ===================================
_______________ test_unidades_fuera_de_orden_lanzan_valueerror ________________
test_task.py:41: in test_unidades_fuera_de_orden_lanzan_valueerror
    with pytest.raises(ValueError):
         ^^^^^^^^^^^^^^^^^^^^^^^^^
E   Failed: DID NOT RAISE ValueError
=========================== short test summary info ===========================
FAILED test_task.py::test_unidades_fuera_de_orden_lanzan_valueerror - Failed:...
1 failed, 15 passed in 0.15s

import re

_UNITS = (("d", 86_400), ("h", 3_600), ("m", 60), ("s", 1))
_PATTERN = re.compile(
    r"\s*"
    r"(?:(?P<d>\d+)d)?\s*"
    r"(?:(?P<h>\d+)h)?\s*"
    r"(?:(?P<m>\d+)m)?\s*"
    r"(?:(?P<s>\d+)s)?\s*",
    re.IGNORECASE,
)


def parse_duration(text: str) -> int:
    """Convierte una duración como "1h 30m 15s" en segundos."""
    match = _PATTERN.fullmatch(text)
    if match is None:
        raise ValueError(f"Duración no válida: {text!r}")

    values = match.groupdict()
    if all(value is None for value in values.values()):
        raise ValueError("La duración está vacía")

    return sum(int(values[unit]) * factor for unit, factor in _UNITS if values[unit] is not None)

................                                                         [100%]
16 passed in 0.06s