Module osbot_utils.utils.Files

def all_parent_folders(path=None, include_path=False):
    if path is None:
        path = os.getcwd()
    parent_directories = []

    # Optionally include the starting path
    if include_path:
        parent_directories.append(path)

    while True:                                         # Split the path into parts
        path, tail = os.path.split(path)
        if tail:
            parent_directories.append(path)
        else:
            if path and path not in parent_directories:  # to handle the root path case
                parent_directories.append(path)
            break

    return parent_directories

@staticmethod
def write_bytes(path=None, bytes=None, extension=None):
    return Files.write(path=path, contents=bytes, extension=extension, mode='wb')

@staticmethod
def folder_create(path):
    if folder_exists(path):
        return path

    os.makedirs(path)
    return path

@staticmethod
def folder_create_in_parent(path, name):
    folder_path = path_combine(path, name)
    return folder_create(folder_path)

@staticmethod
def write(path = None,contents=None, extension=None, mode='w'):
    path     = path or temp_file(extension)
    contents = contents or ''
    with open(file=path, mode=mode) as file:
        file.write(contents)
    return path

@staticmethod
def current_folder():
    return Files.path_combine(".","")

@staticmethod
def temp_folder_current():
    return tempfile.gettempdir()

@staticmethod
def bytes(path):
    with open(path, 'rb') as file:
        return file.read()

@staticmethod
def contains(path, content):
    text = Files.contents(path)
    if type(content) is list:
        for item in content:
            if item not in text:
                return False
        return True
    return content in text

@staticmethod
def contents(path, mode='rt'):
    if file_exists(path):
        with file_open(path, mode) as file:
            return file.read()

@staticmethod
def bytes(path):
    with open(path, 'rb') as file:
        return file.read()

@staticmethod
def contents_gz(path, mode='rt'):
    if file_exists(path):
        with file_open_gz(path, mode) as file:
            return file.read()

@staticmethod
def contents_md5(path):
    from osbot_utils.utils.Misc import bytes_md5
    return bytes_md5(file_contents_as_bytes(path))

@staticmethod
def contents_sha256(path):
    from osbot_utils.utils.Misc import bytes_sha256
    return bytes_sha256(file_contents_as_bytes(path))

@staticmethod
def copy(source:str, destination:str) -> str:
    if file_exists(source):                                     # make sure source file exists
        destination_parent_folder = parent_folder(destination)  # get target parent folder
        folder_create(destination_parent_folder)                # ensure target folder exists       # todo: check if this is still needed (we should be using a copy method that creates the required fodlers)
        return shutil.copy(source, destination)                 # copy file and returns file destination

@staticmethod
def write(path = None,contents=None, extension=None, mode='w'):
    path     = path or temp_file(extension)
    contents = contents or ''
    with open(file=path, mode=mode) as file:
        file.write(contents)
    return path

@staticmethod
def file_create_all_parent_folders(file_path):
    if file_path:
        parent_path = parent_folder(file_path)
        if parent_path:
            path        = Path(parent_path)
            path.mkdir(parents=True, exist_ok=True)
            return parent_path

@staticmethod
def write_bytes(path=None, bytes=None, extension=None):
    return Files.write(path=path, contents=bytes, extension=extension, mode='wb')

@staticmethod
def write_bytes(path=None, bytes=None, extension=None):
    return Files.write(path=path, contents=bytes, extension=extension, mode='wb')

@staticmethod
def write_gz(path=None, contents=None):
    path = path or temp_file(extension='.gz')
    contents = contents or ''
    if type(contents) is str:
        contents = contents.encode()
    with gzip.open(path, "w") as file:
        file.write(contents)
    return path

@staticmethod
def delete(path):
    if Files.exists(path):
        os.remove(path)
        return Files.exists(path) is False
    return False

@staticmethod
def exists(path):
    return is_file(str(path))
    # if path and is_file(path):
    #     return os.path.exists(path)
    # return False

@staticmethod
def file_extension(path):
    if path and '.' in path:
        return os.path.splitext(path)[1]
    return ''

