textutils-kit 0.0.1__py3-none-any.whl

textutils/__init__.py

@@ -0,0 +1,17 @@
+from .casing import camel_case
+from .casing._capitalize_words import capitalize_words
+from .casing._snake_case import snake_case
+from .counting._character_count import character_count
+from .counting._word_count import word_count
+from .frequency._word_frequency import word_frequency
+from .transform._reverse import reverse
+
+__all__ = [
+    "camel_case",
+    "capitalize_words",
+    "character_count",
+    "reverse",
+    "snake_case",
+    "word_count",
+    "word_frequency",
+]

textutils/casing/__init__.py

@@ -0,0 +1,7 @@
+"""Utilities for text casing and naming conventions."""
+
+from ._camel_case import camel_case
+from ._capitalize_words import capitalize_words
+from ._snake_case import snake_case
+
+__all__ = ["camel_case", "capitalize_words", "snake_case"]

textutils/casing/_camel_case.py

@@ -0,0 +1,20 @@
+def camel_case(text):
+    """
+    Convert a text to camel case.
+
+    Parameters
+    ----------
+    text : str
+        The text to convert to camel case.
+
+    Returns
+    -------
+    str
+        The text converted to camel case.
+    """
+    words = text.split()
+
+    if not words:
+        return ""
+
+    return words[0].lower() + "".join(word.capitalize() for word in words[1:])

textutils/casing/_capitalize_words.py

@@ -0,0 +1,21 @@
+def capitalize_words(text):
+    """
+    Capitalize the first letter of each word in a text.
+
+    Parameters
+    ----------
+    text : str
+        The text in which to capitalize the words.
+
+    Returns
+    -------
+    str
+        The text with each word capitalized.
+    """
+    result = ""
+    for i in range(len(text)):
+        if i == 0 or text[i - 1].isspace():
+            result += text[i].upper()
+        else:
+            result += text[i]
+    return result

textutils/casing/_snake_case.py

@@ -0,0 +1,15 @@
+def snake_case(text):
+    """
+    Convert a text to snake case.
+
+    Parameters
+    ----------
+    text : str
+        The text to convert to snake case.
+
+    Returns
+    -------
+    str
+        The text converted to snake case.
+    """
+    return "_".join(text.lower().split())

textutils/casing/tests/test_camel_case.py

@@ -0,0 +1,29 @@
+from textutils.casing._camel_case import camel_case
+
+
+def test_camel_case_normal():
+    assert camel_case("hello world") == "helloWorld"
+
+
+def test_camel_case_upper():
+    assert camel_case("HELLO WORLD") == "helloWorld"
+
+
+def test_camel_case_multiple_spaces():
+    assert camel_case("hello   world") == "helloWorld"
+
+
+def test_camel_case_empty():
+    assert camel_case("") == ""
+
+
+def test_camel_case_newlines():
+    assert camel_case("hello\nworld") == "helloWorld"
+
+
+def test_camel_case_tabs():
+    assert camel_case("hello\tworld") == "helloWorld"
+
+
+def test_camel_case_leading_trailing_spaces():
+    assert camel_case(" hello world ") == "helloWorld"

textutils/casing/tests/test_capitalize_words.py

@@ -0,0 +1,37 @@
+from textutils.casing._capitalize_words import capitalize_words
+
+
+def test_capitalize_words_normal():
+    assert capitalize_words("hello world") == "Hello World"
+
+
+def test_capitalize_words_capitalize():
+    assert capitalize_words("Hello World") == "Hello World"
+
+
+def test_capitalize_words_upper():
+    assert capitalize_words("HELLO WORLD") == "HELLO WORLD"
+
+
+def test_capitalize_words_empty():
+    assert capitalize_words("") == ""
+
+
+def test_capitalize_words_number():
+    assert capitalize_words("1234") == "1234"
+
+
+def test_capitalize_words_multiple_spaces():
+    assert capitalize_words("hello   world") == "Hello   World"
+
+
+def test_capitalize_words_newlines():
+    assert capitalize_words("hello\nworld") == "Hello\nWorld"
+
+
+def test_capitalize_words_tabs():
+    assert capitalize_words("hello\tworld") == "Hello\tWorld"
+
+
+def test_capitalize_words_apostrophe():
+    assert capitalize_words("don't stop") == "Don't Stop"

