liken.preprocessors

def strip() -> Strip:
    """Remove leading/trailing whitespace."""
    return Strip()

def collapse_whitespace() -> CollapseWhitespace:
    """Replace every run of whitespace with a single space.

    Whitespace runs at the start or end of a string collapse to a single
    space, they are *not* removed. Compose with `strip` for that.

    Whitespace here is ASCII whitespace only: `\\t`, `\\n`, `\\f`, `\\r`
    and space. Other Unicode whitespace, such as non-breaking spaces, is
    not collapsed.
    """
    return CollapseWhitespace()

def lower() -> Lower:
    """Convert strings to lowercase."""
    return Lower()

def alnum() -> Alnum:
    """Remove non-alphanumeric characters, including spaces."""
    return Alnum()

def remove_punctuation() -> RemovePunctuation:
    """Remove punctuation but preserve spaces."""
    return RemovePunctuation()

def normalize_unicode(form: Literal["NFC", "NFKC", "NFD", "NFKD"] = "NFKD") -> NormalizeUnicode:
    """Normalize Unicode strings.

    Args:
        form: Unicode normalization form. Accepted values are "NFC", "NFKC",
            "NFD", "NFKD".
    """
    return NormalizeUnicode(form=form)

def ascii_fold() -> AsciiFold:
    """Converts alphabetic, numeric, and symbolic characters that are not in
    the Basic Latin Unicode block (first 127 ASCII characters) to their ASCII
    equivalent, if one exists. For example, the filter changes à to a.
    """
    return AsciiFold()

def remove_stopwords(
    words: list[str] | None = None,
    language: str = "english",
) -> RemoveStopwords:
    """Remove stopwords.

    Args:
        words: A list of words to ignore. If defined, `language` argument is
            ignored.
        language: The language to use for the stop words dictionary"""
    return RemoveStopwords(words=words, language=language)

def regex_replace(pattern: str, replacement: str) -> RegexReplace:
    """Replace every match of a regular expression pattern.

    Args:
        pattern: The regular expression to match.
        replacement: The string to replace each match with.

    Raises:
        `pa.ArrowInvalid` for an invalid pattern
    """
    return RegexReplace(pattern, replacement)

def normalize_names() -> NormalizeName:
    """Normalize personal names.

    Preserves only first name, middle name and last name. Titles and nicknames
    are stripped. Commas are cleaned.
    """
    return NormalizeName()

def normalize_company() -> NormalizeCompany:
    """Normalize company names.

    Strips common company name nomenclature e.g. "Ltd.", or "LLC".
    """
    return NormalizeCompany()