Source code for cgl.core.utils.read_write

import json
import logging
import os
from zipfile import ZipFile, ZIP_DEFLATED
import yaml




def unzip(zipped_file, destination, password=None):
    """
    Args:
        zipped_file:
        destination:
        password:

    Returns:
        destination path
    """
    logging.info("unzipping %s" % zipped_file)
    with ZipFile(zipped_file, "r") as zipObj:
        zipObj.extractall(path=destination, pwd=password)
    return destination





def zip_path(source_path, zip_file):
    """
    built to handle both files and folders as "source_path"

    Args:
        source_path:
        zip_file:

    Returns:
    """

    if os.path.isdir(source_path):
        zipf = ZipFile(zip_file, "w", ZIP_DEFLATED)
        zip_dir(source_path, zipf)
        zipf.close()





def zip_dir(folder_path, zip_file):
    """
    zipes a file or folder

    Args:
        folder_path:
        zip_file:

    Return:

    """
    if os.path.isdir(folder_path):
        for root, dirs, files in os.walk(folder_path):
            for file in files:
                zip_file.write(
                    os.path.join(root, file),
                    os.path.relpath(
                        os.path.join(root, file), os.path.join(folder_path, "..")
                    ),
                )





def load_json(filepath):
    """
    Loads a .json file in as a dictionary

    Args:
        filepath:

    Return:
        data: dictionary
    """
    with open(filepath) as jsonfile:
        data = json.load(jsonfile)
    return data





def load_yaml(filepath):
    """Loads a .yaml file in as a dictionary

    Args:
        filepath:

    Returns:
        data: dictionary
    """
    if not os.path.isfile(filepath):
        logging.error("File not found: %s" % filepath)
        return {}
    with open(filepath, "r") as yamlfile:
        data = yaml.safe_load(yamlfile)
    return data





def save_json(filepath, data):
    """
    Saves a Dictionary as a .json file.

    Args:
        filepath:
        data: dictionary
    """
    with open(filepath, "w") as outfile:
        json.dump(data, outfile, indent=4, sort_keys=True)





class NoAliasDumper(yaml.Dumper):


    def ignore_aliases(self, data):
        return True






def save_yaml(filepath, data):
    """
    Saves a Dictionary as a .json file.

    Args:
        filepath:
        data: dictionary
    """
    with open(filepath, "w", encoding="utf-8") as f:
        yaml.dump(
            data,
            f,
            Dumper=NoAliasDumper,  # <- key line
            sort_keys=False,
            allow_unicode=True,
            width=1000,
        )





def save_xml(filepath, data):
    """
    saves a dictionary as an xml file

    Args:
        filepath:
        data:
    """
    import xmltodict

    with open(filepath, "w") as outfile:
        outfile.write(xmltodict.unparse(data))





def load_xml(filepath):
    """
    loads an xml as a dictionary

    Args:
        filepath:

    Returns:
        docs: dictionary
    """
    import xmltodict

    with open(filepath) as xmlfile:
        docs = xmltodict.parse(xmlfile.read())
    return docs



# def load_style_sheet(style_file="stylesheet.css"):
#     """
#     Loads the main style sheet for cglumberjack.
#
#     Args:
#         style_file:
#
#     Returns:
#         data: string
#     """
#     file_ = os.path.join(
#         __file__.split("cglumberjack")[0], "cglumberjack", "resources", style_file
#     )
#     f = open(file_, "r")
#     data = f.read()
#     data.strip("\n")
#     return data




def load_text_file(file_path):
    file_obj = open(file_path, "r", encoding="utf-8")
    lines = file_obj.readlines()
    file_obj.close()
    return lines





def save_text_lines(text_array, file_path):
    """
    this expects to get typical text that would print normally.

    Args:
        text_array:
        file_path:

    """
    file_object = open(file_path, "w")
    file_object.writelines(text_array)
    file_object.close()