textutils/casing/tests/test_snake_case.py

@@ -0,0 +1,33 @@
+from textutils.casing._snake_case import snake_case
+
+
+def test_snake_case_normal():
+    assert snake_case("hello world") == "hello_world"
+
+
+def test_snake_case_upper():
+    assert snake_case("HELLO WORLD") == "hello_world"
+
+
+def test_snake_case_multiple_spaces():
+    assert snake_case("hello   world") == "hello_world"
+
+
+def test_snake_case_empty():
+    assert snake_case("") == ""
+
+
+def test_snake_case_already_snake_case():
+    assert snake_case("hello_world") == "hello_world"
+
+
+def test_snake_case_newlines():
+    assert snake_case("hello\nworld") == "hello_world"
+
+
+def test_snake_case_tabs():
+    assert snake_case("hello\tworld") == "hello_world"
+
+
+def test_snake_case_leading_trailing_spaces():
+    assert snake_case(" hello world ") == "hello_world"

textutils/counting/__init__.py

@@ -0,0 +1,6 @@
+"""Utilities for counting words and characters."""
+
+from ._character_count import character_count
+from ._word_count import word_count
+
+__all__ = ["character_count", "word_count"]

textutils/counting/_character_count.py

@@ -0,0 +1,24 @@
+def character_count(text, include_spaces=True):
+    """
+    Count the number of characters in a text.
+
+    Parameters
+    ----------
+    text : str
+        The text in which to count the characters.
+    include_spaces : bool, optional
+        Whether to include spaces in the count. Defaults to True.
+
+    Returns
+    -------
+    int
+        The number of characters in the text.
+    """
+    if not include_spaces:
+        nb = 0
+        for i in range(len(text)):
+            if text[i] != " ":
+                nb += 1
+        return nb
+    else:
+        return len(text)

textutils/counting/_word_count.py

@@ -0,0 +1,16 @@
+def word_count(text):
+    """
+    Count the number of words in a text.
+
+    Parameters
+    ----------
+    text : str
+        The text in which to count the words.
+
+    Returns
+    -------
+    int
+        The number of words in the text.
+    """
+    words = text.split()
+    return len(words)

textutils/counting/tests/test_character_count.py

@@ -0,0 +1,61 @@
+from textutils.counting._character_count import character_count
+
+
+def test_character_count():
+    assert character_count("Hello world") == 11
+
+
+def test_character_count_normal_true():
+    assert character_count("Hello world", True) == 11
+
+
+def test_character_count_normal_false():
+    assert character_count("Hello world", False) == 10
+
+
+def test_character_count_empty_true():
+    assert character_count("", True) == 0
+
+
+def test_character_count_empty_false():
+    assert character_count("", False) == 0
+
+
+def test_character_count_single_word_true():
+    assert character_count("Hello", True) == 5
+
+
+def test_character_count_single_word_false():
+    assert character_count("Hello", False) == 5
+
+
+def test_character_count_multiple_spaces_true():
+    assert character_count("Hello   world", True) == 13
+
+
+def test_character_count_multiple_spaces_false():
+    assert character_count("Hello   world", False) == 10
+
+
+def test_character_count_whitespace_true():
+    assert character_count("   ", True) == 3
+
+
+def test_character_count_whitespace_false():
+    assert character_count("   ", False) == 0
+
+
+def test_character_count_newlines_true():
+    assert character_count("Hello\nworld", True) == 11
+
+
+def test_character_count_newlines_false():
+    assert character_count("Hello\nworld", False) == 11
+
+
+def test_character_count_tabs_true():
+    assert character_count("Hello\tworld", True) == 11
+
+
+def test_character_count_tabs_false():
+    assert character_count("Hello\tworld", False) == 11

textutils/counting/tests/test_word_count.py

