dedup_raw_wiki_data.py

# %%
'''
Script on Cleansing Wikipedia Data that has been extracted from extract_raw_wiki_data.py
'''
#core functionality modules
import os, gc
import logging
import argparse
import warnings

from functools import partial

#text preprocess modules
import re
import urllib
from xml.etree import ElementTree as ET

#dataset related modules
import numpy as np
import pandas as pd


### MODULES DEFINITION ###
#create custom type-checking of incoming ArgParse
def argparse_bool_check(value: str):
    #cast str with value like float into actual float
    try:
        value = float(value)
    #can't be parsed as float, keep as it is
    except ValueError:
        pass

    #cast float-like value (incl int) into str
    if isinstance(value, float) and int(value) == value:
        value = str(int(value))
    #raise ArgumentTypeError if the value isn't in string already
    else:
        if not isinstance(value, str):
            raise argparse.ArgumentTypeError(f"Not the correct value (args: {value})! Expected is cast-able to '1' or '0' or already in string. Please rectify!")
    #check for these combinations of values
    if value.lower() in ("yes", "true", "t", "y", "1"):
        return True
    elif value.lower() in ("no", "false", "f", "n", "0"):
        return False
    else:
        raise argparse.ArgumentTypeError(f"Value Error! Not the correct value (args: {value})! Please rectify!")


def text_processing_args_checker(value: str):
    if value not in ["all", "text", "title", "neither"]:
        raise argparse.ArgumentTypeError(f"Value Error! Not the correct value (args: {value})! Please rectify!")
    else:
        return value


def set_logger():
    # Set up the logger
    logging.basicConfig(
        level=logging.INFO,  # Set the desired logging level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
        format='%(asctime)s [%(levelname)s]: %(message)s',  # Customize the log message format
        datefmt='%Y-%m-%d %H:%M:%S'  # Customize the date/time format
    )

    # Create a file handler to write logs into a file
    file_handler = logging.FileHandler('app.log')

    # Set the log level for the file handler
    file_handler.setLevel(logging.INFO) 

    # Create a formatter for the file handler (customize the log format for the file)
    file_formatter = logging.Formatter('%(asctime)s [%(levelname)s]: %(message)s', datefmt='%Y-%m-%d %H:%M:%S')
    file_handler.setFormatter(file_formatter)

    logger = logging.getLogger("Wiki Dataset Generation")
    logger.addHandler(file_handler)

    return logger


#wrapper fn of text-cleansing
def text_cleansing_wrapper(fn, exception_class_names = []):

    #ensure caught exception class names passed to decorator is a list (if provided)
    if not isinstance(exception_class_names, list):
        raise TypeError("Exception Class Name for Wrapper is not a list!")
    #ensure all values of caught exception class name list is a string
    if not all([isinstance(val, str) for val in exception_class_names]):
        raise ValueError("Found an element of Exception Class Name for Wrapper that is not a string!")

    #lowercase all exception class name
    exception_class_names = [val.lower() for val in exception_class_names]
    if len(exception_class_names) == 0:
        warnings.warn("The wrapper receives 0 `exception_class_names` to be warned! Will return the function value with its input!")

    def text_fn_wrapper(text: str, *args, **kwargs):
        try:
            return fn(text, *args, **kwargs)
        except Exception as e:
            _exc_name = type(e).__name__
            if _exc_name.lower() not in exception_class_names and len(exception_class_names)>0:
                raise Exception(f"Exception Occured of {_exc_name} in {fn.__name__}!") from e
            else:
                _followup_msg = "Returning the input as it is..."
                _text_warn = f"An exception of {_exc_name} occured in {fn.__name__}! {_followup_msg}"
                warnings.warn(_text_warn)
                return text

    return text_fn_wrapper


#create html tags cleanser of a given text
partial_decorator = partial(text_cleansing_wrapper, exception_class_names=["parseerror"])
@partial_decorator
def remove_html_tags(text: str):
    #extracted from "https://stackoverflow.com/a/9662410", w/ additional decorator of error handler
    return (''.join(ET.fromstring(text).itertext())).strip()


#create url decoder of text
@text_cleansing_wrapper
def decode_url(text: str):
    # return (urllib.parse.unquote(text)).encode('utf8', errors='ignore').decode().strip()
    return (urllib.parse.unquote(text)).strip()

#create encoder check of text
@text_cleansing_wrapper
def check_text_by_encoder(text: str, encoder: str="utf8"):
    return text.encode(encoder, errors='ignore').decode().strip()

#create excessive whitespace removal of text
@text_cleansing_wrapper
def remove_excessive_whitespace(text: str):
    return re.sub("(\s)(\s+)", r"\1", text).strip()