@staticmethod
def file_extension_fix(extension):
    if extension is None or len(extension) == 0:        # if it None or empty return default .tmp extension
        return '.tmp'
    if extension[0] != '.':                             # make sure that the extension starts with a dot
        return '.' + extension
    return extension

@staticmethod
def file_from_base64(bytes_base64, path=None, extension=None):
    bytes_ = base64_to_bytes(bytes_base64)
    return file_create_bytes(bytes=bytes_, path=path, extension=None)

@staticmethod
def write_bytes(path=None, bytes=None, extension=None):
    return Files.write(path=path, contents=bytes, extension=extension, mode='wb')

@staticmethod
def lines(path):
    with open(path, "rt") as file:
        for line in file:
            yield line

@staticmethod
def lines_gz(path):
    with gzip.open(path, "rt") as file:
        for line in file:
            yield line

@staticmethod
def contents_md5(path):
    from osbot_utils.utils.Misc import bytes_md5
    return bytes_md5(file_contents_as_bytes(path))

def file_move(source_file, target_file):
    if file_exists(source_file):
        file_copy(source_file, target_file)
        if file_exists(target_file):
            if file_delete(source_file):
                return True
    return False

@staticmethod
def file_name(path, check_if_exists=True):
    if is_file(path) or check_if_exists is False:
        return os.path.basename(path)

@staticmethod
def file_name_without_extension(path):
    if path:
        path_file_name = file_name(path)
        extension = file_extension(path_file_name)
        if extension:
            return path_file_name.replace(extension, '')

@staticmethod
def not_exists(path):
    return os.path.exists(str(path)) is False

@staticmethod
def open(path, mode='r'):
    return open(path, mode=mode)

@staticmethod
def open_bytes(path):
    return Files.open(path, mode='rb')

@staticmethod
def open_gz(path, mode='r'):
    return gzip.open(path, mode=mode)

@staticmethod
def save(contents, path=None, extension=None):
    path = path or temp_file(extension=extension)
    file_create(path, contents)
    return path

@staticmethod
def contents_sha256(path):
    from osbot_utils.utils.Misc import bytes_sha256
    return bytes_sha256(file_contents_as_bytes(path))

@staticmethod
def file_size(path):
    return file_stats(path).st_size

@staticmethod
def file_stats(path):
    return os.stat(path)

@staticmethod
def file_to_base64(path):
    return bytes_to_base64(file_bytes(path))

@staticmethod
def write(path = None,contents=None, extension=None, mode='w'):
    path     = path or temp_file(extension)
    contents = contents or ''
    with open(file=path, mode=mode) as file:
        file.write(contents)
    return path

@staticmethod
def write_bytes(path=None, bytes=None, extension=None):
    return Files.write(path=path, contents=bytes, extension=extension, mode='wb')

@staticmethod
def write_gz(path=None, contents=None):
    path = path or temp_file(extension='.gz')
    contents = contents or ''
    if type(contents) is str:
        contents = contents.encode()
    with gzip.open(path, "w") as file:
        file.write(contents)
    return path

@staticmethod
def find(path_pattern, recursive=True):
    return glob.glob(path_pattern, recursive=recursive)

@staticmethod
def files(path, pattern= '*.*'):                        # todo: check behaviour and improve ability to detect file (vs folders)
    result = []
    for file in Path(path).rglob(pattern):
        result.append(str(file))                        # todo: see if there is a better way to do this conversion to string
    return sorted(result)

@staticmethod
def files_names(files : list, check_if_exists=True):
    result = []
    for file in files:
        if is_file(file):
            result.append(file_name(file, check_if_exists=check_if_exists))
    return result

@staticmethod
def files_recursive(parent_dir, include_folders=False):
    all_files = []
    if os.path.isdir(parent_dir):
        for item in os.listdir(parent_dir):
            item_path = os.path.join(parent_dir, item)
            if os.path.isfile(item_path):
                all_files.append(item_path)
            elif os.path.isdir(item_path):
                if include_folders:
                    all_files.append(item_path + '/')
                all_files.extend(files_recursive(item_path,include_folders=include_folders))


    return sorted(all_files)