@@ -0,0 +1,29 @@
+from textutils.counting._word_count import word_count
+
+
+def test_word_count_normal():
+    assert word_count("Hello world") == 2
+
+
+def test_word_count_empty():
+    assert word_count("") == 0
+
+
+def test_word_count_single_word():
+    assert word_count("Hello") == 1
+
+
+def test_word_count_multiple_spaces():
+    assert word_count("Hello   world") == 2
+
+
+def test_word_count_whitespace():
+    assert word_count("   ") == 0
+
+
+def test_word_count_newlines():
+    assert word_count("Hello\nworld") == 2
+
+
+def test_word_count_tabs():
+    assert word_count("Hello\tworld") == 2

textutils/frequency/__init__.py

@@ -0,0 +1,5 @@
+"""Utilities for analyzing word frequencies."""
+
+from ._word_frequency import word_frequency
+
+__all__ = ["word_frequency"]

textutils/frequency/_word_frequency.py

@@ -0,0 +1,163 @@
+import string
+
+
+def _normalize(word, case_sensitive):
+    """
+    Strip surrounding punctuation and apply the case option to a word.
+
+    Parameters
+    ----------
+    word : str
+        The word to clean.
+    case_sensitive : bool
+        If False, the word is converted to lowercase.
+
+    Returns
+    -------
+    str
+        The cleaned word, which may be empty if it contained
+        only punctuation.
+    """
+    word = word.strip(string.punctuation)
+    return word if case_sensitive else word.lower()
+
+
+def _normalize_ignored(ignore_words, case_sensitive):
+    """
+    Build the set of words to ignore, following the case option.
+
+    Parameters
+    ----------
+    ignore_words : list[str] or None
+        Words to exclude, or None for no exclusion.
+    case_sensitive : bool
+        If False, ignored words are converted to lowercase.
+
+    Returns
+    -------
+    set[str]
+        The normalized words to ignore.
+    """
+    return {_normalize(word, case_sensitive) for word in (ignore_words or [])}
+
+
+def _extract_words(text, case_sensitive, ignored, min_length):
+    """
+    Yield the words of a text that must be counted.
+
+    Parameters
+    ----------
+    text : str
+        The text to analyze.
+    case_sensitive : bool
+        Whether to preserve the original case.
+    ignored : set[str]
+        Normalized words to skip.
+    min_length : int
+        Words shorter than this are skipped.
+
+    Yields
+    ------
+    str
+        Each normalized word that passes the filters.
+    """
+    for raw_word in text.split():
+        word = _normalize(raw_word, case_sensitive)
+        if word and len(word) >= min_length and word not in ignored:
+            yield word
+
+
+def _count_words(words):
+    """
+    Count word occurrences, keeping the order of first appearance.
+
+    Parameters
+    ----------
+    words : Iterable[str]
+        The words to count.
+
+    Returns
+    -------
+    dict[str, int]
+        The number of occurrences of each word.
+    """
+    counts = {}
+    for word in words:
+        counts[word] = counts.get(word, 0) + 1
+    return counts
+
+
+def _sort_by_frequency(counts):
+    """
+    Sort word counts by decreasing frequency.
+
+    Words with equal frequencies keep their order of first appearance.
+
+    Parameters
+    ----------
+    counts : dict[str, int]
+        The number of occurrences of each word.
+
+    Returns
+    -------
+    list[tuple[str, int]]
+        The (word, count) pairs, ordered by decreasing frequency.
+    """
+    return sorted(counts.items(), key=lambda item: -item[1])
+
+
+def word_frequency(
+    text, case_sensitive=False, ignore_words=None, min_length=1, top_n=None
+):
+    """
+    Count how often each word appears in a text.
+
+    Punctuation around words is ignored, so "python", "python." and "python!"
+    are the same word. Apostrophes inside a word (e.g. "don't") are kept.
+
+    Parameters
+    ----------
+    text : str
+        The text to analyze.
+    case_sensitive : bool, optional
+        If False (default), "Python" and "python" are counted as the
+        same word and returned in lowercase.
+    ignore_words : list[str] or None, optional
+        Words to exclude from the result.
+        The comparison follows the case_sensitive option.
+    min_length : int, optional
+        Words shorter than this are ignored. Defaults to 1.
+    top_n : int or None, optional
+        If set, only the top_n most frequent words are returned.
+        Defaults to None.
+
+    Returns
+    -------
+    dict[str, int]
+        A dictionary ordered by decreasing frequency. Words with
+        the same frequency keep their order of first appearance.
+        An empty or whitespace-only text returns an empty dictionary.
+
+    Raises
+    ------
+    TypeError
+        If text is not a string.
+    ValueError
+        If min_length is negative.
+
+    Examples
+    --------
+    >>> word_frequency("Python is great. Python is simple.")
+    {'python': 2, 'is': 2, 'great': 1, 'simple': 1}
+    """
+    if not isinstance(text, str):
+        raise TypeError("text must be a string")
+    if min_length < 0:
+        raise ValueError("min_length must be greater than or equal to 0")
+    if top_n is not None and top_n <= 0:
+        return {}
+
+    ignored = _normalize_ignored(ignore_words, case_sensitive)
+    words = _extract_words(text, case_sensitive, ignored, min_length)
+    ordered = _sort_by_frequency(_count_words(words))
+    return dict(ordered[:top_n])

