|
import os |
|
import platform |
|
import sys |
|
import typing as t |
|
|
|
import psutil |
|
import torch |
|
|
|
import launch |
|
from modules import shared |
|
from scripts.msai_logging.msai_logger import Logger |
|
from scripts.msai_utils import msai_toolkit as toolkit |
|
from scripts.msai_utils.msai_singleton import MiaoshouSingleton |
|
import modules |
|
|
|
|
|
class MiaoshouPrelude(metaclass=MiaoshouSingleton): |
|
_dataset = None |
|
|
|
def __init__(self) -> None: |
|
|
|
if MiaoshouPrelude._dataset is None: |
|
self._init_constants() |
|
|
|
MiaoshouPrelude._dataset = { |
|
"log_folder": os.path.join(self.ext_folder, "logs") |
|
} |
|
|
|
disable_log_console_output: bool = False |
|
if self.all_settings.get("boot_settings"): |
|
if self.all_settings["boot_settings"].get("disable_log_console_output") is not None: |
|
disable_log_console_output = self.all_settings["boot_settings"].get("disable_log_console_output") |
|
|
|
self._logger = Logger(self._dataset["log_folder"], disable_console_output=disable_log_console_output) |
|
|
|
def _init_constants(self) -> None: |
|
self._api_url = { |
|
"civitai.com": "https://model-share.com/v1/models", |
|
"liandange.com": "https://model-api.liandange.com/model/api/models", |
|
} |
|
self._ext_folder = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..")) |
|
self._setting_file = os.path.join(self.ext_folder, "configs", "settings.json") |
|
self._model_hash_file = os.path.join(self.ext_folder, "configs", "model_hash.json") |
|
self._gpt_index = os.path.join(self.ext_folder, "configs", "gpt_index.json") |
|
self._assets_folder = os.path.join(self.ext_folder, "assets") |
|
self._cache_folder = os.path.join(self.ext_folder, "cache") |
|
self._cover_folder = os.path.join(self.ext_folder, "covers") |
|
self._no_preview_img = os.path.join(modules.paths.script_path, "html", "card-no-preview.png") |
|
self._model_json = { |
|
'civitai.com': os.path.join(self.ext_folder, 'configs', 'civitai_models.json'), |
|
'liandange.com': os.path.join(self.ext_folder, 'configs', 'liandange_models.json'), |
|
'official_models': os.path.join(self.ext_folder, 'configs', 'official_models.json'), |
|
'hugging_face': os.path.join(self.ext_folder, 'configs', 'hugging_face.json'), |
|
'controlnet': os.path.join(self.ext_folder, 'configs', 'controlnet.json') |
|
} |
|
self._checkboxes = { |
|
'Enable xFormers': '--xformers', |
|
'No Half': '--no-half', |
|
'No Half VAE': '--no-half-vae', |
|
'Enable API': '--api', |
|
'Auto Launch': '--autolaunch', |
|
'Allow Local Network Access': '--listen', |
|
} |
|
|
|
self._gpu_setting = { |
|
'CPU Only': '--precision full --no-half --use-cpu SD GFPGAN BSRGAN ESRGAN SCUNet CodeFormer --all', |
|
'GTX 16xx': '--lowvram --xformers --precision full --no-half', |
|
'Low: 4-6G VRAM': '--xformers --lowvram', |
|
'Med: 6-8G VRAM': '--xformers --medvram', |
|
'Normal: 8+G VRAM': '', |
|
} |
|
|
|
self._theme_setting = { |
|
'Auto': '', |
|
'Light Mode': '--theme light', |
|
'Dark Mode': '--theme dark', |
|
} |
|
self._ENV_EXCLUSION = ['COLAB_GPU', 'RUNPOD_POD_ID'] |
|
self._model_type = {'Checkpoint': f'{os.path.join(shared.models_path,"Stable-diffusion")}', |
|
'LORA': f'{os.path.join(shared.models_path,"Lora")}', |
|
'LoCon': f'{os.path.join(shared.models_path, "LyCORIS")}', |
|
"TextualInversion": f'{os.path.join(shared.script_path,"embeddings")}', |
|
"Hypernetwork": f'{os.path.join(shared.models_path,"hypernetworks")}' |
|
} |
|
|
|
self._gpt_type = ['gpt-3.5-turbo', 'text-davinci-003'] |
|
|
|
@property |
|
def ext_folder(self) -> str: |
|
return self._ext_folder |
|
|
|
@property |
|
def log_folder(self) -> str: |
|
return self._dataset.get("log_folder") |
|
|
|
@property |
|
def all_settings(self) -> t.Any: |
|
return toolkit.read_json(self._setting_file) |
|
|
|
@property |
|
def boot_settings(self) -> t.Any: |
|
all_setting = self.all_settings |
|
if all_setting: |
|
return all_setting['boot_settings'] |
|
else: |
|
return None |
|
|
|
def api_url(self, model_source: str) -> t.Optional[str]: |
|
return self._api_url.get(model_source) |
|
|
|
@property |
|
def setting_file(self) -> str: |
|
return self._setting_file |
|
|
|
@property |
|
def ENV_EXCLUSION(self) -> list[str]: |
|
return self._ENV_EXCLUSION |
|
|
|
@property |
|
def model_hash_file(self) -> str: |
|
return self._model_hash_file |
|
|
|
@property |
|
def gpt_index(self) -> str: |
|
return self._gpt_index |
|
|
|
@property |
|
def cache_folder(self) -> str: |
|
return self._cache_folder |
|
|
|
@property |
|
def assets_folder(self) -> str: |
|
return self._assets_folder |
|
|
|
@property |
|
def cover_folder(self) -> str: |
|
return self._cover_folder |
|
|
|
@property |
|
def no_preview_img(self) -> str: |
|
return self._no_preview_img |
|
|
|
@property |
|
def checkboxes(self) -> t.Dict[str, str]: |
|
return self._checkboxes |
|
|
|
@property |
|
def gpu_setting(self) -> t.Dict[str, str]: |
|
return self._gpu_setting |
|
|
|
@property |
|
def theme_setting(self) -> t.Dict[str, str]: |
|
return self._theme_setting |
|
|
|
@property |
|
def model_type(self) -> t.Dict[str, str]: |
|
return self._model_type |
|
|
|
@property |
|
def gpt_type(self) -> t.Dict[str, str]: |
|
return self._gpt_type |
|
|
|
@property |
|
def model_json(self) -> t.Dict[str, t.Any]: |
|
return self._model_json |
|
|
|
def update_model_json(self, site: str, models: t.Dict[str, t.Any]) -> None: |
|
if self._model_json.get(site) is None: |
|
self._logger.error(f"cannot save model info for {site}") |
|
return |
|
|
|
self._logger.info(f"{self._model_json[site]} updated") |
|
toolkit.write_json(self._model_json[site], models) |
|
|
|
def load(self) -> None: |
|
self._logger.info("start to do prelude") |
|
self._logger.info(f"cmdline args: {' '.join(sys.argv[1:])}") |
|
|
|
@classmethod |
|
def get_sys_info(cls) -> str: |
|
sys_info = 'System Information\n\n' |
|
|
|
sys_info += r'OS Name: {0} {1}'.format(platform.system(), platform.release()) + '\n' |
|
sys_info += r'OS Version: {0}'.format(platform.version()) + '\n' |
|
sys_info += r'WebUI Version: {0}'.format( |
|
f'https://github.com/AUTOMATIC1111/stable-diffusion-webui/commit/{launch.commit_hash()}') + '\n' |
|
sys_info += r'Torch Version: {0}'.format(getattr(torch, '__long_version__', torch.__version__)) + '\n' |
|
sys_info += r'Python Version: {0}'.format(sys.version) + '\n\n' |
|
sys_info += r'CPU: {0}'.format(platform.processor()) + '\n' |
|
sys_info += r'CPU Cores: {0}/{1}'.format(psutil.cpu_count(logical=False), psutil.cpu_count(logical=True)) + '\n' |
|
|
|
try: |
|
sys_info += r'CPU Frequency: {0} GHz'.format(round(psutil.cpu_freq().max/1000,2)) + '\n' |
|
except Exception as e: |
|
sys_info += r'CPU Frequency: N/A GHz' + '\n' |
|
|
|
sys_info += r'CPU Usage: {0}%'.format(psutil.cpu_percent()) + '\n\n' |
|
sys_info += r'RAM: {0}'.format(toolkit.get_readable_size(psutil.virtual_memory().total)) + '\n' |
|
sys_info += r'Memory Usage: {0}%'.format(psutil.virtual_memory().percent) + '\n\n' |
|
for i in range(torch.cuda.device_count()): |
|
sys_info += r'Graphics Card{0}: {1} ({2})'.format(i, torch.cuda.get_device_properties(i).name, |
|
toolkit.get_readable_size( |
|
torch.cuda.get_device_properties( |
|
i).total_memory)) + '\n' |
|
sys_info += r'Available VRAM: {0}'.format(toolkit.get_readable_size(torch.cuda.mem_get_info(i)[0])) + '\n' |
|
|
|
return sys_info |
|
|
|
|
|
|