#create non-alphanumeric removal of text
@text_cleansing_wrapper
def remove_non_alphanumeric(text: str):
    return re.sub("[^a-z0-9\s]", "", text, flags=re.I).strip()

# def cleanse_wiki_text(text: str):
#     return remove_html_tags(decode_url_and_remove_non_ascii(text))

# def normalize_wiki_title(text: str):
#     return remove_non_alphanumeric(remove_excessive_whitespace(text.lower()))


def _text_normalizer_constructor(
        remove_non_alphanumeric_bool: bool, remove_excessive_whitespace_bool: bool,
        remove_html_tags_bool: bool, decode_url_bool: bool, encoder_check_bool: bool,
        encoder: str="utf8"):

    _lambda_fn_1 = partial(check_text_by_encoder, encoder=encoder) if encoder_check_bool else lambda x: x
    _lambda_fn_2 = lambda x: remove_non_alphanumeric(_lambda_fn_1(x)) if remove_non_alphanumeric_bool else _lambda_fn_1(x)
    _lambda_fn_3 = lambda x: remove_excessive_whitespace(_lambda_fn_2(x)) if remove_excessive_whitespace_bool else _lambda_fn_2(x)
    _lambda_fn_4 = lambda x: remove_html_tags(_lambda_fn_3(x)) if remove_html_tags_bool else _lambda_fn_3(x)
    _lambda_fn_5 = lambda x: decode_url(_lambda_fn_4(x)) if decode_url_bool else _lambda_fn_4(x)

    return _lambda_fn_5


def _args_to_text_constructor_fn(**kwargs):

    def _decode_options(opt: str):
        # return decoded options with format `text_opt`, `title_opt`
        # possible values are ["all", "text", "title", "neither"]
        if opt == "all":
            return True, True
        elif opt == "text":
            return True, False
        elif opt == "title":
            return False, True
        else:
            return False, False

    kwargs_title, kwargs_text = {}, {}

    kwargs_title["encoder"] = kwargs["text_encoder_choice_title"]
    kwargs_text["encoder"] = kwargs["text_encoder_choice_text"]

    for key, val in kwargs.items():
        if key not in [
            "remove_non_alphanumeric_option", "remove_excessive_whitespace_option",
            "remove_html_tags_option", "decode_url_option", "encoder_check_option"]:
            continue
        new_key = "_".join(key.split("_")[:-1]) + "_bool"
        text_opt_val, title_opt_val = _decode_options(val)
        kwargs_text[new_key], kwargs_title[new_key] = text_opt_val, title_opt_val

    return _text_normalizer_constructor(**kwargs_text), _text_normalizer_constructor(**kwargs_title)


def _text_processing_wrapper(text: str, _fn, mode: str="text"):
    if mode not in ["text", "title"]:
        raise ValueError(f"Provided `mode` isn't either 'text' or 'title'! Received: {mode}")
    return _fn(text.lower()) if mode=="title" else _fn(text)


