rp-segmentation 0.1.0__py3-none-any.whl

rp_segmentation/__init__.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from importlib.metadata import PackageNotFoundError, version
+
+from rp_segmentation.nltk_resources import ensure_required_nltk_resources
+from rp_segmentation.segmenters import (
+    get_tokens,
+    n_stop_words_segmentation,
+    paragraph_segmentation,
+    sentence_segmentation,
+)
+
+try:
+    __version__ = version("rp-segmentation")
+except PackageNotFoundError:
+    __version__ = "0.1.0"
+
+
+__all__ = (
+    "__version__",
+    "ensure_required_nltk_resources",
+    "get_tokens",
+    "sentence_segmentation",
+    "paragraph_segmentation",
+    "n_stop_words_segmentation",
+)

rp_segmentation/exceptions.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+
+class RPSegmentationError(Exception):
+    """
+    Base exception for all errors raised by the rp_segmentation package.
+
+    This exception can be used to catch any package-specific error without
+    catching unrelated built-in Python exceptions.
+    """
+
+
+class InvalidSegmentationParameterError(RPSegmentationError):
+    """
+    Raised when an invalid segmentation parameter is provided.
+
+    Examples include empty language values, unsupported parameter values,
+    non-positive segmentation thresholds, or texts that cannot be segmented
+    according to the selected strategy.
+    """
+
+
+class NLTKResourceError(RPSegmentationError):
+    """
+    Raised when a required external NLTK resource is missing or cannot be loaded.
+
+    This exception is used when the package cannot find, download, or access
+    resources such as tokenizers or stopword corpora required for text
+    processing.
+    """
+
+
+__all__ = (
+    "RPSegmentationError",
+    "InvalidSegmentationParameterError",
+    "NLTKResourceError",
+)

rp_segmentation/nltk_resources.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from functools import cache
+from types import MappingProxyType
+from typing import Final, NoReturn
+from zipfile import BadZipFile
+
+import nltk
+
+from rp_segmentation.exceptions import NLTKResourceError
+
+NLTK_RESOURCES: Final[Mapping[str, str]] = MappingProxyType(
+    {
+        "punkt_tab": "tokenizers/punkt_tab",
+        "stopwords": "corpora/stopwords",
+    }
+)
+
+
+def _supported_resources_message() -> str:
+    return ", ".join(sorted(NLTK_RESOURCES))
+
+
+def _recovery_hint(resource_name: str) -> str:
+    return f"Try running: python -m nltk.downloader {resource_name}"
+
+
+def _raise_corrupted_resource_error(
+    resource_name: str,
+    exc: BadZipFile,
+    *,
+    after_download: bool = False,
+) -> NoReturn:
+    moment = " after download" if after_download else ""
+
+    raise NLTKResourceError(
+        f"The NLTK resource appears to be corrupted{moment}: {resource_name}. "
+        f"Try deleting the local NLTK resource and running: "
+        f"python -m nltk.downloader {resource_name}"
+    ) from exc
+
+
+def _resource_exists(resource_name: str, resource_path: str) -> bool:
+    try:
+        nltk.data.find(resource_path)
+        return True
+
+    except LookupError:
+        return False
+
+    except BadZipFile as exc:
+        _raise_corrupted_resource_error(resource_name, exc)
+
+
+@cache
+def ensure_nltk_resource(resource_name: str) -> None:
+    """
+    Ensures that a required NLTK resource is available.
+
+    If the resource is missing, the function attempts to download it
+    automatically. If the resource is corrupted or cannot be downloaded,
+    a package-specific error is raised with a clear recovery message.
+
+    Parameters
+    ----------
+    resource_name:
+        Name of the NLTK resource. Example: 'punkt_tab'.
+
+    Raises
+    ------
+    NLTKResourceError
+        If the resource is unsupported, missing, corrupted, or cannot be
+        downloaded.
+    """
+    resource_path = NLTK_RESOURCES.get(resource_name)
+
+    if resource_path is None:
+        raise NLTKResourceError(
+            f"Unsupported NLTK resource for rp_segmentation: {resource_name}. "
+            f"Supported resources are: {_supported_resources_message()}."
+        )
+
+    if _resource_exists(resource_name, resource_path):
+        return
+
+    try:
+        downloaded = nltk.download(resource_name, quiet=True)
+
+    except BadZipFile as exc:
+        _raise_corrupted_resource_error(resource_name, exc, after_download=True)
+
+    except Exception as exc:
+        raise NLTKResourceError(
+            f"Could not download the NLTK resource: {resource_name}. "
+            f"{_recovery_hint(resource_name)}"
+        ) from exc
+
+    if not downloaded:
+        raise NLTKResourceError(
+            f"Could not download the NLTK resource: {resource_name}. "
+            f"{_recovery_hint(resource_name)}"
+        )
+
+    try:
+        nltk.data.find(resource_path)
+
+    except BadZipFile as exc:
+        _raise_corrupted_resource_error(resource_name, exc, after_download=True)
+
+    except Exception as exc:
+        raise NLTKResourceError(
+            f"The NLTK resource was downloaded but could not be located: "
+            f"{resource_name}. {_recovery_hint(resource_name)}"
+        ) from exc
+
+
+def ensure_required_nltk_resources() -> None:
+    """
+    Ensures that all NLTK resources required by the package are available.
+    """
+    for resource_name in NLTK_RESOURCES:
+        ensure_nltk_resource(resource_name)

