Upload src + bin with data visualizer (visualizer.py)

README.md

@@ -64,3 +64,96 @@ git clone https://huggingface.co/datasets/Alverciito/wikipedia_articles_es
 from datasets import load_from_disk
 
 ds = load_from_disk("wikipedia-es-A000")  # or A001 / A002
+```
+
+## 🔧 Dataset Construction Pipeline
+
+This dataset was generated in two main stages:
+
+### 1️⃣ Wikipedia Article Extraction (ZIM-based)
+
+Raw articles are extracted directly from an offline **Wikipedia ZIM file** using a custom extractor.
+Download the Spanish Wikipedia ZIM file [here](https://download.kiwix.org/zim/wikipedia_es_all_maxi.zim).
+
+
+The extraction process:
+- Randomly samples Wikipedia articles by internal index
+- Parses HTML content using **BeautifulSoup**
+- Extracts clean paragraph-level text
+- Optionally follows internal Wikipedia links (relation recursion)
+- Assigns unique document IDs
+
+Each extracted article contains:
+- `title`
+- `text` (list of paragraphs)
+- internal references (used only during extraction)
+
+This approach ensures:
+- No dependency on the live Wikipedia API
+- Full reproducibility from a fixed ZIM snapshot
+- High-throughput extraction suitable for large-scale datasets
+
+---
+
+### 2️⃣ Segmentation into Multi-Article Samples
+
+Extracted articles are converted into **segmented documents** using a controlled aggregation strategy.
+
+Segmentation rules:
+- Each sample contains **1 to 10 articles**
+- Articles are concatenated until a maximum paragraph limit is reached
+- Paragraphs are preserved as coherent textual units
+- Metadata is accumulated per segment
+
+Resulting metadata per sample:
+- `paragraphs`: total number of paragraphs
+- `words`: total word count
+- `articles`: number of Wikipedia articles combined
+- `title`: list of article titles
+- `text`: list of paragraph blocks (order preserved)
+
+This structure is designed for:
+- document-level classification
+- segmentation boundary detection
+- long-context language modeling
+- sentence and paragraph similarity tasks
+
+---
+
+## 📊 Dataset Statistics
+
+Each sample provides both **local** and **global** structural information:
+
+- Document length in paragraphs and words
+- Number of source articles per segment
+- Explicit title grouping for multi-article samples
+
+This enables models to reason about **structure and scale**, not just raw text.
+
+---
+
+## 🧪 Visualization & Exploration
+
+A **Gradio-based dataset explorer** is included for interactive inspection.
+
+Features:
+- Browse samples by index
+- View full segmented text with paragraph numbering
+- Inspect per-sample statistics
+- Visualize global distributions:
+  - Paragraph counts
+  - Word counts
+  - Articles per segment
+
+Typical use cases:
+- Dataset sanity checking
+- Length distribution analysis
+- Manual validation of segmentation quality
+
+---
+
+## ▶️ Running the data Visualizer
+
+```bash
+python bin/visualizer.py
+```

bin/extractor.py

@@ -0,0 +1,139 @@
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                                                           #
+#   This file was created by: Alberto Palomo Alonso         #
+# Universidad de Alcalá - Escuela Politécnica Superior      #
+#                                                           #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+"""
+Wikipedia ZIM extraction and segmentation script.
+
+Main workflow:
+1) Ask the user for a ZIM path and an identifier.
+2) Extract articles using `WikipediaExtractor`.
+3) Convert the extracted list to a Hugging Face `datasets.Dataset`.
+4) Post-process the dataset with `wiki_to_seg` (segmentation).
+5) Save the resulting dataset to disk and reload it.
+
+Notes:
+- This script assumes `src.WikipediaExtractor` and `src.wiki_to_seg` are available.
+- Output is saved under `./wikipedia-es-<identifier>`.
+"""
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                       IMPORT STATEMENTS                   #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+import logging
+import datasets
+from src import WikipediaExtractor, wiki_to_seg
+
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                        FUNCTION DEF                       #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+def setup_logger() -> logging.Logger:
+    """
+    Set up the logger for debugging.
+
+    Creates a module-level logger configured at DEBUG level with a StreamHandler.
+
+    Returns:
+        logging.Logger: Configured logger instance.
+
+    Notes:
+        If this function is called multiple times in the same process, it may attach
+        multiple handlers to the same logger. If that is undesirable in your runtime,
+        consider checking `logger.handlers` before adding a new handler.
+    """
+    logger = logging.getLogger(__name__)
+    logger.setLevel(logging.DEBUG)
+
+    handler = logging.StreamHandler()
+    handler.setLevel(logging.DEBUG)
+
+    formatter = logging.Formatter(
+        '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+    )
+    handler.setFormatter(formatter)
+
+    logger.addHandler(handler)
+    logger.debug('Debugging WikipediaExtractor')
+    return logger
+
+
+def extract(
+        zim_path: str,
+        relation_recursion: int = 0,
+        n_trials: int = 30_000
+) -> datasets.Dataset:
+    """
+    Extract Wikipedia articles from a ZIM file and return a Hugging Face Dataset.
+
+    Args:
+        zim_path (str):
+            Path to the Wikipedia ZIM file.
+        relation_recursion (int, optional):
+            Recursion depth for relation/link exploration (as implemented by
+            `WikipediaExtractor`). Defaults to 0.
+        n_trials (int, optional):
+            Trial/iteration budget for extraction (as implemented by the extractor).
+            Defaults to 30_000.
+
+    Returns:
+        datasets.Dataset:
+            A Hugging Face Dataset built from the extracted articles list.
+
+    Raises:
+        Any exception raised by `WikipediaExtractor` or `datasets.Dataset.from_list`.
+    """
+    extractor = WikipediaExtractor(
+        zim_path,
+        encoding='utf-8',
+        logger=setup_logger()
+    )
+
+    articles, _ = extractor.get_database(
+        relation_recursion=relation_recursion,
+        n_trials=n_trials,
+        from_cnt=0
+    )
+
+    hf_ds = datasets.Dataset.from_list(articles)
+    return hf_ds
+
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                           MAIN                            #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+if __name__ == '__main__':
+    """
+    Script entry point.
+
+    Prompts for user inputs, runs extraction + segmentation, saves the dataset to disk,
+    and reloads it at the end.
+
+    Inputs:
+        - Wikipedia (zim file) path
+        - Wikipedia identifier (e.g., B000)
+
+    Side effects:
+        - Creates `./wikipedia-es-<identifier>` containing the saved dataset.
+        - Reloads the dataset from disk into the `dataset` variable.
+    """
+    # Ask user for input data:
+    z_path = input("Wikipedia (zim file) path: ")
+    identifier = input("Wikipedia (Wikipedia identifier, e.g. B000): ")
+
+    # Pathing:
+    path_to_disk = rf'./wikipedia-es-{identifier}'
+    # Extract:
+    hf_pre_dataset = extract(z_path)
+    # Post-processing:
+    segmentation_dataset = wiki_to_seg(hf_pre_dataset, 50)
+    # Save the dataset:
+    segmentation_dataset.save_to_disk(path_to_disk)
+    # Load the dataset:
+    dataset = datasets.load_from_disk(path_to_disk)
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                        END OF FILE                        #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #

bin/visualizer.py

@@ -0,0 +1,207 @@
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                                                           #
+#   This file was created by: Alberto Palomo Alonso         #
+# Universidad de Alcalá - Escuela Politécnica Superior      #
+#                                                           #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+"""
+Gradio-based explorer for inspecting a segmented Wikipedia dataset.
+
+Main features:
+- Load a Hugging Face dataset from disk.
+- Compute global statistics for paragraphs, words, and articles.
+- Precompute histograms for dataset-level distributions.
+- Provide an interactive Gradio UI to browse individual samples and
+  visualize global statistics.
+
+Expected dataset fields:
+- id
+- text (list of paragraphs/segments)
+- paragraphs
+- words
+- articles
+- title
+"""
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                       IMPORT STATEMENTS                   #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+from datasets import load_from_disk
+
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                     STATISTICS UTILITIES                  #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+def compute_stats(arr: np.ndarray) -> dict:
+    """
+    Compute basic descriptive statistics for a numeric array.
+
+    Args:
+        arr (np.ndarray):
+            Input array of numeric values.
+
+    Returns:
+        dict:
+            Dictionary containing mean, median, standard deviation (sample),
+            minimum, and maximum values.
+    """
+    return {
+        'mean': float(np.mean(arr)),
+        'median': float(np.median(arr)),
+        'std': float(np.std(arr, ddof=1)),
+        'min': int(np.min(arr)),
+        'max': int(np.max(arr))
+    }
+
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                       PLOTTING UTILITIES                  #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+def make_histogram(arr: np.ndarray, title: str):
+    """
+    Create a histogram plot for a numeric array.
+
+    Args:
+        arr (np.ndarray):
+            Input array of numeric values.
+        title (str):
+            Title label for the histogram (used in title and x-axis).
+
+    Returns:
+        matplotlib.figure.Figure:
+            Matplotlib figure object containing the histogram.
+    """
+    fig, ax = plt.subplots()
+    ax.hist(arr, bins=30)
+    ax.set_title(f"Distribution of {title}")
+    ax.set_xlabel(title)
+    ax.set_ylabel("Count")
+    fig.tight_layout()
+    return fig
+
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                           MAIN                            #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+if __name__ == '__main__':
+    """
+    Script entry point.
+
+    Loads a dataset from disk, computes global statistics and histograms,
+    and launches a Gradio UI to interactively explore dataset samples.
+    """
+    # Load dataset
+    dataset_path = input('Enter dataset path: ')
+    ds = load_from_disk(dataset_path)
+
+    # Extract numeric arrays
+    paragraphs_arr = np.array(ds['paragraphs'], dtype=int)
+    words_arr = np.array(ds['words'], dtype=int)
+    articles_arr = np.array(ds['articles'], dtype=int)
+
+    # Compute global statistics
+    stats = {
+        'paragraphs': compute_stats(paragraphs_arr),
+        'words': compute_stats(words_arr),
+        'articles': compute_stats(articles_arr)
+    }
+
+    # Precompute histogram figures
+    par_plot_obj = make_histogram(paragraphs_arr, 'Paragraphs')
+    words_plot_obj = make_histogram(words_arr, 'Words')
+    articles_plot_obj = make_histogram(articles_arr, 'Articles')
+
+    # - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+    #                    GRADIO CALLBACK                      #
+    # - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+    def show(idx: int):
+        """
+        Retrieve and format a single dataset sample for display.
+
+        Args:
+            idx (int):
+                Index of the document in the dataset.
+
+        Returns:
+            tuple[str, str]:
+                - Formatted sample text and metadata.
+                - Formatted global statistics and current sample information.
+        """
+        sample = ds[int(idx)]
+        texto = "\n\n".join(
+            [f"{i}: {p}" for i, p in enumerate(sample["text"])]
+        )
+
+        sample_info = (
+            f"Doc ID: {sample['id']}"
+            f"\n\n{texto}"
+        )
+
+        stats_text = (
+            "Global Dataset Statistics:\n"
+            f"Paragraphs \t- mean: {stats['paragraphs']['mean']:.2f}, "
+            f"std: {stats['paragraphs']['std']:.2f}, "
+            f"min: {stats['paragraphs']['min']}, "
+            f"max: {stats['paragraphs']['max']}\n"
+            f"Words      \t- mean: {stats['words']['mean']:.2f}, "
+            f"std: {stats['words']['std']:.2f}, "
+            f"min: {stats['words']['min']}, "
+            f"max: {stats['words']['max']}\n"
+            f"Articles   \t- mean: {stats['articles']['mean']:.2f}, "
+            f"std: {stats['articles']['std']:.2f}, "
+            f"min: {stats['articles']['min']}, "
+            f"max: {stats['articles']['max']}\n"
+            f"\nCurrent Sample Information:\n"
+            f"\t- Doc ID: {sample['id']}\n"
+            f"\t- Paragraphs: {sample['paragraphs']}\n"
+            f"\t- Words: {sample['words']}\n"
+            f"\t- Articles: {sample['articles']}\n"
+            f"\t- Titles: {sample['title']}"
+        )
+        return sample_info, stats_text
+
+    # - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+    #                       GRADIO UI                          #
+    # - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+    with gr.Blocks(title="Wikipedia Extractor Explorer") as demo:
+        gr.Markdown("## Wikipedia Segmentation Explorer")
+
+        idx_slider = gr.Slider(
+            0, len(ds) - 1, step=1, label="Document Index"
+        )
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                sample_output = gr.Textbox(
+                    label="Sample Info", lines=20
+                )
+                stats_output = gr.Textbox(
+                    label="Global Statistics", lines=6
+                )
+            with gr.Column(scale=1):
+                gr.Plot(
+                    label="Paragraphs Histogram",
+                    value=par_plot_obj
+                )
+                gr.Plot(
+                    label="Words Histogram",
+                    value=words_plot_obj
+                )
+                gr.Plot(
+                    label="Articles Histogram",
+                    value=articles_plot_obj
+                )
+
+        idx_slider.change(
+            fn=show,
+            inputs=idx_slider,
+            outputs=[sample_output, stats_output]
+        )
+
+    demo.launch()
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                        END OF FILE                        #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #

src/__init__.py

@@ -0,0 +1,11 @@
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                                                           #
+#   This file was created by: Alberto Palomo Alonso         #
+# Universidad de Alcalá - Escuela Politécnica Superior      #
+#                                                           #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+from .zimclass import WikipediaExtractor
+from .wikipedia_to_segmentation import wiki_to_seg
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                        END OF FILE                        #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #

src/wikipedia_to_segmentation.py

@@ -0,0 +1,67 @@
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                                                           #
+#   This file was created by: Alberto Palomo Alonso         #
+# Universidad de Alcalá - Escuela Politécnica Superior      #
+#                                                           #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+# Import statements:
+import random
+import datasets
+
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                        FUNCTION DEF                       #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+def wiki_to_seg(dataset: datasets.Dataset, max_paragraphs: int) -> datasets.Dataset:
+    """
+    Converts a wikipedia dataset to a segmentation dataset.
+    :param dataset: A dataset with the structure {'title': str, 'text': list of str, 'id': str, 'paragraphs': int}.
+    :param max_paragraphs: Maximum number of paragraphs to segment.
+    :return: A dataset with the same structure as the original one, but with the text segmented.
+    """
+    # Initialize the dataset:
+    lines = list()
+    n_articles = random.randint(1, 10)
+    new_element = {'title': list(), 'text': list(), 'id': 'Unknown', 'paragraphs': 0, 'articles': 0, 'words': 0}
+
+    # Typing:
+    element: dict
+    idx: int
+    count: int = 0
+
+    # Iterate over the original dataset:
+    for idx, element in enumerate(dataset):
+        # Get the text:
+        paragraphs = element['text']
+        element_paragraphs = len(paragraphs)
+        if element_paragraphs + new_element['paragraphs'] > max_paragraphs:
+            # In case of exceeding max_paragraphs, we need to split the paragraphs:
+            paragraphs = paragraphs[:max_paragraphs - new_element['paragraphs']]
+
+        if paragraphs:
+            # Join the paragraphs
+            article_text = '\n'.join(paragraphs) + '\n'
+
+            # Add the paragraphs to the new element:
+            new_element['text'].append(article_text)
+            new_element['paragraphs'] += len(paragraphs)
+            new_element['title'].append(element['title'])
+            new_element['id'] = f'S0-{count:06}' if new_element['id'] == 'Unknown' else new_element['id']
+            new_element['words'] += len(article_text.split())
+
+            # If we reach the end of the generation:
+            new_element['articles'] += 1
+
+        if (new_element['articles'] == n_articles or idx == len(dataset) - 1
+                or max_paragraphs <= new_element['paragraphs']):
+            n_articles = random.randint(1, 10)
+            lines.append(new_element)
+            new_element = {'title': list(), 'text': list(), 'id': 'Unknown', 'paragraphs': 0, 'articles': 0, 'words': 0}
+            count += 1
+
+    # Convert to the dataset:
+    new_dataset = datasets.Dataset.from_list(lines)
+    return new_dataset
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                        END OF FILE                        #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #

src/zimclass.py

@@ -0,0 +1,190 @@
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                                                           #
+#   This file was created by: Alberto Palomo Alonso         #
+# Universidad de Alcalá - Escuela Politécnica Superior      #
+#                                                           #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+# Import statements:
+import logging
+import zimply
+import os
+import bs4
+import random
+import re
+import tqdm
+
+
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                        MAIN CLASS                         #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+class WikipediaExtractor:
+    def __init__(self,
+                 wikipedia_path: str,
+                 encoding: str = 'utf-8',
+                 find: tuple = ('p',),
+                 logger: logging.Logger = None,
+                 seed: int = None,
+        ):
+        """
+        :param wikipedia_path: Path to the Wikipedia ZIM file.
+        :param encoding: Encoding of the ZIM file. Default is 'utf-8'.
+        :param find: The elements of the article to find, refer to BS4.
+        :param logger: Logger object for logging. Default is None.
+        :param seed: Seed for random number generator. Default is None.
+        """
+        # Error handlers:
+        if not os.path.exists(wikipedia_path):
+            raise FileNotFoundError(f"File {wikipedia_path} does not exist.")
+
+        self.zim = zimply.zimply.ZIMFile(wikipedia_path, encoding=encoding)
+        self.logger = logger or logging.getLogger(__name__)
+        self.find = find
+        self.magic_min = 78
+        self.magic_max = 4_113_686
+
+        # Random seed:
+        random.seed(seed)
+
+        # Avoid repetition:
+        self.stacked_refs = {'Wikidata', 'Wikimedia_Commons', 'ISSN'}
+        self.logger.info(f'WikipediaExtractor initialized.')
+
+    def get_database(self, relation_recursion: int = 0, n_trials: int = 100_000, from_cnt: int = 0):
+        """
+        Gets the database of articles.
+        :param relation_recursion: Relation recursion. Default is 0.
+        :param n_trials: Number of trials to get articles. Default is 100_000.
+        :param from_cnt: Count of articles. Default is 0.
+        :return: A list of related (or not) articles and the successful count.
+        """
+        # Recursion level 0:
+        articles = list()
+        cnt = from_cnt
+
+        # Loop through the number of trials:
+        for _ in tqdm.tqdm(range(n_trials), desc='Article extraction', unit='article'):
+            article = self.get(relation_recursion=relation_recursion)
+            # Check if the article is valid:
+            if article is not None:
+                for entry in article:
+                    if entry is not None:
+                        cnt += 1
+                        entry['id'] = f'L0-{cnt:06}'
+                        articles.append(entry)
+
+        return articles, cnt
+
+    def get(self, relation_recursion: int = 0, generation_policy: str = 'kill'):
+        """
+        Gets a random article from wikipedia. Gets a random related article per relation_recursion given.
+        :param relation_recursion: Relation recursion. Default is 0.
+        :param generation_policy: Tells continuing if there is no relationship recursion. Default is 'kill':
+            'kill': Stops generation and returns None
+            'warn': Logs a warning and returns the current generation.
+            'ignore': Ignores the article and returns the current generation.
+        :return: A list of Articles.
+        """
+        articles = list()
+        # Random number between min and max:
+        random_index = random.randint(self.magic_min, self.magic_max)
+        articles.append(self.__get_article_by_index(random_index))
+        # Get recursion:
+        for recursion in range(relation_recursion):
+            # Gather last refs:
+            last_refs = articles[-1]['refs']
+            # Check if there are valid references:
+            if last_refs:
+                # Get the random related article:
+                random_choice = random.choice(last_refs)
+                articles.append(self.__get_article_by_url(random_choice))
+            elif generation_policy == 'kill':
+                self.logger.error(f'Generation at iteration {recursion + 1} stoped due to lack of references.')
+                return None
+            elif generation_policy == 'warn':
+                self.logger.warning(f'Generation at iteration {recursion + 1} stoped due to lack of references.')
+                return articles
+            elif generation_policy == 'ignore':
+                return articles
+        # Return the articles:
+        return articles
+
+    def __get_article_by_index(self, index: int, astype: type = dict):
+        """
+        Gets an article by its index.
+        :param index: Index of the article.
+        :param astype: Type of the return article. Dictionary or article.
+        :return:
+        """
+        if index < self.magic_min or index > self.magic_max:
+            raise IndexError(f"Index {index} is out of range [{self.magic_min}, {self.magic_max}].")
+        # Read the entry:
+        dict_entry = self.zim.read_directory_entry_by_index(index)
+        # Get the article:
+        return self.__get_article_by_url(dict_entry['url'], astype=astype)
+
+    def __get_article_by_url(self, url: str, astype: type = dict):
+        """
+        Get article by url
+        :param url: The url of the article.
+        :param astype: Type of the return article. Dictionary or article.
+        :return:
+        """
+        # Gather article:
+        article = self.zim.get_article_by_url('A', url)
+        if article is None:
+            logging.error(f'Article {url} not found, skipping...')
+            return None
+        # Avoid loops and using the same article twice from references:
+        self.stacked_refs.add(url)
+        # Convert to format:
+        return self.__article_to_dict(article, self.stacked_refs, self.find) if astype == dict else article
+
+    @staticmethod
+    def __article_to_dict(article: zimply.zimply.Article,
+                          stacked_refs: set,
+                          find: tuple = ('p',)) -> dict:
+        """
+        Converts an article into a dictionary.
+        :param article: Article to convert.
+        :param stacked_refs: Stacked references of the article to avoid.
+        :param find: Elements of the article to find, refer to BS4.
+        :return: A dictionary.
+        """
+        # Extract HTML:
+        html = article.data.decode('utf-8')
+        soup = bs4.BeautifulSoup(html, 'html.parser')
+
+        # Title extraction:
+        page_title = soup.find('title').text.strip()
+
+        # Paragraphs extraction:
+        paragraphs = soup.find_all(find)
+        text = [re.sub(r'\s+', ' ', re.sub(r'\[\d+]', '', p.get_text())).strip()
+                for p in paragraphs if p.get_text(strip=True)]
+
+
+        # Extraer referencias internas
+        internal_refs = list()
+        for a in soup.find_all('a', href=True):
+            href = a['href']
+            title = a.get('title')
+            if (
+                    href.startswith('/') is False and  # Avoid external links
+                    '://' not in href and  # Avoid internal links
+                    title and len(title) > 1  and # Can be read
+                    '%' not in href and # Is valid (% is invalid)
+                    '#' not in href and # Is valid (# is invalid)
+                    '.svg' not in href and # SVG are along with refs.
+                    href not in stacked_refs # Avoid loops
+            ):
+                internal_refs.append(href)
+
+        # Return as dictionary:
+        return {
+            'title': page_title,
+            'text': text,
+            'refs': internal_refs
+        }
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #
+#                        END OF FILE                        #
+# - x - x - x - x - x - x - x - x - x - x - x - x - x - x - #