textutils/frequency/tests/test_word_frequency.py

@@ -0,0 +1,97 @@
+import pytest
+
+from textutils.frequency._word_frequency import word_frequency
+
+
+def test_word_frequency_normal():
+    assert word_frequency("hello world hello") == {
+        "hello": 2,
+        "world": 1,
+    }
+
+
+def test_word_frequency_empty():
+    assert word_frequency("") == {}
+
+
+def test_word_frequency_whitespace():
+    assert word_frequency("     ") == {}
+
+
+def test_word_frequency_single_word():
+    assert word_frequency("hello") == {
+        "hello": 1,
+    }
+
+
+def test_word_frequency_upper_false():
+    assert word_frequency("Hello hello HELLO") == {
+        "hello": 3,
+    }
+
+
+def test_word_frequency_upper_true():
+    assert word_frequency("Hello hello HELLO", case_sensitive=True) == {
+        "Hello": 1,
+        "hello": 1,
+        "HELLO": 1,
+    }
+
+
+def test_word_frequency_punctuation():
+    assert word_frequency("Hello! hello. hello?") == {
+        "hello": 3,
+    }
+
+
+def test_word_frequency_ignore_words():
+    assert word_frequency("hello world hello", ignore_words=["hello"]) == {
+        "world": 1,
+    }
+
+
+def test_word_frequency_min_length():
+    assert word_frequency("I love Python", min_length=2) == {
+        "love": 1,
+        "python": 1,
+    }
+
+
+def test_word_frequency_top_n():
+    assert word_frequency("cat dog cat bird cat dog", top_n=2) == {
+        "cat": 3,
+        "dog": 2,
+    }
+
+
+def test_word_frequency_top_n_zero():
+    assert word_frequency("cat dog cat bird cat dog", top_n=0) == {}
+
+
+def test_word_frequency_invalid_text():
+    with pytest.raises(TypeError):
+        word_frequency(123)
+
+
+def test_word_frequency_negative_min_length():
+    with pytest.raises(ValueError):
+        word_frequency("hello world", min_length=-1)
+
+
+def test_word_frequency_apostrophe():
+    assert word_frequency("don't don't") == {"don't": 2}
+
+
+def test_word_frequency_tied_frequencies():
+    assert list(word_frequency("dog cat dog cat")) == ["dog", "cat"]
+
+
+def test_word_frequency_ignore_words_case():
+    assert word_frequency(
+        "Hello hello world",
+        ignore_words=["HELLO"],
+    ) == {"world": 1}
+
+
+def test_word_frequency_only_punctuation():
+    assert word_frequency("!!! ??? ...") == {}

textutils/transform/__init__.py