rp_segmentation/segmenters.py

@@ -0,0 +1,395 @@
+from __future__ import annotations
+
+from functools import cache
+from typing import cast
+
+import regex as re
+from nltk.corpus import stopwords
+from nltk.tokenize import sent_tokenize
+
+from rp_segmentation.exceptions import InvalidSegmentationParameterError
+from rp_segmentation.nltk_resources import ensure_nltk_resource
+
+WORD_RE = re.compile(r"\p{L}+")
+
+
+def _normalize_text(text: str) -> str:
+    """
+    Normalizes leading and trailing whitespace while preserving the internal
+    structure of the text.
+
+    Parameters
+    ----------
+    text:
+        Input text.
+
+    Returns
+    -------
+    str
+        Normalized text.
+
+    Raises
+    ------
+    TypeError
+        If the input value is not a string.
+    """
+    if not isinstance(text, str):
+        raise TypeError("The input text must be a string.")
+
+    return text.strip()
+
+
+def _validate_language(language: str) -> str:
+    """
+    Validates and normalizes the language parameter.
+
+    Parameters
+    ----------
+    language:
+        Language identifier used by NLTK.
+
+    Returns
+    -------
+    str
+        Normalized language value.
+
+    Raises
+    ------
+    InvalidSegmentationParameterError
+        If the language value is invalid.
+    """
+    if not isinstance(language, str) or not language.strip():
+        raise InvalidSegmentationParameterError(
+            "The language parameter must be a non-empty string."
+        )
+
+    return language.strip().lower()
+
+
+@cache
+def _get_stopwords(language: str) -> frozenset[str]:
+    """
+    Loads and caches stopwords for the selected language.
+
+    Parameters
+    ----------
+    language:
+        Language used to retrieve NLTK stopwords.
+
+    Returns
+    -------
+    frozenset[str]
+        Cached set of stopwords.
+
+    Raises
+    ------
+    InvalidSegmentationParameterError
+        If stopwords are not available for the selected language.
+    """
+    language = _validate_language(language)
+
+    ensure_nltk_resource("stopwords")
+
+    try:
+        return frozenset(stopwords.words(language))
+
+    except OSError as exc:
+        raise InvalidSegmentationParameterError(
+            f"Stopwords are not available for language: {language}."
+        ) from exc
+
+
+def get_tokens(
+    text: str,
+    language: str = "english",
+    remove_stopwords: bool = False,
+) -> list[str]:
+    """
+    Extracts lowercase word tokens from a text.
+
+    The tokenizer keeps Unicode letter characters and discards numbers,
+    punctuation marks, symbols, and empty values.
+
+    Parameters
+    ----------
+    text:
+        Input text.
+    language:
+        Language used when stopword removal is enabled.
+        Default is 'english'.
+    remove_stopwords:
+        Whether to remove stopwords from the resulting tokens.
+        Default is False.
+
+    Returns
+    -------
+    list[str]
+        List of lowercase word tokens.
+
+    Examples
+    --------
+    >>> get_tokens("Hello, John. How are you?")
+    ['hello', 'john', 'how', 'are', 'you']
+
+    >>> get_tokens("Hello, John. How are you?", remove_stopwords=True)
+    ['hello', 'john']
+    """
+    clean_text = _normalize_text(text)
+
+    if not clean_text:
+        return []
+
+    tokens = cast(list[str], WORD_RE.findall(clean_text.lower()))
+
+    if not remove_stopwords:
+        return tokens
+
+    stop_words = _get_stopwords(language)
+
+    return [token for token in tokens if token not in stop_words]
+
+
+def _clean_segment(
+    text: str,
+    language: str = "english",
+    remove_stopwords: bool = False,
+) -> str:
+    """
+    Applies the package's canonical text normalization strategy to a segment
+    and returns the result as a single whitespace-normalized string.
+
+    Parameters
+    ----------
+    text:
+        Input sentence or paragraph.
+    language:
+        Language used when stopword removal is enabled.
+        Default is 'english'.
+    remove_stopwords:
+        Whether to remove stopwords from the resulting segment.
+        Default is False.
+
+    Returns
+    -------
+    str
+        Normalized segment.
+
+    Examples
+    --------
+    >>> _clean_segment("Hello, John. How are you?")
+    'hello john how are you'
+
+    >>> _clean_segment("Hello, John. How are you?", remove_stopwords=True)
+    'hello john'
+    """
+    return " ".join(
+        get_tokens(
+            text,
+            language=language,
+            remove_stopwords=remove_stopwords,
+        )
+    )
+
+
+def sentence_segmentation(
+    text: str,
+    language: str = "english",
+    remove_stopwords: bool = False,
+) -> list[str]:
+    """
+    Segments a text into sentences and normalizes each resulting segment.
+
+    The function validates and normalizes the input text, ensures that the
+    required NLTK tokenizer resource is available, detects sentence boundaries
+    using the selected language, and discards empty segments after
+    normalization.
+
+    Parameters
+    ----------
+    text:
+        Input text to be segmented.
+    language:
+        Language used by NLTK for sentence boundary detection.
+        Default is 'english'.
+    remove_stopwords:
+        Whether to remove stopwords from each normalized sentence.
+        Default is False.
+
+    Returns
+    -------
+    list[str]
+        List of normalized sentence segments.
+
+    Examples
+    --------
+    >>> segment_sentences("Hello, John. How are you?")
+    ['hello john', 'how are you']
+
+    >>> segment_sentences("Hello, John. How are you?", remove_stopwords=True)
+    ['hello john']
+    """
+    language = _validate_language(language)
+
+    clean_text = _normalize_text(text)
+
+    if not clean_text:
+        return []
+
+    ensure_nltk_resource("punkt_tab")
+
+    sentences = sent_tokenize(clean_text, language=language)
+
+    return [
+        cleaned_sentence
+        for sentence in sentences
+        if (
+            cleaned_sentence := _clean_segment(
+                sentence,
+                language=language,
+                remove_stopwords=remove_stopwords,
+            )
+        )
+    ]
+
+
+def paragraph_segmentation(
+    text: str,
+    language: str = "english",
+    remove_stopwords: bool = False,
+) -> list[str]:
+    """
+    Segments a text into paragraphs and normalizes each resulting segment.
+
+    Paragraph boundaries are detected using double or multiple line breaks.
+    Each paragraph is normalized, and empty segments produced after
+    normalization are discarded.
+
+    Parameters
+    ----------
+    text:
+        Input text to be segmented.
+    language:
+        Language used when stopword removal is enabled.
+        Default is 'english'.
+    remove_stopwords:
+        Whether to remove stopwords from each normalized paragraph.
+        Default is False.
+
+    Returns
+    -------
+    list[str]
+        List of normalized paragraph segments.
+
+    Examples
+    --------
+    >>> segment_paragraphs("First paragraph.\\n\\nSecond paragraph.")
+    ['first paragraph', 'second paragraph']
+
+    >>> segment_paragraphs(
+        "This is the first paragraph.\\n\\nThis is another one.",
+        remove_stopwords=True
+    )
+    ['first paragraph', 'another one']
+    """
+    language = _validate_language(language)
+
+    clean_text = _normalize_text(text)
+
+    if not clean_text:
+        return []
+
+    paragraphs = re.split(r"\n\s*\n+", clean_text)
+
+    return [
+        cleaned_paragraph
+        for paragraph in paragraphs
+        if (
+            cleaned_paragraph := _clean_segment(
+                paragraph,
+                language=language,
+                remove_stopwords=remove_stopwords,
+            )
+        )
+    ]
+
+
+def n_stop_words_segmentation(
+    text: str, language: str = "english", n: int = 5, remove_stopwords: bool = False
+) -> list[str]:
+    """
+    A text is segmented every N stop words.
+
+    Parameters
+    ----------
+    text:
+        Input text to be segmented.
+    language:
+        Language used when stopword removal is enabled.
+        Default is 'english'.
+    n:
+        Number of stop words after which to segment the text.
+        Default is 5.
+    remove_stopwords:
+        Whether to remove stopwords from each segment.
+        Default is False.
+
+    Returns
+    -------
+    list[str]
+        List of segments created every N stop words.
+
+    """
+
+    language = _validate_language(language)
+
+    clean_text = _normalize_text(text)
+
+    if not clean_text:
+        return []
+
+    if n <= 0:
+        raise InvalidSegmentationParameterError(
+            "The number of stopwords must be greater than zero."
+        )
+
+    tokens = get_tokens(text)
+
+    n_tokens = len(tokens)
+
+    if n_tokens <= 0:
+        raise InvalidSegmentationParameterError(
+            "The number of tokens must be greater than zero."
+        )
+
+    stop_words = _get_stopwords(language)
+
+    stopword_count = sum(1 for token in tokens if token in stop_words)
+
+    if stopword_count / n_tokens < 0.2:
+        raise InvalidSegmentationParameterError(
+            "The text does not contain enough stopwords to be segmented."
+        )
+
+    segments = []
+    current_tokens = []
+    current_stopword_count = 0
+
+    for token in tokens:
+        if not remove_stopwords or token not in stop_words:
+            current_tokens.append(token)
+
+        if token in stop_words:
+            current_stopword_count += 1
+
+            if current_stopword_count == n:
+                if current_tokens:
+                    segments.append(" ".join(current_tokens))
+
+                current_tokens = []
+
+                current_stopword_count = 0
+
+    if current_tokens:
+        segments.append(" ".join(current_tokens).strip())
+
+    return segments