@staticmethod
def filter_parent_folder(items, folder):
    all_relative_items = []
    for item in items:
        all_relative_items.append(item.replace(folder, '')[1:])
    return sorted(all_relative_items)

@staticmethod
def files(path, pattern= '*.*'):                        # todo: check behaviour and improve ability to detect file (vs folders)
    result = []
    for file in Path(path).rglob(pattern):
        result.append(str(file))                        # todo: see if there is a better way to do this conversion to string
    return sorted(result)

@staticmethod
def folder_copy(source, destination, ignore_pattern=None):
    if ignore_pattern:
        if type(ignore_pattern) is str:
            ignore_pattern = [ignore_pattern]
        ignore = shutil.ignore_patterns(*ignore_pattern)            # for example ignore_pattern = ['*.pyc','.DS_Store']
    else:
        ignore = None
    return shutil.copytree(src=source, dst=destination, ignore=ignore)

@staticmethod
def folder_copy(source, destination, ignore_pattern=None):
    if ignore_pattern:
        if type(ignore_pattern) is str:
            ignore_pattern = [ignore_pattern]
        ignore = shutil.ignore_patterns(*ignore_pattern)            # for example ignore_pattern = ['*.pyc','.DS_Store']
    else:
        ignore = None
    return shutil.copytree(src=source, dst=destination, ignore=ignore)

@staticmethod
def folder_create(path):
    if folder_exists(path):
        return path

    os.makedirs(path)
    return path

@staticmethod
def folder_create_in_parent(path, name):
    folder_path = path_combine(path, name)
    return folder_create(folder_path)

@staticmethod
def temp_folder(prefix=None, suffix=None,target_folder=None):
    return tempfile.mkdtemp(suffix, prefix, target_folder)

@staticmethod
def folder_delete(target_folder):
    if folder_exists(target_folder):
        try:
            os.rmdir(target_folder)
            return True
        except OSError:
            pass
    return False

@staticmethod
def folder_delete_all(path):                # this will remove recursively
    if folder_exists(path):
        shutil.rmtree(path)
        return folder_exists(path) is False
    return False

@staticmethod
def folder_delete_all(path):                # this will remove recursively
    if folder_exists(path):
        shutil.rmtree(path)
        return folder_exists(path) is False
    return False

@staticmethod
def folder_exists(path):
    return is_folder(path)

@staticmethod
def files(path, pattern= '*.*'):                        # todo: check behaviour and improve ability to detect file (vs folders)
    result = []
    for file in Path(path).rglob(pattern):
        result.append(str(file))                        # todo: see if there is a better way to do this conversion to string
    return sorted(result)

@staticmethod
def folder_name(path):
    if path:
        return os.path.basename(path)

@staticmethod
def folder_not_exists(path):
    return folder_exists(path) is False

@staticmethod
def folder_sub_folders(path):
    result = []
    item: os.DirEntry
    if Files.is_folder(path):
        for item in os.scandir(path):
            if item.is_dir():
                result.append(item.path)
    return result

@staticmethod
def temp_folder(prefix=None, suffix=None,target_folder=None):
    return tempfile.mkdtemp(suffix, prefix, target_folder)

@staticmethod
def folder_sub_folders(path):
    result = []
    item: os.DirEntry
    if Files.is_folder(path):
        for item in os.scandir(path):
            if item.is_dir():
                result.append(item.path)
    return result

@staticmethod
def folders_names(folders : list):
    result = []
    for folder in folders:
        if folder:
            result.append(folder_name(folder))
    return sorted(result)

def folders_names_in_folder(target):
    folders = folders_in_folder(target)
    return folders_names(folders)

@staticmethod
def folders_recursive(parent_dir):
    subdirectories = []
    for item in os.listdir(parent_dir):
        item_path = os.path.join(parent_dir, item)
        if os.path.isdir(item_path):
            subdirectories.append(item_path)
            subdirectories.extend(folders_recursive(item_path))

    return sorted(subdirectories)

