change hash to sha256

/extensions

/test/stdout.txt

/test/stderr.txt

/cache.json

        return upscalers

    def get_sd_models(self):

        return [{"title":x.title, "model_name":x.model_name, "hash":x.hash, "filename": x.filename, "config": find_checkpoint_config(x)} for x in checkpoints_list.values()]

        return [{"title": x.title, "model_name": x.model_name, "hash": x.shorthash, "sha256": x.sha256, "filename": x.filename, "config": find_checkpoint_config(x)} for x in checkpoints_list.values()]

    def get_hypernetworks(self):

        return [{"name": name, "path": shared.hypernetworks[name]} for name in shared.hypernetworks]

class SDModelItem(BaseModel):

    title: str = Field(title="Title")

    model_name: str = Field(title="Model Name")

    hash: str = Field(title="Hash")

    hash: Optional[str] = Field(title="Short hash")

    sha256: Optional[str] = Field(title="sha256 hash")

    filename: str = Field(title="Filename")

    config: str = Field(title="Config file")

import hashlib

import json

import os.path

import filelock

cache_filename = "cache.json"

cache_data = None

def dump_cache():

    with filelock.FileLock(cache_filename+".lock"):

        with open(cache_filename, "w", encoding="utf8") as file:

            json.dump(cache_data, file, indent=4)

def cache(subsection):

    global cache_data

    if cache_data is None:

        with filelock.FileLock(cache_filename+".lock"):

            if not os.path.isfile(cache_filename):

                cache_data = {}

            else:

                with open(cache_filename, "r", encoding="utf8") as file:

                    cache_data = json.load(file)

    s = cache_data.get(subsection, {})

    cache_data[subsection] = s

    return s

def calculate_sha256(filename):

    hash_sha256 = hashlib.sha256()

    with open(filename, "rb") as f:

        for chunk in iter(lambda: f.read(4096), b""):

            hash_sha256.update(chunk)

    return hash_sha256.hexdigest()

def sha256(filename, title):

    hashes = cache("hashes")

    ondisk_mtime = os.path.getmtime(filename)

    if title in hashes:

        cached_sha256 = hashes[title].get("sha256", None)

        cached_mtime = hashes[title].get("mtime", 0)

        if ondisk_mtime <= cached_mtime and cached_sha256 is not None:

            return cached_sha256

    print(f"Calculating sha256 for {filename}: ", end='')

    sha256_value = calculate_sha256(filename)

    print(f"{sha256_value}")

    hashes[title] = {

        "mtime": ondisk_mtime,

        "sha256": sha256_value,

    }

    dump_cache()

    return sha256_value

    if shared.opts.save_training_settings_to_txt:

        saved_params = dict(

            model_name=checkpoint.model_name, model_hash=checkpoint.hash, num_of_dataset_images=len(ds),

            model_name=checkpoint.model_name, model_hash=checkpoint.shorthash, num_of_dataset_images=len(ds),

            **{field: getattr(hypernetwork, field) for field in ['layer_structure', 'activation_func', 'weight_init', 'add_layer_norm', 'use_dropout', ]}

        )

        logging.save_settings_to_file(log_directory, {**saved_params, **locals()})

    old_sd_checkpoint = hypernetwork.sd_checkpoint if hasattr(hypernetwork, "sd_checkpoint") else None

    old_sd_checkpoint_name = hypernetwork.sd_checkpoint_name if hasattr(hypernetwork, "sd_checkpoint_name") else None

    try:

        hypernetwork.sd_checkpoint = checkpoint.hash

        hypernetwork.sd_checkpoint = checkpoint.shorthash

        hypernetwork.sd_checkpoint_name = checkpoint.model_name

        hypernetwork.name = hypernetwork_name

        hypernetwork.save(filename)