rp_segmentation-0.1.0.dist-info/METADATA

@@ -0,0 +1,341 @@
+Metadata-Version: 2.4
+Name: rp-segmentation
+Version: 0.1.0
+Summary: A lightweight text segmentation and tokenization library for Python.
+Author-email: Pablo Nicolás Ramos <pablonicolasramos.90@gmail.com>, Ricardo Daniel Perez <sanexto@gmail.com>
+Maintainer-email: Pablo Nicolás Ramos <pablonicolasramos.90@gmail.com>, Ricardo Daniel Perez <sanexto@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/pablonicolasr/rp_segmentation
+Project-URL: Repository, https://github.com/pablonicolasr/rp_segmentation
+Project-URL: Issues, https://github.com/pablonicolasr/rp_segmentation/issues
+Project-URL: Changelog, https://github.com/pablonicolasr/rp_segmentation/blob/main/CHANGELOG.md
+Keywords: nlp,nltk,tokenization,text-processing,text-segmentation,natural-language-processing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Text Processing :: Linguistic
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nltk<4.0,>=3.9
+Requires-Dist: regex>=2024.0.0
+Provides-Extra: dev
+Requires-Dist: build>=1.2.0; extra == "dev"
+Requires-Dist: mypy>=1.10.0; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: ruff>=0.5.0; extra == "dev"
+Requires-Dist: twine>=5.0.0; extra == "dev"
+Requires-Dist: types-regex>=2024.0.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: mkdocs<2.0.0,>=1.6.0; extra == "docs"
+Requires-Dist: mkdocs-material<10.0.0,>=9.5.0; extra == "docs"
+Dynamic: license-file
+
+# rp-segmentation
+
+`rp-segmentation` is a lightweight Python library for text segmentation, token normalization, and NLP-oriented preprocessing.
+
+The package provides a simple and consistent API for splitting text into meaningful units, including sentences, paragraphs, and stopword-based segments. It is designed for text processing pipelines, NLP experimentation, semantic search, retrieval-augmented generation, and document preprocessing workflows.
+
+## Features
+
+* Sentence segmentation using NLTK.
+* Paragraph segmentation based on structural line breaks.
+* Stopword-based segmentation every `N` stopwords.
+* Unicode-aware token extraction.
+* Optional stopword removal.
+* Typed package support through `py.typed`.
+* Lightweight and easy to integrate into NLP pipelines.
+
+## Installation
+
+```bash
+pip install rp-segmentation
+```
+
+## Requirements
+
+* Python 3.10 or higher.
+* NLTK.
+* regex.
+
+## NLTK Resources
+
+`rp-segmentation` relies on external NLTK resources for sentence tokenization and stopword handling.
+
+You can install the required resources manually:
+
+```bash
+python -m nltk.downloader punkt_tab
+python -m nltk.downloader stopwords
+```
+
+Or install them directly from Python:
+
+```python
+from rp_segmentation import ensure_required_nltk_resources
+
+ensure_required_nltk_resources()
+```
+
+## Basic Usage
+
+```python
+from rp_segmentation import (
+    sentence_segmentation,
+    paragraph_segmentation,
+    n_stop_words_segmentation,
+)
+
+text = """
+Hello, Pablo. This is a simple test.
+
+This is another paragraph with additional content.
+It can be used for text processing workflows.
+"""
+
+print(sentence_segmentation(text))
+print(paragraph_segmentation(text))
+print(n_stop_words_segmentation(text, n=3))
+```
+
+## Available Methods
+
+### `sentence_segmentation`
+
+```python
+sentence_segmentation(
+    text: str,
+    language: str = "english",
+    remove_stopwords: bool = False,
+) -> list[str]
+```
+
+Segments a text into sentences using NLTK and applies the package's internal normalization strategy to each resulting segment.
+
+#### Example
+
+```python
+from rp_segmentation import sentence_segmentation
+
+text = "Hello, John. How are you?"
+
+segments = sentence_segmentation(text)
+
+print(segments)
+```
+
+Output:
+
+```python
+["hello john", "how are you"]
+```
+
+With stopword removal:
+
+```python
+segments = sentence_segmentation(
+    text,
+    language="english",
+    remove_stopwords=True,
+)
+
+print(segments)
+```
+
+Output:
+
+```python
+["hello john"]
+```
+
+---
+
+### `paragraph_segmentation`
+
+```python
+paragraph_segmentation(
+    text: str,
+    language: str = "english",
+    remove_stopwords: bool = False,
+) -> list[str]
+```
+
+Segments a text into paragraphs using double or multiple line breaks. Each paragraph is normalized before being returned.
+
+#### Example
+
+```python
+from rp_segmentation import paragraph_segmentation
+
+text = "First paragraph.\n\nSecond paragraph."
+
+segments = paragraph_segmentation(text)
+
+print(segments)
+```
+
+Output:
+
+```python
+["first paragraph", "second paragraph"]
+```
+
+---
+
+### `n_stop_words_segmentation`
+
+```python
+n_stop_words_segmentation(
+    text: str,
+    language: str = "english",
+    n: int = 5,
+    remove_stopwords: bool = False,
+) -> list[str]
+```
+
+Segments a text every `N` stopwords. This strategy is useful when working with natural language texts where stopword distribution can help define semantic or syntactic boundaries.
+
+#### Example
+
+```python
+from rp_segmentation import n_stop_words_segmentation
+
+text = "Alpha the beta and gamma is delta of omega."
+
+segments = n_stop_words_segmentation(
+    text,
+    language="english",
+    n=2,
+)
+
+print(segments)
+```
+
+Output:
+
+```python
+[
+    "alpha the beta and",
+    "gamma is delta of",
+    "omega",
+]
+```
+
+With stopword removal:
+
+```python
+segments = n_stop_words_segmentation(
+    text,
+    language="english",
+    n=2,
+    remove_stopwords=True,
+)
+
+print(segments)
+```
+
+Output:
+
+```python
+[
+    "alpha beta",
+    "gamma delta",
+    "omega",
+]
+```
+
+## Use Cases
+
+`rp-segmentation` can be used in a wide range of text processing tasks, including:
+
+* Natural Language Processing.
+* Text normalization.
+* Document preprocessing.
+* Semantic search.
+* Embedding preparation.
+* Retrieval-Augmented Generation pipelines.
+* Educational and research-oriented NLP projects.
+
+## Local Development
+
+Clone the repository:
+
+```bash
+git clone https://github.com/pablonicolasr777/rp-segmentation.git
+cd rp-segmentation
+```
+
+Create and activate a virtual environment:
+
+```bash
+python -m venv .venv
+.venv\Scripts\Activate.ps1
+```
+
+Install the package with development dependencies:
+
+```bash
+pip install -e ".[dev]"
+```
+
+Install the required NLTK resources:
+
+```bash
+python -m nltk.downloader punkt_tab
+python -m nltk.downloader stopwords
+```
+
+Run code quality checks:
+
+```bash
+ruff check .
+mypy src
+pytest --cov=rp_segmentation --cov-report=term-missing
+```
+
+## Project Structure
+
+```text
+rp-segmentation/
+├── src/
+│   └── rp_segmentation/
+│       ├── __init__.py
+│       ├── segmenters.py
+│       ├── nltk_resources.py
+│       ├── exceptions.py
+│       └── py.typed
+├── tests/
+│   └── test_segmenters.py
+├── docs/
+├── .github/
+│   └── workflows/
+│       ├── ci.yml
+│       └── publish.yml
+├── README.md
+├── CHANGELOG.md
+├── CONTRIBUTING.md
+├── SECURITY.md
+├── LICENSE
+├── pyproject.toml
+├── requirements-dev.txt
+└── .gitignore
+```
+
+## Authors
+
+* Pablo Nicolás Ramos
+* Ricardo Daniel Perez
+
+## License
+
+This project is licensed under the MIT License.