@staticmethod
def folders_sub_folders(folders : list):
    result = []
    for folder in folders:
        result.extend(Files.folder_sub_folders(folder))
    return result

@staticmethod
def is_file(target):
    if isinstance(target, Path):
        return target.is_file()
    if type(target) is str:
        return os.path.isfile(target)
    return False

@staticmethod
def is_folder(target):
    if isinstance(target, Path):
        return target.is_dir()
    if type(target) is str:
        return os.path.isdir(target)
    return False

@staticmethod
def contents(path, mode='rt'):
    if file_exists(path):
        with file_open(path, mode) as file:
            return file.read()

@staticmethod
def contents_gz(path, mode='rt'):
    if file_exists(path):
        with file_open_gz(path, mode) as file:
            return file.read()

@staticmethod
def parent_folder(path):
    if path:
        return os.path.dirname(path)

@staticmethod
def parent_folder_combine(file, path):
    return Files.path_combine(os.path.dirname(file),path)

@staticmethod
def path_combine(path1, path2):
    if type(path1) in [str, Path] and type(path2) in [str, Path]:
        parent_path = str(path1)
        sub_path    = str(path2)
        if sub_path.startswith('/'):
            sub_path = sub_path[1:]
        return abspath(join(parent_path,sub_path))

@staticmethod
def path_combine(path1, path2):
    if type(path1) in [str, Path] and type(path2) in [str, Path]:
        parent_path = str(path1)
        sub_path    = str(path2)
        if sub_path.startswith('/'):
            sub_path = sub_path[1:]
        return abspath(join(parent_path,sub_path))

@staticmethod
def current_folder():
    return Files.path_combine(".","")

@staticmethod
def pickle_load_from_file(path=None):
    file_to_read = open(path, "rb")
    loaded_object = pickle.load(file_to_read)
    file_to_read.close()
    return loaded_object

@staticmethod
def pickle_save_to_file(object_to_save, path=None):
    path = path or temp_file(extension=".pickle")
    file_to_store = open(path, "wb")
    pickle.dump(object_to_save, file_to_store)
    file_to_store.close()
    return path

@staticmethod
def safe_file_name(file_name):
    if type(file_name) is not str:
        file_name = f"{file_name}"
    return re.sub(r'[^a-zA-Z0-9_.-]', '_',file_name or '')

@staticmethod
def save_bytes_as_file(bytes_to_save, path=None, extension=None):
    if path is None:
        path = Files.temp_file(extension)
    with open(path, 'wb') as fp:
        fp.write(bytes_to_save)
    return path

@staticmethod
def save(contents, path=None, extension=None):
    path = path or temp_file(extension=extension)
    file_create(path, contents)
    return path

def stream_to_bytes(stream):
    return stream.read()

def stream_to_file(stream, path=None):
    if path is None:                        # if path is not defined
        path = Files.temp_file()            # save it to a temp file
    with open(path, 'wb') as file:          # Write the content to the file
        file.write(stream.read())
    return path

@staticmethod
def sub_folders(target):
    if type(target) is list:
        return Files.folders_sub_folders(target)
    if type(target) is str:
        return Files.folder_sub_folders(target)
    return []

@staticmethod
def temp_file(extension = '.tmp', contents=None, target_folder=None):
    extension = file_extension_fix(extension)
    if target_folder is None:
        (fd, tmp_file) = tempfile.mkstemp(extension)
        file_delete(tmp_file)
    else:
        tmp_file = path_combine(target_folder, temp_filename(extension))

    if contents:
        file_create(tmp_file, contents)
    return tmp_file

@staticmethod
def temp_file_in_folder(target_folder, prefix="temp_file_", postfix='.txt'):
    if is_folder(target_folder):
        path_to_file = path_combine(target_folder, random_string(prefix=prefix, postfix=postfix))
        file_create(path_to_file, random_string())
        return path_to_file