@@ -0,0 +1,5 @@
+"""Utilities for text transformations."""
+
+from ._reverse import reverse
+
+__all__ = ["reverse"]

textutils/transform/_reverse.py

@@ -0,0 +1,15 @@
+def reverse(text):
+    """
+    Reverse the characters in a text.
+
+    Parameters
+    ----------
+    text : str
+        The text to reverse.
+
+    Returns
+    -------
+    str
+        The reversed text.
+    """
+    return text[::-1]

textutils/transform/tests/test_reverse.py

@@ -0,0 +1,25 @@
+from textutils.transform._reverse import reverse
+
+
+def test_reverse_normal():
+    assert reverse("bonjour") == "ruojnob"
+
+
+def test_reverse_empty():
+    assert reverse("") == ""
+
+
+def test_reverse_single_character():
+    assert reverse("a") == "a"
+
+
+def test_reverse_with_spaces():
+    assert reverse("hello world") == "dlrow olleh"
+
+
+def test_reverse_unicode():
+    assert reverse("été") == "été"
+
+
+def test_reverse_numbers():
+    assert reverse("12345") == "54321"

textutils_kit-0.0.1.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: textutils-kit
+Version: 0.0.1
+Summary: A Python library providing utilities for text manipulation and analysis.
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest<10,>=9; extra == "dev"
+Requires-Dist: pytest-cov<8,>=7; extra == "dev"
+Requires-Dist: black<26,>=25; extra == "dev"
+Requires-Dist: ruff<0.18,>=0.17; extra == "dev"
+Dynamic: license-file
+
+# textutils
+
+An open-source Python library providing simple utilities for common text-processing operations.
+
+## Features
+
+- `word_count(text)`: Count the number of words in a text.
+- `character_count(text, include_spaces=True)`: Count the number of characters in a text, with the option to include or exclude spaces.
+- `reverse(text)`: Reverse the characters in a text.
+- `capitalize_words(text)`: Capitalize the first letter of each word in a text.
+- `snake_case(text)`: Convert a text to snake case.
+- `word_frequency(text, case_sensitive=False, ignore_words=None, min_length=1, top_n=None)`: Count how often each word appears in a text, ordered by frequency.
+
+## Requirements
+
+- Python 3.12 or later.
+
+## Installation
+
+Clone the repository and install the package:
+
+```bash
+git clone https://github.com/Emilie-Th/textutils.git
+cd textutils
+python -m pip install .
+```
+
+To install the package with the development dependencies:
+
+```bash
+python -m pip install -e ".[dev]"
+```
+
+## Usage
+
+```python
+from textutils import (
+    word_count,
+    character_count,
+    reverse,
+    capitalize_words,
+    snake_case,
+    word_frequency,
+)
+
+print(word_count("Hello Open Source!"))
+print(character_count("Hello Open Source!", include_spaces=False))
+print(reverse("Hello Open Source!"))
+print(capitalize_words("hello open source!"))
+print(snake_case("Hello Open Source!"))
+print(word_frequency("Python is great. Python is simple."))
+```
+
+## Testing
+
+The project uses **pytest** for automated testing and **pytest-cov** to measure test coverage.
+
+Run the complete test suite:
+
+```bash
+python -m pytest -q
+```
+
+Run the tests with a coverage report:
+
+```bash
+python -m pytest -q --cov=textutils --cov-report=term-missing
+```
+
+## Code Quality
+
+The project uses **Black** for consistent code formatting and **Ruff** for linting and static code analysis.
+
+Check formatting with Black:
+
+```bash
+python -m black --check .
+```
+
+Format the code automatically:
+
+```bash
+python -m black .
+```
+
+Check code quality with Ruff:
+
+```bash
+python -m ruff check .
+```
+
+These checks should pass before submitting a pull request.
+
+## Contributing
+
+Contributions are welcome!
+
+Before submitting a pull request, please:
+
+1. Add or update tests for any changes.
+2. Ensure all tests pass.
+3. Check the code with Black and Ruff.
+4. Follow the existing package structure and document public functions using NumPy-style docstrings.
+
+## License
+
+This project is licensed under the MIT License.

