DataOpsHub 6.2.0__py3-none-any.whl

DataOpsHub/databases/database_handler.py

@@ -0,0 +1,878 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""
+Database Handler Module
+
+This module provides comprehensive database operations and utilities for the DataOpsHub application.
+It includes functionality for database initialization, data filtering, CRUD operations, and file uploads.
+"""
+
+#----------------#
+# Import modules #
+#----------------#
+
+from sqlalchemy import Column, DateTime, Integer, String, create_engine, text
+from sqlalchemy.exc import SQLAlchemyError, IntegrityError
+from sqlalchemy.orm import declarative_base, sessionmaker
+from urllib.parse import quote_plus
+
+#------------------------#
+# Import project modules #
+#------------------------#
+
+from filewise.general.introspection_utils import get_type_str, get_func_name
+from filewise.json_utils.json_obj_handler import serialise_to_json, deserialise_json
+from filewise.pandas_utils.pandas_obj_handler import csv2df, excel_handler, ods_handler
+from paramlib.config_params import DB_ERROR_CODE_DICT, USER_INFO_JSON_PATH
+from pygenutils.strings.string_handler import find_substring_index, get_obj_specs
+from pygenutils.strings.text_formatters import format_string
+from pygenutils.time_handling.date_and_time_utils import parse_time_string
+
+#------------------------#
+# Import project modules #
+#------------------------#
+
+from DataOpsHub.models.user import User
+from DataOpsHub.constants.error_messages import (
+    INVALID_DATE_FORMAT_ERROR,
+    INVALID_DATE_RANGE_ERROR
+)
+
+#-----------------#
+# Declare objects #
+#-----------------#
+
+# SQLAlchemy Base class #
+Base = declarative_base()
+
+# Model registry to store all models
+MODEL_REGISTRY = {}
+
+#------------------#
+# Define functions #
+#------------------#
+
+# %% HELPERS
+
+# Database connections #
+#----------------------#
+
+def _init_engine(config, database_type="mysql"):
+    """
+    Create a SQLAlchemy engine based on provided credentials and database type.
+
+    Parameters
+    ----------
+    config : dict
+        Contains credentials for accessing the database with keys:
+        - 'username': str, the database username.
+        - 'password': str, the database password.
+        - 'host': str, the database host address.
+        - 'port': str, optional, the database port.
+        - 'database_name': str, optional, the name of the database.
+
+    database_type : {'mysql', 'postgresql', 'sqlite'}, optional
+        The type of database for SQLAlchemy configuration. Default is 'mysql'.
+
+    Returns
+    -------
+    sqlalchemy.engine.base.Engine
+        A configured SQLAlchemy engine object for database interactions.
+
+    Note
+    ----
+    Use URL-encoded passwords with special characters (e.g., '@') using `urllib.parse.quote_plus`.
+    """
+    if database_type not in DATABASE_ALIAS_DICT:
+        raise ValueError(f"Unsupported database type. Choose from {list(DATABASE_ALIAS_DICT.keys())}")
+
+    password = quote_plus(config.get('password'))
+    db_alias = DATABASE_ALIAS_DICT[database_type]
+    port = config.get('port', '')  # Get port if provided
+    host_with_port = f"{config['host']}:{port}" if port else config['host']
+
+    if database_type in ("mysql", "postgresql"):
+        engine = create_engine(f"{db_alias}://{config['username']}:{password}@{host_with_port}/{config.get('database_name', '')}")
+    else:
+        engine = create_engine(f"{db_alias}:///{config.get('database_name', '')}.db")
+    
+    return engine
+
+def _apply_date_range_filter(query, min_value, max_value, date_field):
+    """
+    Apply date range filter, always including both edges of the range.
+
+    Parameters
+    ----------
+    query : sqlalchemy.orm.query.Query
+        The current query object.
+    min_value : str
+        Start date in format 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM'.
+        If only date is provided, time defaults to 00:00.
+    max_value : str
+        End date in format 'YYYY-MM-DD' or 'YYYY-MM-DD HH:MM'.
+        If only date is provided, time defaults to 23:59.
+    date_field : sqlalchemy.Column
+        The date field to filter on.
+
+    Returns
+    -------
+    sqlalchemy.orm.query.Query
+        Query with date range filter applied.
+
+    Raises
+    ------
+    ValueError
+        If date format is incorrect.
+    """
+    try:
+        # Try parsing with time first
+        try:
+            min_date = parse_time_string(min_value, '%Y-%m-%d %H:%M')
+        except ValueError:
+            # If that fails, try date-only format and set time to 00:00
+            min_date = parse_time_string(min_value, '%Y-%m-%d')
+            min_date = min_date.replace(hour=0, minute=0)
+
+        try:
+            max_date = parse_time_string(max_value, '%Y-%m-%d %H:%M')
+        except ValueError:
+            # If that fails, try date-only format and set time to 23:59
+            max_date = parse_time_string(max_value, '%Y-%m-%d')
+            max_date = max_date.replace(hour=23, minute=59)
+
+    except ValueError:
+        raise ValueError(INVALID_DATE_FORMAT_ERROR)
+
+    if min_date > max_date:
+        raise ValueError(INVALID_DATE_RANGE_ERROR)
+
+    # Always include both edges of the range
+    query = query.filter(date_field >= min_date, date_field <= max_date)
+    return query
+
+# Bulk Data Loading #
+#-------------------#
+
+def _load_df(df, table_name, engine, if_exists="replace", import_index=False):
+    """
+    Upload a DataFrame to an SQL database.
+
+    Parameters
+    ----------
+    df : pandas.DataFrame
+        DataFrame to upload.
+    table_name : str
+        Name of the SQL table.
+    engine : sqlalchemy.engine.Engine
+        Database engine for connection.
+    if_exists : {'replace', 'append', 'fail'}, optional
+        Action if the table already exists, default is 'replace'.
+    import_index : bool, optional
+        Whether to include DataFrame index, default is False.
+
+    Returns
+    -------
+    str
+        A message indicating successful data load to the specified
+        database and table name.
+
+    Raises
+    ------
+    ValueError
+        If the data upload fails due to incorrect database credentials
+        or other issues.
+    SQLAlchemyError
+        If an error occurs within SQLAlchemy during the upload process.
+    Exception
+        For any other errors, providing an intuitive error message.
+    """
+    try:
+        df.to_sql(table_name, con=engine, if_exists=if_exists, index=import_index)
+    except ValueError as ve:
+        print(f"ValueError: {ve}")
+    except SQLAlchemyError as se:
+        print(f"SQLAlchemyError: {se}")
+    except Exception as e:
+        err_code = find_substring_index(str(e), "[0-9]{4}", 
+                                        advanced_search=True, 
+                                        return_match_index=False,
+                                        return_match_str=True)
+        intuitive_err = DB_ERROR_CODE_DICT.get(err_code)
+        raise ValueError(intuitive_err)
+    else:
+        database_name = engine.url.database
+        data_load_format_values = [database_name, table_name]
+        return format_string(SUCCESS_DATA_LOAD_TEMPLATE, data_load_format_values)
+
+
+# %% MAIN METHODS
+
+# Database creation and initialization #
+#-------------------------------------#
+
+def create_database(config, database_name, database_type="mysql"):
+    """
+    Create a new database using the provided configuration and database name.
+
+    Parameters
+    ----------
+    config : dict
+        Contains credentials for accessing the database.
+        For information about keys, refer to the docstring of the '_init_engine' function.
+    database_name : str
+        The name of the database to be created.
+    database_type : str, optional
+        The type of database for SQLAlchemy configuration. Default is 'mysql'.
+
+    Returns
+    -------
+    None
+    """
+    # Create an engine for the initial connection #
+    engine = _init_engine(config, database_type)
+    
+    # Check if the database already exists
+    try:
+        with engine.connect() as conn:
+            if database_type in ("mysql", "postgresql"):
+                result = conn.execute(text(f"SELECT 1 FROM INFORMATION_SCHEMA.SCHEMATA WHERE SCHEMA_NAME = :db_name"), {'db_name': database_name})
+                if result.fetchone():
+                    return f"Database '{database_name}' already exists, skipping creation."
+                
+                conn.execute(text(f"CREATE DATABASE {database_name}"))
+                return f"Database '{database_name}' created successfully."
+            else:
+                # For SQLite, the database is created when the engine is connected
+                return f"SQLite database '{database_name}.db' created successfully."
+    except SQLAlchemyError as e:
+        return f"An SQLAlchemy error occurred: {e}"
+    except Exception as e:
+        return f"An unexpected error occurred: {e}"
+
+def init_db(config, database_type="mysql"):
+    """
+    Initialise database tables as per model classes, including the User model.
+
+    Parameters
+    ----------
+    config : dict
+        Database configuration credentials for connection.
+        For information of the keys, refer to the help docstring of the 
+        '_init_engine' helper function.
+    database_type : {'mysql', 'postgresql', 'sqlite'}, optional
+        The type of database for SQLAlchemy configuration. Default is 'mysql'.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - engine (sqlalchemy.engine.base.Engine): The database engine.
+        - Session (sqlalchemy.orm.session.Session): A session factory bound to the database.
+    """
+    engine = _init_engine(config, database_type)
+    Base.metadata.create_all(engine)
+    Session = sessionmaker(bind=engine)
+    return engine, Session
+
+# Data filtering #
+#----------------#
+
+def filter_data(session_or_factory, request_data, filtering_fields, model_class=None):
+    """
+    Filter user data based on the provided JSON data.
+
+    Parameters
+    ----------
+    session_or_factory : sqlalchemy.orm.Session or sqlalchemy.orm.session.Session
+        Either a SQLAlchemy session or a session factory.
+    request_data : dict
+        JSON data containing filter criteria.
+    filtering_fields : list of str
+        List of field names to filter on.
+    model_class : sqlalchemy.orm.DeclarativeMeta, optional
+        The model class to query. If not provided, it will be determined from the request data.
+
+    Returns
+    -------
+    sqlalchemy.orm.query.Query
+        A query object with the applied filters.
+    """
+    if isinstance(session_or_factory, sessionmaker):
+        session = session_or_factory()
+    else:
+        session = session_or_factory
+
+    if model_class is None:
+        model_class = MODEL_REGISTRY.get(request_data.get('table_name'))
+
+    if model_class is None:
+        raise ValueError("No model class provided or found in registry")
+
+    query = session.query(model_class)
+
+    for field in filtering_fields:
+        if field in request_data:
+            value = request_data[field]
+            if value is not None:
+                column = getattr(model_class, field)
+                if field == model_class.get_date_field():
+                    min_value = value.get('min_value')
+                    max_value = value.get('max_value')
+                    if min_value is not None and max_value is not None:
+                        query = _apply_date_range_filter(query, min_value, max_value, column)
+                else:
+                    query = query.filter(column == value)
+
+    return query
+
+# CRUD operations #
+#-----------------#
+
+# User insertion #
+#-#-#-#-#-#-#-#-#-
+
+def create_user(Session, user_info_dict):
+    """
+    Insert a new user into the database.
+
+    Parameters
+    ----------
+    Session : sqlalchemy.orm.session.Session
+        The session factory for database interaction.
+    user_info_dict : dict
+        Dictionary containing the user's information.
+
+    Returns
+    -------
+    str
+        A message indicating the result of the operation.
+    """
+    session = Session()
+    try:
+        new_user = User(
+            email=user_info_dict['email'],
+            first_name=user_info_dict['first_name'],
+            first_surname=user_info_dict['first_surname'],
+            second_surname=user_info_dict['second_surname'],
+            password=user_info_dict['password'],
+            tel=user_info_dict['tel'],
+            age=user_info_dict['age']
+        )
+        session.add(new_user)
+        session.commit()
+        return SUCCESS_USER_INSERT
+    except IntegrityError as e:
+        session.rollback()
+        if "email" in str(e.orig):
+            return EMAIL_EXISTS_ERROR
+        elif "tel" in str(e.orig):
+            return PHONE_EXISTS_ERROR
+    except Exception as e:
+        session.rollback()
+        return f"Error al insertar el usuario: {e}"
+    finally:
+        session.close()
+
+def create_user_json(json_path, data_dict):
+    """
+    Insert a new user's information into the JSON file, ensuring uniqueness for email and tel.
+
+    Parameters
+    ----------
+    json_path : str
+        Path to the JSON file.
+    data_dict : dict
+        Dictionary containing the new user's information.
+
+    Returns
+    -------
+    str
+        A message indicating the result of the operation.
+    """
+    user_info_array = deserialise_json(json_path)
+
+    # Check for uniqueness of email and tel
+    for user in user_info_array:
+        if user['email'] == data_dict['email']:
+            return EMAIL_EXISTS_ERROR
+        if user['tel'] == data_dict['tel']:
+            return PHONE_EXISTS_ERROR
+
+    # Add the new user data
+    user_info_array.append(data_dict)
+    serialise_to_json(user_info_array, json_path)
+    return SUCCESS_USER_INSERT
+
+# User retrieval #
+#-#-#-#-#-#-#-#-#
+
+def get_all_users(Session):
+    """
+    Retrieve all user records from the database.
+
+    Parameters
+    ----------
+    Session : sqlalchemy.orm.session.Session
+        The session factory for database interaction.
+
+    Returns
+    -------
+    list
+        A list of User objects representing all users in the database.
+    """
+    session = Session()
+    try:
+        users = session.query(User).all()
+        return users
+    except Exception as e:
+        session.rollback()
+        return f"Error al recabar datos de usuarios: {e}"
+    finally:
+        session.close()
+
+def get_all_users_json(json_path):
+    user_info_array = deserialise_json(json_path)
+    field_names = list(list(set(tuple(user.keys()) for user in user_info_array))[0])
+    return user_info_array, field_names
+
+# User data filtering #
+#-#-#-#-#-#-#-#-#-#-#-#
+
+def filter_data_json(json_path, form_data, field_name_list):
+    """
+    Filter user data from a JSON file based on the provided form data.
+
+    Parameters
+    ----------
+    json_path : str
+        Path to the JSON file containing user data.
+    form_data : dict
+        Dictionary containing form data for filtering.
+    field_name_list : list
+        List of field names to consider for filtering.
+
+    Returns
+    -------
+    list
+        A list of dictionaries representing the filtered user data.
+    """
+    # Load the JSON data using the deserialise_json function
+    data = deserialise_json(json_path)
+
+    # Filter the data based on form inputs
+    filtered_data = []
+    for entry in data:
+        match = True
+        for field in field_name_list:
+            if field in form_data and form_data[field]:
+                if form_data[field] not in entry.get(field, ''):
+                    match = False
+                    break
+        if match:
+            filtered_data.append(entry)
+
+    return filtered_data
+
+# User data modification #
+#-#-#-#-#-#-#-#-#-#-#-#-#-
+
+def update_data(Session, checked_box_ids, updatable_info_dict):
+    """
+    Update user data in the database for multiple users and return both old and new data.
+
+    Parameters
+    ----------
+    Session : sqlalchemy.orm.session.Session
+        The session factory for database interaction.
+    checked_box_ids : list
+        List of IDs of the users to be updated.
+    updatable_info_dict : dict
+        Dictionary containing the new user information to update.
+
+    Returns
+    -------
+    tuple
+        A tuple containing:
+        - original_users (list): List of original user data dictionaries.
+        - updated_users (list): List of updated user data dictionaries.
+    """
+    session = Session()
+    original_users = []
+    updated_users = []
+    try:
+        # Retrieve and filter the selected users
+        selected_users = session.query(User).filter(User.id.in_(checked_box_ids)).all()
+
+        for user in selected_users:
+            # Store original user data
+            original_user_data = {column.name: getattr(user, column.name) for column in User.__table__.columns}
+            original_users.append(original_user_data)
+
+            # Check for uniqueness of email and tel
+            if 'email' in updatable_info_dict:
+                existing_user = session.query(User).filter(User.email == updatable_info_dict['email'], User.id != user.id).first()
+                if existing_user:
+                    return "El correo electrónico ya existe.", None
+            
+            if 'tel' in updatable_info_dict:
+                existing_user = session.query(User).filter(User.tel == updatable_info_dict['tel'], User.id != user.id).first()
+                if existing_user:
+                    return "El teléfono ya existe.", None
+
+            # Update the user with new values
+            for key, value in updatable_info_dict.items():
+                if value:
+                    setattr(user, key, value)
+
+            # Store updated user data
+            updated_user_data = {column.name: getattr(user, column.name) for column in User.__table__.columns}
+            updated_users.append(updated_user_data)
+
+        session.commit()
+        return original_users, updated_users
+    except IntegrityError as e:
+        session.rollback()
+        if "email" in str(e.orig):
+            return "El correo electrónico ya existe.", None
+        elif "tel" in str(e.orig):
+            return "El teléfono ya existe.", None
+    except Exception as e:
+        session.rollback()
+        return f"Error al actualizar los datos del usuario: {e}", None
+    finally:
+        session.close()
+
+def update_data_json(json_path, updated_info_dict, user_ids):
+    """
+    Updates the user information in the JSON file for the given user IDs.
+
+    Parameters
+    ----------
+    json_path : str
+        Path to the JSON file containing user information.
+    updated_info_dict : dict
+        Dictionary containing the new user information.
+    user_ids : list
+        List of user IDs to update.
+
+    Returns
+    -------
+    list
+        Updated list of user information dictionaries.
+    """
+    user_info_array = deserialise_json(json_path)
+
+    # Check for uniqueness of email and tel
+    for user in user_info_array:
+        if str(user['ID']) not in user_ids:
+            if 'email' in updated_info_dict and user['email'] == updated_info_dict['email']:
+                return "El correo electrónico ya existe."
+            if 'tel' in updated_info_dict and user['tel'] == updated_info_dict['tel']:
+                return "El teléfono ya existe."
+
+    # Update the selected users
+    selected_users_obj = [dct for dct in user_info_array if str(dct.get("ID")) in user_ids]
+    for user in selected_users_obj:
+        for key, value in updated_info_dict.items():
+            if value:
+                user[key] = value
+
+    serialise_to_json(USER_INFO_JSON_PATH, user_info_array)
+    return selected_users_obj, user_info_array
+
+# User deletion #
+#-#-#-#-#-#-#-#-#
+
+def remove_data(Session, checked_box_ids):
+    """
+    Remove user data from the database based on the provided IDs.
+
+    Parameters
+    ----------
+    Session : sqlalchemy.orm.session.Session
+        The session factory for database interaction.
+    checked_box_ids : list
+        List of IDs of the users to be deleted.
+
+    Returns
+    -------
+    None
+    """
+    session = Session()
+    try:
+        # Use the checked_box_ids to filter and delete users
+        session.query(User).filter(User.id.in_(checked_box_ids)).delete(synchronize_session='fetch')
+        # Commit the changes to the database
+        session.commit()
+    except Exception as e:
+        session.rollback()
+        return f"Error durante la eliminación de datos: {e}"
+    finally:
+        session.close()
+
+def remove_data_json(json_path, checked_box_ids):
+    """
+    Removes the specified users from the user info array and updates the JSON file.
+
+    Parameters
+    ----------
+    json_path : str
+        Path to the JSON file containing user information.
+    checked_box_ids : list
+        List of IDs of the users to be deleted.
+
+    Returns
+    -------
+    None
+    """
+    # Load the existing user data from the JSON file
+    user_info_array = deserialise_json(json_path)
+    
+    # Identify users to delete based on the provided IDs
+    users_to_delete = [user for user in user_info_array if str(user['ID']) in checked_box_ids]
+    
+    # Create a new list excluding the users marked for deletion
+    updated_info_array = [user for user in user_info_array if user not in users_to_delete]
+    
+    # Save the updated user list back to the JSON file
+    serialise_to_json(json_path, updated_info_array)
+
+# Operations beyond CRUD set #
+#----------------------------#
+
+def run_custom_query(query_str, engine, print_str=False):
+    """
+    Execute custom SQL queries for operations beyond
+    standard CRUD (Create, Read, Update, Delete) operations.
+
+    Parameters
+    ----------
+    query_str : str
+        The SQL query string to execute.
+    engine : sqlalchemy.engine.base.Engine
+        The SQLAlchemy engine object for the database connection.
+    print_str : bool, optional
+        If True, prints the query result to the console. Default is False.
+
+    Returns
+    -------
+    list of tuple
+        The result of the query as a list of tuples, or an empty list if there are no rows.
+    """
+    try:
+        with engine.connect() as conn:
+            query = text(query_str)
+            result = conn.execute(query)
+            rows = result.fetchall() if result.returns_rows else []
+
+            if print_str:
+                if rows:
+                    for row in rows:
+                        return row
+                else:
+                    return "Query executed successfully, no results to display."
+
+            return rows
+    except SQLAlchemyError as e:
+        return f"An SQLAlchemy error occurred: {e}"
+    except Exception as e:
+        return f"An unexpected error occurred: {e}"
+
+def upload_file_data(input_file_list, 
+                     config,
+                     database_type="mysql",
+                     if_exists="replace",
+                     import_index=False,
+                     separator="\t",
+                     sheet_name=None,
+                     header=None,
+                     parser_engine=None,
+                     decimal=".",
+                     dtype_dict=None):
+    """
+    Load data from various file types into an SQL database table using Pandas DataFrames.
+
+    Parameters
+    ----------
+    input_file_list : str or list of str
+        Path(s) to input files (CSV, XLSX, ODS).
+    config : dict
+        Database configuration credentials (refer to `create_engine_with_config`).
+    database_type : {'mysql', 'postgresql', or 'sqlite'}, optional
+        Type of SQL database. Default is 'mysql'.
+    if_exists : {'replace', 'append', or 'fail'}, optional
+        Behaviour if the table exists in the database. Default is 'replace'.
+    import_index : bool, optional
+        Whether to import the DataFrame index into the database table.
+        Default is False.
+    separator : str, optional
+        Separator for CSV files. Default is "\t".
+    sheet_name : str, optional
+        Sheet name for XLSX/ODS files.
+    header : int or None, optional
+        Row number(s) to use as column names.
+        Default is None (take into account all sheets).
+    parser_engine : str, optional
+        Parser engine for reading the files.
+    decimal : str, optional
+        Character to recognise as decimal point. Default is ".".
+    dtype_dict : dict, ptional
+        Data type definitions for columns.
+        
+    Notes
+    -----
+
+    Usage 
+    ~~~~~
+    - The `dtype_dict` parameter defines data types for columns in the DataFrame.
+    - If processing multiple files, construct a list of dictionaries, 
+      with each dictionary corresponding to a file's data types.
+    - It is not necessary to mention every data table column in a dictionary.
+    - For columns that don't require specific types, set the relevant dictionary entry
+      to `None` or an empty dictionary.
+    
+    Data Type Options
+    ~~~~~~~~~~~~~~~~~
+    Refer to the following table for mapping Pandas data types to MySQL data types:
+
+    | Pandas Data Type |   MySQL Data Type   |
+    |------------------|---------------------|
+    | `int64`          | `BIGINT`            |
+    | `int32`          | `INTEGER`           |
+    | `float64`        | `DOUBLE`            |
+    | `float32`        | `FLOAT`             |
+    | `bool`           | `BOOLEAN`           |
+    | `datetime64`     | `DATETIME`          |
+    | `timedelta[ns]`  | `TIME`              |
+    | `object`         | `TEXT` or `VARCHAR` |
+    | `category`       | `VARCHAR`           |
+        
+    Returns
+    -------
+    None
+    """
+    
+    # Argument adequacy controls #
+    ##############################
+    
+    # Retrieve argument names for error handling #
+    function_arg_names = get_func_name()
+    dtype_dict_arg_pos = find_substring_index(function_arg_names, "dtype_dict")
+    
+    # Convert the input file list to that if it's a string
+    if isinstance(input_file_list, str):
+        input_file_list = [input_file_list]
+        
+    # Convert 'dtype_dict' argument to list if it's a single dictionary
+    if isinstance(dtype_dict, dict):
+        dtype_dict = [dtype_dict]
+          
+    # Common keyword arguments #
+    ############################
+        
+    # Common keyword argument dictionary for CSV and other file handlers
+    kwargs_simple = dict(
+        engine=parser_engine,
+        header=header, 
+        decimal=decimal,
+    )
+    
+    kwargs_complete = dict(
+        engine=parser_engine,
+        sheet_name=sheet_name,
+        header=header, 
+        decimal=decimal,
+    )
+    
+    # Operations #
+    ##############
+    
+    # Create the database engine
+    engine = _init_engine(config, database_type=database_type)
+  
+    # Keyword arguments for data upload
+    kwargs_data_upload = dict(
+        engine=engine,
+        if_exists=if_exists,
+        import_index=import_index,
+    )
+    
+    # Loop through files and upload data to the table names defined by their sheet names
+    for file, dtype in zip(input_file_list, dtype_dict):
+        in_extension = get_obj_specs(file, "ext")
+        
+        try:
+            # CSV files
+            if in_extension == SUPPORTED_EXTENSIONS[0]:
+                """
+                In CSV files there is no 'sheet' concept, so it is assumed
+                that the input data comes as is.
+                """
+                df = csv2df(file, separator, **kwargs_simple)
+                table_name = get_obj_specs(file, "name_noext")
+                if dtype:
+                    df = df.astype(dtype)
+                _load_df(df, table_name, **kwargs_data_upload)
+        
+            # Microsoft Excel files
+            elif in_extension == SUPPORTED_EXTENSIONS[1]:
+                item_dict = excel_handler(file, **kwargs_complete, return_type='dict')
+                for sheet_name, df in item_dict.items():
+                    if dtype:
+                        df = df.astype(dtype)
+                    _load_df(df, sheet_name, **kwargs_data_upload)
+                
+            # LibreOffice Calc files
+            elif in_extension == SUPPORTED_EXTENSIONS[2]:
+                item_dict = ods_handler(file, **kwargs_complete, return_type='dict')
+                for sheet_name, df in item_dict.items():
+                    if dtype:
+                        df = df.astype(dtype)
+                    _load_df(df, sheet_name, **kwargs_data_upload)
+                    
+        except ValueError:
+            # Handle ValueError for unsupported data types
+            raise ValueError(format_string(UNSUPPORTED_DTYPE_ERROR_TEMPLATE, file))
+        except TypeError:
+            # Handle TypeError for incorrect dtype_dict type
+            dtype_arg_type = get_type_str(dtype_dict)
+            format_args_type_error = [file, function_arg_names[dtype_dict_arg_pos], dtype_arg_type]
+            raise TypeError(INCORRECT_ARG_TYPE_TEMPLATE, format_args_type_error)
+        
+
+#--------------------------#
+# Parameters and constants #
+#--------------------------#
+
+# File extensions #
+SUPPORTED_EXTENSIONS = ["csv", "xlsx", "ods"]
+
+# Template strings #
+#------------------#
+
+# Informative strings #
+SUCCESS_DATA_LOAD_TEMPLATE = """Data successfully loaded:
+Database : {}
+Table : {}
+"""
+
+# Error strings #
+UNSUPPORTED_DTYPE_ERROR_TEMPLATE = "File: {}\nUnsupported data type(s) provided"
+INCORRECT_ARG_TYPE_TEMPLATE = "File: {}\nExpected dictionary for argument '{}', got {}"
+
+# Database configuration #
+#-----------------------#
+
+# Database aliases #
+DATABASE_ALIAS_DICT = {
+    "mysql": "mysql+pymysql",
+    "postgresql": "postgresql",
+    "sqlite": "sqlite"
+}
+
+# Success messages #
+SUCCESS_USER_INSERT = "Usuario insertado exitosamente."
+EMAIL_EXISTS_ERROR = "El correo electrónico ya existe."
+PHONE_EXISTS_ERROR = "El teléfono ya existe."