@staticmethod
def temp_filename(extension='.tmp'):
    return file_name(temp_file(extension), check_if_exists=False)

@staticmethod
def temp_folder(prefix=None, suffix=None,target_folder=None):
    return tempfile.mkdtemp(suffix, prefix, target_folder)

@staticmethod
def temp_folder_current():
    return tempfile.gettempdir()

@staticmethod
def temp_folder_with_temp_file(prefix=None, suffix=None,parent_folder=None, file_name='temp_file.txt', file_contents='temp_file'):
    folder = temp_folder(prefix,suffix,parent_folder)
    file_create(path_combine(folder,file_name), file_contents)
    return folder

class Files:
    @staticmethod
    def bytes(path):
        with open(path, 'rb') as file:
            return file.read()

    @staticmethod
    def copy(source:str, destination:str) -> str:
        if file_exists(source):                                     # make sure source file exists
            destination_parent_folder = parent_folder(destination)  # get target parent folder
            folder_create(destination_parent_folder)                # ensure target folder exists       # todo: check if this is still needed (we should be using a copy method that creates the required fodlers)
            return shutil.copy(source, destination)                 # copy file and returns file destination

    @staticmethod
    def contains(path, content):
        text = Files.contents(path)
        if type(content) is list:
            for item in content:
                if item not in text:
                    return False
            return True
        return content in text

    @staticmethod
    def contents(path, mode='rt'):
        if file_exists(path):
            with file_open(path, mode) as file:
                return file.read()

    @staticmethod
    def contents_gz(path, mode='rt'):
        if file_exists(path):
            with file_open_gz(path, mode) as file:
                return file.read()

    @staticmethod
    def contents_md5(path):
        from osbot_utils.utils.Misc import bytes_md5
        return bytes_md5(file_contents_as_bytes(path))

    @staticmethod
    def contents_sha256(path):
        from osbot_utils.utils.Misc import bytes_sha256
        return bytes_sha256(file_contents_as_bytes(path))

    @staticmethod
    def current_folder():
        return Files.path_combine(".","")

    @staticmethod
    def delete(path):
        if Files.exists(path):
            os.remove(path)
            return Files.exists(path) is False
        return False

    @staticmethod
    def exists(path):
        return is_file(str(path))
        # if path and is_file(path):
        #     return os.path.exists(path)
        # return False

    @staticmethod
    def find(path_pattern, recursive=True):
        return glob.glob(path_pattern, recursive=recursive)

    @staticmethod
    def files(path, pattern= '*.*'):                        # todo: check behaviour and improve ability to detect file (vs folders)
        result = []
        for file in Path(path).rglob(pattern):
            result.append(str(file))                        # todo: see if there is a better way to do this conversion to string
        return sorted(result)

    @staticmethod
    def files_names(files : list, check_if_exists=True):
        result = []
        for file in files:
            if is_file(file):
                result.append(file_name(file, check_if_exists=check_if_exists))
        return result

    @staticmethod
    def file_create_all_parent_folders(file_path):
        if file_path:
            parent_path = parent_folder(file_path)
            if parent_path:
                path        = Path(parent_path)
                path.mkdir(parents=True, exist_ok=True)
                return parent_path

    @staticmethod
    def file_name(path, check_if_exists=True):
        if is_file(path) or check_if_exists is False:
            return os.path.basename(path)

    @staticmethod
    def file_name_without_extension(path):
        if path:
            path_file_name = file_name(path)
            extension = file_extension(path_file_name)
            if extension:
                return path_file_name.replace(extension, '')


    @staticmethod
    def file_extension(path):
        if path and '.' in path:
            return os.path.splitext(path)[1]
        return ''

    @staticmethod
    def file_extension_fix(extension):
        if extension is None or len(extension) == 0:        # if it None or empty return default .tmp extension
            return '.tmp'
        if extension[0] != '.':                             # make sure that the extension starts with a dot
            return '.' + extension
        return extension

    @staticmethod
    def file_to_base64(path):
        return bytes_to_base64(file_bytes(path))

    @staticmethod
    def file_from_base64(bytes_base64, path=None, extension=None):
        bytes_ = base64_to_bytes(bytes_base64)
        return file_create_bytes(bytes=bytes_, path=path, extension=None)

    @staticmethod
    def file_size(path):
        return file_stats(path).st_size

    @staticmethod
    def file_stats(path):
        return os.stat(path)

    @staticmethod
    def filter_parent_folder(items, folder):
        all_relative_items = []
        for item in items:
            all_relative_items.append(item.replace(folder, '')[1:])
        return sorted(all_relative_items)

    @staticmethod
    def files_recursive(parent_dir, include_folders=False):
        all_files = []
        if os.path.isdir(parent_dir):
            for item in os.listdir(parent_dir):
                item_path = os.path.join(parent_dir, item)
                if os.path.isfile(item_path):
                    all_files.append(item_path)
                elif os.path.isdir(item_path):
                    if include_folders:
                        all_files.append(item_path + '/')
                    all_files.extend(files_recursive(item_path,include_folders=include_folders))


        return sorted(all_files)


    @staticmethod
    def folder_exists(path):
        return is_folder(path)

    @staticmethod
    def folder_copy(source, destination, ignore_pattern=None):
        if ignore_pattern:
            if type(ignore_pattern) is str:
                ignore_pattern = [ignore_pattern]
            ignore = shutil.ignore_patterns(*ignore_pattern)            # for example ignore_pattern = ['*.pyc','.DS_Store']
        else:
            ignore = None
        return shutil.copytree(src=source, dst=destination, ignore=ignore)

    @staticmethod
    def folder_create(path):
        if folder_exists(path):
            return path

        os.makedirs(path)
        return path

    @staticmethod
    def folder_create_in_parent(path, name):
        folder_path = path_combine(path, name)
        return folder_create(folder_path)

    @staticmethod
    def folder_delete(target_folder):
        if folder_exists(target_folder):
            try:
                os.rmdir(target_folder)
                return True
            except OSError:
                pass
        return False

    @staticmethod
    def folder_delete_all(path):                # this will remove recursively
        if folder_exists(path):
            shutil.rmtree(path)
            return folder_exists(path) is False
        return False

    @staticmethod
    def folder_name(path):
        if path:
            return os.path.basename(path)

    @staticmethod
    def folder_not_exists(path):
        return folder_exists(path) is False

    @staticmethod
    def folder_sub_folders(path):
        result = []
        item: os.DirEntry
        if Files.is_folder(path):
            for item in os.scandir(path):
                if item.is_dir():
                    result.append(item.path)
        return result

    @staticmethod
    def folders_names(folders : list):
        result = []
        for folder in folders:
            if folder:
                result.append(folder_name(folder))
        return sorted(result)

    @staticmethod
    def folders_sub_folders(folders : list):
        result = []
        for folder in folders:
            result.extend(Files.folder_sub_folders(folder))
        return result

    @staticmethod
    def folders_recursive(parent_dir):
        subdirectories = []
        for item in os.listdir(parent_dir):
            item_path = os.path.join(parent_dir, item)
            if os.path.isdir(item_path):
                subdirectories.append(item_path)
                subdirectories.extend(folders_recursive(item_path))

        return sorted(subdirectories)


    @staticmethod
    def is_file(target):
        if isinstance(target, Path):
            return target.is_file()
        if type(target) is str:
            return os.path.isfile(target)
        return False

    @staticmethod
    def is_folder(target):
        if isinstance(target, Path):
            return target.is_dir()
        if type(target) is str:
            return os.path.isdir(target)
        return False

    @staticmethod
    def lines(path):
        with open(path, "rt") as file:
            for line in file:
                yield line

    @staticmethod
    def lines_gz(path):
        with gzip.open(path, "rt") as file:
            for line in file:
                yield line

    @staticmethod
    def not_exists(path):
        return os.path.exists(str(path)) is False

    @staticmethod
    def open(path, mode='r'):
        return open(path, mode=mode)

    @staticmethod
    def open_gz(path, mode='r'):
        return gzip.open(path, mode=mode)

    @staticmethod
    def open_bytes(path):
        return Files.open(path, mode='rb')

    @staticmethod
    def path_combine(path1, path2):
        if type(path1) in [str, Path] and type(path2) in [str, Path]:
            parent_path = str(path1)
            sub_path    = str(path2)
            if sub_path.startswith('/'):
                sub_path = sub_path[1:]
            return abspath(join(parent_path,sub_path))

    @staticmethod
    def parent_folder(path):
        if path:
            return os.path.dirname(path)

    @staticmethod
    def parent_folder_combine(file, path):
        return Files.path_combine(os.path.dirname(file),path)

    @staticmethod
    def pickle_save_to_file(object_to_save, path=None):
        path = path or temp_file(extension=".pickle")
        file_to_store = open(path, "wb")
        pickle.dump(object_to_save, file_to_store)
        file_to_store.close()
        return path

    @staticmethod
    def pickle_load_from_file(path=None):
        file_to_read = open(path, "rb")
        loaded_object = pickle.load(file_to_read)
        file_to_read.close()
        return loaded_object

    @staticmethod
    def safe_file_name(file_name):
        if type(file_name) is not str:
            file_name = f"{file_name}"
        return re.sub(r'[^a-zA-Z0-9_.-]', '_',file_name or '')

    @staticmethod
    def save(contents, path=None, extension=None):
        path = path or temp_file(extension=extension)
        file_create(path, contents)
        return path

    @staticmethod
    def sub_folders(target):
        if type(target) is list:
            return Files.folders_sub_folders(target)
        if type(target) is str:
            return Files.folder_sub_folders(target)
        return []

    @staticmethod
    def save_bytes_as_file(bytes_to_save, path=None, extension=None):
        if path is None:
            path = Files.temp_file(extension)
        with open(path, 'wb') as fp:
            fp.write(bytes_to_save)
        return path

    @staticmethod
    def temp_file(extension = '.tmp', contents=None, target_folder=None):
        extension = file_extension_fix(extension)
        if target_folder is None:
            (fd, tmp_file) = tempfile.mkstemp(extension)
            file_delete(tmp_file)
        else:
            tmp_file = path_combine(target_folder, temp_filename(extension))

        if contents:
            file_create(tmp_file, contents)
        return tmp_file

    @staticmethod
    def temp_file_in_folder(target_folder, prefix="temp_file_", postfix='.txt'):
        if is_folder(target_folder):
            path_to_file = path_combine(target_folder, random_string(prefix=prefix, postfix=postfix))
            file_create(path_to_file, random_string())
            return path_to_file

        

    @staticmethod
    def temp_filename(extension='.tmp'):
        return file_name(temp_file(extension), check_if_exists=False)

    @staticmethod
    def temp_folder(prefix=None, suffix=None,target_folder=None):
        return tempfile.mkdtemp(suffix, prefix, target_folder)

    @staticmethod
    def temp_folder_current():
        return tempfile.gettempdir()

    @staticmethod
    def temp_folder_with_temp_file(prefix=None, suffix=None,parent_folder=None, file_name='temp_file.txt', file_contents='temp_file'):
        folder = temp_folder(prefix,suffix,parent_folder)
        file_create(path_combine(folder,file_name), file_contents)
        return folder

    @staticmethod
    def write(path = None,contents=None, extension=None, mode='w'):
        path     = path or temp_file(extension)
        contents = contents or ''
        with open(file=path, mode=mode) as file:
            file.write(contents)
        return path

    @staticmethod
    def write_bytes(path=None, bytes=None, extension=None):
        return Files.write(path=path, contents=bytes, extension=extension, mode='wb')

    @staticmethod
    def write_gz(path=None, contents=None):
        path = path or temp_file(extension='.gz')
        contents = contents or ''
        if type(contents) is str:
            contents = contents.encode()
        with gzip.open(path, "w") as file:
            file.write(contents)
        return path