textutils_kit-0.0.1.dist-info/RECORD

@@ -0,0 +1,24 @@
+textutils/__init__.py,sha256=hYsSNiDdm3ctUhZjGC4xHOfhHjL8Zqkh0j1KlZDQ84Q,476
+textutils/casing/__init__.py,sha256=XSCtxlPi-fYECel0jBlpusjAIYn9vZbHPDMxEPepGKA,237
+textutils/casing/_camel_case.py,sha256=A3Z7MzZaKgV4Afo260GtXAuGZ_teh0ooV-eQG8Lzj5Y,378
+textutils/casing/_capitalize_words.py,sha256=xwhLFhLym7QH450w7UL5gJeZon63X2Pv6S90UxWcJsU,466
+textutils/casing/_snake_case.py,sha256=pZxbEUzafcZPO-5MDlZ94kqHWat-w8wSLysam9ysDDs,278
+textutils/casing/tests/test_camel_case.py,sha256=fD9GsRrbkzradli4OF7FggzLbi5TtDAZt9T0mMnFPoA,656
+textutils/casing/tests/test_capitalize_words.py,sha256=ArvX_yB6ISgxzX-IendnTLkvHRaG1Usm-wC7oHti46M,931
+textutils/casing/tests/test_snake_case.py,sha256=QZOneAo6LZy8yzxuFeVUV0nNmH9BjvFGBl8aO0ukR7Y,760
+textutils/counting/__init__.py,sha256=qpjKo2UWyfcLwc2HfhukGoi1N0N8V42IA97lf77xB2s,179
+textutils/counting/_character_count.py,sha256=DWUv0D8w6JZcx-NzzZQIPzCcaXTBLfwJ2nvTc0vB4fw,573
+textutils/counting/_word_count.py,sha256=PWWH4Vrx2pG2ZSRlHkyt4sZ7YjzFkhijnC6ohAubP7Q,292
+textutils/counting/tests/test_character_count.py,sha256=YGGpOfxPn4mRqawcSU42uEz39QeZgZjhY-ZOYe4al3k,1486
+textutils/counting/tests/test_word_count.py,sha256=HWn8xR7RGYmUv3IlWgHUOo1UCUCp7FsgnhuuX5W2B4g,568
+textutils/frequency/__init__.py,sha256=ptxHVvDt85NNfOrAbXmWvR_dLetjJwyTebufF7MgpXA,123
+textutils/frequency/_word_frequency.py,sha256=zR3bnNJkUhkK_pVAEusKUbOFDOkIkOS6CQjvKBmzAe0,4390
+textutils/frequency/tests/test_word_frequency.py,sha256=nJgUUhiTLDmeh-JUanBmPw-4As0CaGlLWn0hLJDb7pI,2142
+textutils/transform/__init__.py,sha256=Y6GVMMUyA3bIpXObWyO--D11rBLFrdLZ4Lz333N4Ra0,96
+textutils/transform/_reverse.py,sha256=7RhIm1NKQq0dQQD4h7HsV8K-DnGBtFb-1lz9QVyGvKQ,230
+textutils/transform/tests/test_reverse.py,sha256=YO-nmPnfUqsXpTS7J6sOLbKYLxCHioAJLPJbDdQ9Xog,471
+textutils_kit-0.0.1.dist-info/licenses/LICENSE,sha256=IYraf---0PfR3P3G-WPwtHLYBrncvUQOupLhY1JGPYw,1066
+textutils_kit-0.0.1.dist-info/METADATA,sha256=ix6SZEo6uXTRvENJMxcReRbHvZnbsucwNnNF2EiaNT0,2909
+textutils_kit-0.0.1.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+textutils_kit-0.0.1.dist-info/top_level.txt,sha256=amWgGsYwaWzVol7zPaWIjxj2Of6hEptj7rE9MR3bp_E,10
+textutils_kit-0.0.1.dist-info/RECORD,,

textutils_kit-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.2.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

textutils_kit-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Emilie-Th
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

textutils_kit-0.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+textutils