rp_segmentation-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+rp_segmentation/__init__.py,sha256=axOooewzkbk6ApbBJXE1mLXbb6fuIxD-zwD4Iccym3A,606
+rp_segmentation/exceptions.py,sha256=sCdXAT8zulINoIK-gaipzcCPbCPXMCaz7podmkgFtVs,1045
+rp_segmentation/nltk_resources.py,sha256=VuHm8n7UMmLmxmhwC8Pxa_0g_h5-OdXfOHqTRBPCNTY,3476
+rp_segmentation/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+rp_segmentation/segmenters.py,sha256=T7zhwIarx0Y6qkYnd_PYiiwetdvikWxWhT6gUV7VTrY,9454
+rp_segmentation-0.1.0.dist-info/licenses/LICENSE,sha256=RRGZoHMerRt3n08cFCuM281l7NzGNkcKwl6q634zugI,1097
+rp_segmentation-0.1.0.dist-info/METADATA,sha256=GCgj8-gZDrkMNnpTZ85Hah-u2Xnk4mS91fw2JlFIoRU,7587
+rp_segmentation-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+rp_segmentation-0.1.0.dist-info/top_level.txt,sha256=LZbx_li_bxf9E4N6nRyTN7HDuFNRnrFuXIYRFt1wG0I,16
+rp_segmentation-0.1.0.dist-info/RECORD,,

rp_segmentation-0.1.0.dist-info/WHEEL

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

rp_segmentation-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pablo Nicolás Ramos and Ricardo Daniel Perez
+
+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.

rp_segmentation-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rp_segmentation