### MAIN CODE ###
if __name__ == "__main__":
    parser = argparse.ArgumentParser()

    parser.add_argument("--raw-csv-path", help="Relative location of csv file containing raw Wikipedia data")

    parser.add_argument("--drop-hard-dupl", help="""Flag whether to drop hard duplicates
                        (exact values of data of relevant text fields, Titles & Desc)""",
          default=True, type=argparse_bool_check)

    parser.add_argument("--drop-soft-dupl", help="""Flag whether to drop soft duplicates
                        (duplicates after cleansed and normalized relevant text fields, Titles & Desc)""",
          default=True, type=argparse_bool_check)

    parser.add_argument("--save-dir-path", help="""Relative dir path of saved Wikipedia CSV data
                        to the `dedup_raw_wiki_data.py` script dir""",
            default=os.path.dirname(os.path.abspath(__file__)))

    ### THE FOLLOWING ARGUMENTS ONLY TEMPORARILY ALTER THE TEXT DATA ONLY FOR SOFT-DEDUP CHECK ###
    ### THE INITIAL TEXT DATA WON'T BE OVERWRITTEN AFTER BEING PREPROCESSED ###
    ### UNLESS YOU ARE SPECIFYING IN ARGS `overwrite-initial-title-data` AND `overwrite-initial-text-data` ###

    ### ARGS TO OVERWRITTE INITIAL TEXT DATA WITH PROCESSED ONES ###
    parser.add_argument("--overwrite-initial-title-data", help="""Flag whether to overwrite title
                        init data w/ processed data (True) or keep it as it is (False)""",
          default=False, type=argparse_bool_check)

    parser.add_argument("--overwrite-initial-text-data", help="""Flag whether to overwrite text
                        init data w/ processed data (True) or keep it as it is (False)""",
          default=False, type=argparse_bool_check)

    ### INSTANTIATOR ARGS FOR CONSTRUCTING TEXT PROCESSING FN TO BE APPLIED ###
    parser.add_argument("--remove-non-alphanumeric-option", help="""Identifier which columns to be preprocessed
                        using `remove_non_alphanumeric` for soft duplicates detection
                        (Choices are "all", "text", "title", "neither")""",
          default="neither", type=text_processing_args_checker)

    parser.add_argument("--remove-excessive-whitespace-option", help="""Identifier which columns to be preprocessed
                        using `remove_excessive_whitespace` for soft duplicates detection
                        (Choices are "all", "text", "title", "neither")""",
          default="all", type=text_processing_args_checker)

    parser.add_argument("--remove-html-tags-option", help="""Identifier which columns to be preprocessed
                        using `remove_html_tags` for soft duplicates detection
                        (Choices are "all", "text", "title", "neither")""",
          default="all", type=text_processing_args_checker)

    parser.add_argument("--decode-url-option", help="""Identifier which columns to be preprocessed
                        using `decode_url` for soft duplicates detection
                        (Choices are "all", "text", "title", "neither")""",
          default="all", type=text_processing_args_checker)

    ### ARGS TO CHOOSE ENCODER CHECKING AND ITS CONFIG INITIALIZATION ###
    parser.add_argument("--encoder-check-option", help="""Identifier which columns to be preprocessed
                        using `check_text_by_encoder` for soft duplicates detection
                        (Choices are "all", "text", "title", "neither")""",
          default="all", type=text_processing_args_checker)

    parser.add_argument("--text-encoder-choice-title", help="""Identifier of title encoder type
                        to be applied into `check_text_by_encoder` for soft duplicates detection""",
          default="utf8", type=str)

    parser.add_argument("--text-encoder-choice-text", help="""Identifier of text encoder type
                        to be applied into `check_text_by_encoder` for soft duplicates detection""",
          default="utf8", type=str)


    _EXPECTED_COLNAMES = ["id", "url", "title", "text"]

    logger = set_logger()
    logger.info("Parsing arguments...")

    args = parser.parse_args()

    # class dotdict(dict):
    #     """dot.notation access to dictionary attributes"""
    #     __getattr__ = dict.get
    #     __setattr__ = dict.__setitem__
    #     __delattr__ = dict.__delitem__
    
    # args = dotdict({
    #     "raw_csv_path":"",
    #     "drop_hard_dupl": True,
    #     "drop_soft_dupl": True,
    #     "save_dir_path": os.path.dirname(os.path.abspath(__file__)),
    #     "overwrite_initial_title_data": False,
    #     "overwrite_initial_text_data": False,
    #     "remove_non_alphanumeric_option":"neither",
    #     "remove_excessive_whitespace_option": "neither",
    #     "remove_html_tags_option":"neither",
    #     "decode_url_option":"neither",
    #     "encoder_check_option":"all",
    #     "text_encoder_choice_title":"utf8",
    #     "text_encoder_choice_text":"utf8"
    # })

    _TEXT_PROCESSING_FN, _TITLE_PROCESSING_FN = _args_to_text_constructor_fn(
        remove_non_alphanumeric_option = args.remove_non_alphanumeric_option,
        remove_excessive_whitespace_option = args.remove_excessive_whitespace_option,
        remove_html_tags_option = args.remove_html_tags_option,
        decode_url_option = args.text_encoder_choice_title,
        encoder_check_option = args.encoder_check_option,
        text_encoder_choice_title = args.text_encoder_choice_title,
        text_encoder_choice_text = args.text_encoder_choice_text
    )

    raw_data_path = args.raw_csv_path
    drop_hard_dupl = args.drop_hard_dupl
    drop_soft_dupl = args.drop_soft_dupl
    save_dir = args.save_dir_path

    overwrite_initial_title_data = args.overwrite_initial_title_data
    overwrite_initial_text_data = args.overwrite_initial_text_data


    df = pd.read_csv(raw_data_path)
    if len(set(df.columns).difference(set(_EXPECTED_COLNAMES))) != 0 or len(set(_EXPECTED_COLNAMES).difference(set(df.columns))) != 0:
        raise ValueError(f"The data schema expected, consist of columns: {', '.join(df.columns.to_list())} doesn't match with expected column values of {', '.join(_EXPECTED_COLNAMES)}!")

    if (not drop_hard_dupl) and (not drop_soft_dupl):
        raise AssertionError("The script won't run with both `drop-hard-dupl` and `drop-soft-dupl` args turned off!")
    elif (not drop_hard_dupl):
        warnings.warn("The args of `drop_hard_dupl` isn't turned off! Possibly the data will contain one template value of Wikipedia (usually no contribution text!)")

    #will save id identifier colname first (popping first list val)
    id_colname = _EXPECTED_COLNAMES.pop(0)

    # if any of the data has duplicate values from columns checked (url, title, or text),
    # it means the data integrity is questionable
    # i.e. copied from other article or filled with template text
    # hence, we will delete those duplicated datasets

    #hard duplicate drop (drop all duplicate values that has exact same text on expected unique colnames)
    if drop_hard_dupl:

        for colname in _EXPECTED_COLNAMES:
            logger.info(f"Checking data integrity on column {colname} on removing hard-duplicate(s)...")
            dupl_text_df = df[df.duplicated(subset=colname,keep=False)]
            shape_of_dupl_data = dupl_text_df.shape[0]

            if shape_of_dupl_data > 0:
                logger.info(f"Found {shape_of_dupl_data} data duplicated! Will be dropped")
                df.drop_duplicates(subset=colname, keep=False, inplace=True)


        #check id/idx of the cleansed data, whether it has duplicate
        # (the duplication of id/idx should came from the very first extraction, not from the cleansing)

        if df[df.duplicated(subset=id_colname,keep=False)].shape[0] > 0:
            logger.info("Duplicated ID found! Re-assigning ID to the new ones based on `df.reset_index` method!")
            df[id_colname] = df.reset_index().index

    #soft duplicate drop (drop all except one duplicate values that has exact same text on expected unique colnames)
    #keep the data that has longest value of its raw form
    if drop_soft_dupl:

        idx_to_keep = set(df.index.to_list())
        #clean from text & title only, url isn't needed for this process
        _EXPECTED_COLNAMES.remove("url")

        for colname in _EXPECTED_COLNAMES:
            #Construct Text Cleanser Fn for soft-duplicate cleansing
            _PROCESSING_FN = _TEXT_PROCESSING_FN if colname == "text" else _TITLE_PROCESSING_FN
            text_processing_fn = partial(_text_processing_wrapper, _fn=_PROCESSING_FN, mode=colname)
            logger.info(f"Checking data integrity on column {colname} on removing soft-duplicate(s)...")
            _df = df.copy(deep=True)

            #Setting up DF cols as String so it can be text-processed
            _df = _df[[colname]]
            _df[colname] = _df[colname].astype("str")
            logger.info(f"Cleansing the data based on {colname}")

            #applying text processing
            _df[colname+"_raw_len"] = _df[colname].apply(len)
            _df[colname+"_cleansed"] = _df[colname].apply(lambda row_text: text_processing_fn(text=row_text))

            #overwrite its text data if set as true
            if overwrite_initial_title_data and colname == "title":
                df[colname] = _df[colname+"_cleansed"]
            elif overwrite_initial_text_data and colname == "text":
                df[colname] = _df[colname+"_cleansed"]

            #choose the data to keep by "ranking" it according to len of its raw text (greatest to keep)
            logger.info(f"Ranking and grouping the data based on {colname}")
            _df["rk"] = _df.groupby(colname+"_cleansed")[colname+"_raw_len"].rank(method="min", ascending=False)
            shape_of_dupl_data = _df[_df["rk"]>1].shape[0]

            if shape_of_dupl_data > 0:
                logger.info(f"Found {shape_of_dupl_data} data duplicated! Will be dropped")
                _idx_to_keep = _df[_df["rk"]==1].index.to_list()
                if len(_idx_to_keep)+shape_of_dupl_data != df.shape[0]:
                    raise AssertionError("Mismatch of data number!")
                idx_to_keep = idx_to_keep.intersection(set(_idx_to_keep))
            else:
                logger.info(f"No soft-duplicate found in colname {colname}. Continuing")

            del _df
            gc.collect()

        logger.info(f"The final data kept is {len(idx_to_keep)} from {df.shape[0]}")
        df = df.loc[list(idx_to_keep),:]

    logger.info("Saving dataset cleansed form...")
    #input path splitted by ("/") for the last entry should return filename
    #whereas the filename splitted by (".") except the last value should return the filename w/o ".csv" extension

    _override_suffix_identifier = ""
    if overwrite_initial_title_data or overwrite_initial_text_data:
        _override_suffix_identifier = "_overwritten"
        if overwrite_initial_text_data:
            _override_suffix_identifier = "_text"+_override_suffix_identifier
        if overwrite_initial_title_data:
            _override_suffix_identifier = "_title"+_override_suffix_identifier

    _save_file_name = ".".join(raw_data_path.split("/")[-1].split(".")[:-1]) + "_dedup_cleansed" + _override_suffix_identifier + ".csv"
    _save_file_name = _save_file_name.replace("_raw", "")
    df.to_csv(f"{save_dir}/{_save_file_name}", index=False)