Upload 46 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+img/all_in_one.png filter=lfs diff=lfs merge=lfs -text

.github/ISSUE_TEMPLATE/simple-issue-template.md

@@ -0,0 +1,20 @@
+---
+name: Simple Issue template
+about: Describe this issue template's purpose here.
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+## Have you read document?
+
+## Have you checked console log window's msg?
+
+## Describe Issue
+
+
+## Screenshot for UI issue
+
+
+## Console log's msg or screenshot for function issue

.gitignore

@@ -0,0 +1,3 @@
+scripts/__pycache__/
+scripts/ch_lib/__pycache__/
+setting.json

README.cn.md

@@ -0,0 +1,241 @@
+## 关于Civitai Helper2: Model Info Helper
+Civitai助手2将改名为**Model Info助手**。目前还在缓慢开发中。你可以查看它的UI演示视频，了解它会是什么样子:    
+[https://youtu.be/mPcKwQDDH8s](https://youtu.be/mPcKwQDDH8s)  
+
+
+# Civitai Helper
+Stable Diffusion Webui 扩展Civitai助手，用于更轻松的管理和使用Civitai模型。
+
+[Civitai Url](https://civitai.com/models/16768/civitai-helper-sd-webui-civitai-extension)  
+
+# 注意
+**本插件现在非常稳定，很多人用得很好，如果碰到问题，先看[常见问题](#常见问题)，并检查命令行窗口的详情。**   
+开issue前，请先看文档。找茬行为的用户将会被拉黑，参考：[找茬行为会被拉黑](https://github.com/butaixianran/Stable-Diffusion-Webui-Civitai-Helper/issues/96#issuecomment-1500310981)   
+
+
+# 功能
+[中文介绍视频(非官方)](https://youtu.be/x4tPWPmeAgM?t=373)  
+
+* 扫描所有模型，从Civitai下载模型信息和预览图 
+* 通过civitai模型页面url，连接本地模型和civitai模型信息
+* 通过Civitai模型页面url，下载模型(含信息和预览图)到SD目录或子目录。
+* 下载支持断点续传
+* 批量检查本地模型，在civitai上的新版本
+* 直接下载新版本模型到SD模型目录内(含信息和预览图)
+* 修改了内置的"Extra Network"模型卡片，每个卡片增加了如下功能按钮:
+  - 🖼: 修改文字"replace preview"为这个图标
+  - 🌐: 在新标签页打开这个模型的Civitai页面
+  - 💡: 一键添加这个模型的触发词到关键词输入框
+  - 🏷: 一键使用这个模型预览图所使用的关键词
+* 以上额外功能按钮支持thumbnail模式
+* 增加一直显示按钮的选项，以供触屏用户使用
+
+
+# 安装
+下载本项目为zip文件，解压到`你的SD webui目录/extensions`下即可。
+
+不管是安装还是升级本插件，都要整个关闭SD Webui，重新启动它。只是Reload UI不起作用。  
+
+(如果用SD webui的插件界面安装，请先给git配置代理。它不是通过浏览器下载，是通过git下载。)  
+
+
+# 使用方法
+
+## 更新你的SD webui
+本扩展需要取到 Extra Network的卡片列表id。**这个是2023-02-06，才添加到SD webui里面的。**  
+
+所以，如果你用的版本比这个早，你就需要先更新你的SD Webui！
+
+
+## 扫描模型
+前往扩展页面"Civitai Helper"，有个按钮叫："Scan Model"  
+
+![](img/extension_tab.jpg)  
+
+点击，就会扫描所有模型，生成SHA256码，用于从civitai获取模型信息和预览图。**扫描需要很久，耐心等待**。
+
+每个模型，本扩展都会创建一个json文件，用来保存从civitai得到的模型信息。这个文件会保存在模型同目录下，名称为："模型名字.civitai.info"。  
+
+![](img/model_info_file.jpg)  
+
+如果模型信息文件已经存在，扫描时就会跳过这个模型。如果模型不是civitai的，就会创建个空信息文件，以避免以后重复扫描。
+
+### 添加新模型
+当你下载了新模型之后，只要再次点击扫描按钮即可。已经扫描过的文件不会重复扫描，会自动得到新模型的信息和预览图。无须重启SD webui。 
+
+## 模型卡片
+**(先完成扫描，再使用卡片功能)**  
+打开SD webui's 内置的 "Extra Network" 页面，显示模型卡片  
+
+![](img/extra_network.jpg)  
+
+
+移动鼠标到模型卡片底部，就会显示4个按钮：
+  - 🖼: 修改文字"replace preview"为这个图标
+  - 🌐: 在新标签页打开这个模型的Civitai页面
+  - 💡: 一键添加这个模型的触发词到关键词输入框
+  - 🏷: 一键使用这个模型预览图所使用的关键词
+  
+![](img/model_card.jpg)  
+
+如果你没有看到这些额外的按钮，只要点击`Refresh Civitai Helper`，他们就会被重新添加到卡片上。  
+
+![](img/refresh_ch.jpg)  
+
+每次当Extra Network刷新，他都会删除掉额外的修改，我们的按钮就会消失。这时你就需要点击`Refresh Civitai Helper`把这些功能添加回去。
+
+
+### 小图模式
+以上功能按钮支持小图模式，但受制于SD Webui的CSS问题，目前，只能要么一直显示，要么一直不显示，不能鼠标滑过才显示。   
+![](img/thumb_mode.jpg)  
+
+## 下载 
+**(单任务，下载完一个再下另一个)**  
+通过Civitai模型页面Url下载模型，要3个步骤：
+* 填入url，点击按钮获取模型信息
+* 扩展会自动填入模型名称和类型，你需要选择下载的子目录和模型版本。
+* 点击下载  
+![](img/download_model.jpg)
+
+下载过程会显示在命令行界面带个进度条。  
+支持断点续传，无畏大文件。  
+
+
+## 批量检查模型新版本
+你可以按照模型类型，批量检查你的本地模型，在civitai上的新版本。你可以选择多个模型类型。  
+![](img/check_model_new_version.jpg)  
+
+检查新版本的时候，每检查完一个模型，都会有一个1秒的延迟，所以速度有点慢。
+
+这是为了保护Civitai避免因为本插件而短暂陷入类似DDos的局面。有些云服务商，有类似“免费用户每秒API请求不能超过1次”的保护机制。Civitai还没有这种设置。但我们还是得自觉保护它。因为如果它挂了，对大家都没有好处。    
+
+**检查完毕之后**，就会如下图，在UI上显示所有找到的新版本的信息。  
+
+每个模型新版本，都有3个链接。
+* 第一个是这个模型的网页。
+* 第二个是这个新版本的下载地址。   
+* 第三个是个按钮，在python端，直接下载新版本到模型目录内。  
+这种方式下载，下载详情显示在"Download Model"的区域和命令行窗口中。一次一个任务，不支持多任务。  
+![](img/check_model_new_version_output.jpg)
+
+
+
+## 根据URL获取模型信息
+如果无法在civitai上找到你的模型的SHA256，但你还是希望能把你的模型连接到一个civitai模型，你可以在本扩展页面，从列表中选择你的模型，并提供一个civitai模型页面的url。
+
+点击按钮之后，扩展就会下载那个civitai模型的信息，作为你这个本地模型的信息使用。  
+
+![](img/get_one_model_info.jpg)  
+
+## 代理
+**如果你是刚更新新版本，你需要重启SD webui再来使用**   
+
+代理输入框在插件页面最下方。
+
+**每次填入或清除代理后，都要保存，并用SDwebui设置页面的Reload UI按钮刷新UI**  
+
+然后所有发到civitai的请求就会用代理。  
+
+有些sock5代理, 需要使用socks5h开头的形式"socks5h://xxxxx"才能生效。   
+
+
+
+## 其他设置
+**保存设置按钮, 会保存扫描模型区域，以及其他设置 这两个区域的选项**  
+
+* "一直显示按钮" 是为了方便触屏。  
+* "小图模式显示功能按钮" 会开关功能按钮在小图模式的显示  
+![](img/other_setting.jpg) 
+
+## 预览图
+Extra Network支持两种预览图命名：`model_name.png` 和 `model_name.preview.png`。其中，`model_name.png`优先级较高。
+
+当优先级较高的预览图不存在，他就会自动使用`model_name.preview.png`。
+
+这样，你自己创建的预览图 和 网络下载的预览图，能够同时存在，并优先使用你自己创建的。
+
+## 关键词
+卡片上，添加关键词按钮，是添加从civitai预览图中得到的关键词，而不是你自己创建的图片的关键词。
+
+civitai不是每个图片都有关键词，一个模型中，也不是所有预览图关键词都一样。所以这里是遍历所有civitai预览图信息，加载第一个有关键词的。
+
+
+## SHA256
+为了创建文件的SHA256，插件需要读取整个文件。对于大尺寸文件，就会很慢。
+
+有两种情况，这个SHA256无法从civitai找到对应模型：
+* 太老的模型，civitai没有存储SHA256.
+* 模型作者，静静的换掉了模型文件，但没有修改描述和版本。所以，虽然网页上看不出来，但实际上civitai上的 和你本地的模型文件，已经不是同一个文件了。  
+
+这些情况下，你可以在插件上，通过提供模型页面的url，来获取模型信息文件。
+
+
+
+## 新特性
+从v1.5开始，v1.x不再接受任何新特性。所有新特性进入2.x。
+
+2.x专注于自定义模型信息，并可能改名为"Model Info Helper"。因为不再是专注Civitai了。 
+
+从v1.5开始。v1.x进入维护阶段。  
+
+
+Enjoy!
+
+
+## 常见问题
+### 4个卡片按钮不显示
+#### 汉化原因
+下载新版，最新版已经处理汉化导致的问题。**双语汉化插件需要v1.6.1.1之后的版本才开始支持。**  
+
+#### 使用了云端汉化功能
+如果是秋叶启动器，就关闭启动器“云端汉化”功能。如果是专门的云端汉化插件，就换用普通汉化插件。  
+
+#### 其他情况
+首先，确保你点过了"Refresh Civitai Helper"刷新按钮。  
+
+然后，如果还有这个问题，那么唯一原因，是你没有使用最新版SD webui。  
+
+如果你修改过SD webui的文件， 你的更新操作可能会失败。你需要检查git命令行的输出信息，来确定你更新成功了。   
+
+git在很多时候，会拒绝升级，并告诉你有些冲突需要你手动先解决。如果你不看命令行输出，你就会以为你已经更新成功了，但其实并没有。   
+
+ 
+### Request model info from civitai
+意思就是正在连接civitai，如果没有后面的信息，就是连不上，请挂代理。
+
+
+### 扫描或获取模型信息失败
+这个插件现在很稳定，所以，这个问题的原因，基本是是因为Civitai拒绝了你的连接请求。  
+
+Civitai不像那些大网站那么稳定。他网站会挂，会拒绝API连接，还会把API请求转到真人验证页面，来挡住。  
+
+Civitai还有连接池的设定。基本上，就是同时能允许的最大连接数。一旦达到这个数字，接下来的API连接请求，都会被拒绝。  
+
+所以，这种时候你只能等一下再试。  
+
+另外，对于国��用户，还有代理问题。现在国内都要用代理才能连上。   
+
+
+### 扫描之后得到了错误的预览图和模型信息
+坏消息是，有些模型在civitai数据库中，保存的sha256完全是错的。查看下面的issue了解详情：    
+[https://github.com/civitai/civitai/issues/426](https://github.com/civitai/civitai/issues/426)  
+
+对于这种模型，那这个插件自然就无法获得正确的模型信息和预览图。  
+
+这种情况下，请删除扫描得到的模型信息和预览图，在插件界面提供正确的模型url来获取。   
+
+另外，civitai官方有个页面，专门用于回报带有错误sha256的模型：   
+[https://discord.com/channels/1037799583784370196/1096271712959615100/1096271712959615100](https://discord.com/channels/1037799583784370196/1096271712959615100/1096271712959615100)  
+
+请把这类模型反馈给civitai，好让他们进行修复。  
+
+
+
+
+### 使用colab时扫描失败
+首先，在google中搜索你看到的错误信息。更有可能是，你碰到的是个colab的问题。  
+
+然后，如果colab连接了google drive，会有一次性访问文件数量的限制，而导致扫描失败。这是google drive的限制，请自行google搜索了解详情。
+
+
+

README.jp.md

@@ -0,0 +1,224 @@
+### Language
+[中文](README.cn.md)   
+[English](README.md)  
+[한국어(ChatGPT)](README.kr.md)  
+
+## About Civitai Helper2: Model Info Helper
+Civitai Helper 2は、**ModelInfo Helper**に改名されます。現在開発中です。デモをご覧ください:
+[YouTube](https://youtu.be/mPcKwQDDH8s)  
+
+# お知らせ
+**この拡張機能は現在、非常に安定しています。もし問題があれば、コンソールログの詳細を確認し、[よくある質問](#よくある質問)を確認してください。**   
+
+# Civitai Helper
+この拡張機能は、Civitaiのモデルをより簡単に扱えるようにするためのものです。
+
+Civitai: [Civitai Url](https://civitai.com/models/16768/civitai-helper-sd-webui-civitai-extension)  
+
+# 機能
+* 全てのモデルをスキャンし、Civitaiからモデル情報とプレビューをダウンロード
+* CivitaiモデルページのURLを使って、ローカルモデルとCivitaiモデル情報を取得
+* CivitaiモデルページのURLから、モデル(情報とプレビューを含む)をSDディレクトリまたはサブディレクトリにダウンロードする。
+* ダウンロードは途中から再開可能
+* ローカルのモデルとCivitai上の新しいバージョンを一括でチェック
+* 新しいバージョンのモデルを直接モデルのディレクトリにダウンロード(情報とプレビュー画像を含む)
+* 内蔵の**Extra Network**モデルカードを変更し、各カードに以下の機能ボタンを追加しました。
+  - 🖼: `replace preview`のテキストをこのアイコンに変更
+  - 🌐: このモデルのCivitaiページを新しいタブで開く
+  - 💡: このモデルのトリガーワードをキーワード入力欄に一括で追加する
+  - 🏷: このモデルのプレビュー画像で使用されているキーワードを一括で使用する
+* 上記の追加機能ボタンは、サムネイルモードにも対応しています。
+* タッチスクリーンデバイス向けに、常に表示されるボタンのオプションを追加しました。
+
+
+# インストール
+SD webui's extensionタブから、`Install from url`のタブに移動。
+このリポジトリのURLをコピーペーストし、インストールする。  
+
+または、このリポジトリをzipでダウンロードし、`./webui/extensions`へ展開してください。
+
+この拡張機能をインストール、またはアップデートするたびに、SD Webui再起動する必要があります。  
+この拡張機能は、**UIを再読み込みする**だけでは動作しません。
+
+# 使い方
+
+## WebUIをアップデート
+この拡張機能は`network cards id`を取得する必要があります。この機能は**2023-02-06**に追加されました。    
+**SD webuiがこれより前のバージョンである場合は、アップデートする必要があります!**  
+
+## モデルのスキャン
+拡張機能タブから<kbd>Civitai Helper</kbd>へ。  
+<kbd>Scan model</kbd>というボタンがあります。  
+
+![](img/extension_tab.jpg)
+
+これをクリックすると、拡張機能がすべてのモデルをスキャンしてSHA256ハッシュを生成し、それを使ってCivitaiからモデル情報とプレビュー画像を取得します。
+**スキャンには時間がかかります。 終了までお待ちください。**
+
+各モデルに対して、Civitaiからすべてのモデル情報を保存するためのjsonファイルを作成します。このモデル情報ファイルは、modelsディレクトリ内の`Your_model_name.civitai.info`となります。
+
+![](img/model_info_file.jpg)
+
+モデル情報ファイルがすでに存在する場合は、スキップされます。Civitaiでモデルが見つからない場合、空のモデル情報ファイルを作成するので、モデルが2回スキャンされることはありません。
+
+### 新しいモデルを追加
+新規のモデルがある場合、もう一度スキャンボタンをクリックするだけで、新しいモデルの情報とプレビューを取得できます。同じモデルを2回スキャンすることはありません。
+
+## モデルカード
+**(スキャン終了後に使用)**   
+SD webuiの`Extra Network`タブを開き、モデルカードを表示します。
+
+![](img/extra_network.jpg)
+
+
+マウスをモデルカードの下部に移動すると、4つのボタンが表示されます。
+  - 🖼: プレビューを置き換えるためのテキストを`replace preview`からこのアイコンに変更します
+  - 🌐: このモデルのCivitaiページを新しいタブで開きます
+  - 💡: このモデルのトリガーワードをキーワード入力欄に一括追加します
+  - 🏷: このモデルのプレビュー画像に使用されているキーワードを一括で使用します
+  
+![](img/model_card.jpg)  
+
+これらのボタンが表示���れない場合は、<kbd>Refresh Civitai Helper</kbd>をクリックすると、ボタンがカードに再追加されます。  
+
+![](img/refresh_ch.jpg)  
+
+`Extra Network`が更新されるたびに、余分な変更が削除され、ボタンが消えてしまいます。その場合は、「Refresh Civitai Helper」をクリックして、これらの機能を再度追加する必要があります。
+
+
+### サムネイル
+これらのボタンは、サムネイルをサポートしていますが、SD WebuiのCSSの問題により、現在は常に表示か非表示かのどちらかに制限されています。マウスをスライドして表示することはできません。   
+![](img/thumb_mode.jpg)  
+
+
+## ダウンロード
+**(タスクが一つ完了してから、次のタスクをダウンロードしてください)**  
+CivitaiモデルページのURLを使用してモデルをダウンロードするには、3つのステップが必要です。
+1. URLを入力し、モデル情報を取得するためにボタンをクリック
+2. 拡張機能が自動的にモデル名とタイプを入力します。ダウンロードするサブディレクトリとモデルバージョンを選択
+3. ダウンロードをクリックします  
+![](img/download_model.jpg)
+
+ダウンロード状況は、CLIに進行状況バーを表示します。  
+断片的に再開することができ、大きなファイルをダウンロードする際にも心配する必要はありません。  
+
+
+## 新しいモデルのバージョンを確認する
+モデルの種類に従って、ローカルのモデルを一括でCivitaiの新バージョンがないかをチェックすることができます。複数のモデルの種類を選択できます。  
+![](img/check_model_new_version.jpg)  
+
+これを押すと、各モデルをチェックするたびに1秒の遅延が発生するため、速度がやや遅くなります。  
+
+これは、本拡張機能のユーザーの過失によるDDoSを回避し、Civitaiを保護するために行われます。  
+一部のクラウドサービスプロバイダーには、「無料ユーザーのAPIリクエストは1秒あたり1回を超えてはいけない」というような保護があります。Civitaiにはまだこのような設定がありませんが、我々はそれを自衛しなければなりません。  
+なぜなら、もしCivitaiがダウンした場合、誰にとっても良いことではないからです。      
+
+チェックが完了すると、すべての新しいバージョンがUIに表示されます。    
+
+各モデルの新しいバージョンには、3つのリンクがあります。
+* 最初のものは、このモデルのWebページです。
+* 2つ目は、この新しいバージョンのダウンロードアドレスです。  
+* 3つ目は、Python(拡張機能)側で新しいバージョンをモデルディレクトリに直接ダウンロードするボタンです。
+この方法でダウンロードすると、ダウンロードの詳細が「Download Model」の領域とコマンドラインに表示されます。一度に1つのタスクしかサポートされていません。  
+![](img/check_model_new_version_output.jpg)
+
+
+
+## URLからモデル情報を取得する
+Civitai上で自分のモデルのSHA256が見つからない場合でも、自分のモデルをCivitaiモデルに接続したい場合は、この拡張機能のページから、モデルをリストから選択し、CivitaiモデルページのURLを提供することができます。  
+
+ボタンをクリックすると、拡張機能はCivitaiモデルの情報をダウンロードし、それをローカルモデルの情報として使用します。  
+
+![](img/get_one_model_info.jpg)  
+
+
+
+## その他の設定
+**設定保存ボタンを押すと、<kbd>Scan Model</kbd>の設定とその他の設定の両方が保存されます。**  
+
+*  <kbd>Always Display Button</kbd>は、タッチデバイスでの操作を容易にするためです。
+*  <kbd>Show Buttons on Thumb Mode</kbd>は、小さな画像モードでの機能ボタンの表示を切り替えます。 
+![](img/other_setting.jpg) 
+
+## プレビュー
+Extra Networkは、2つのプレビュー画像の命名をサポートしています:`model_name.png`と`model_name.preview.png`。  
+デフォルトでは自動で`model_name.png`が優先的に使われます。
+
+優先度が高いプレビュー画像が存在しない場合は、自動的に`model_name.preview.png`が使用されます。
+
+これにより、自分で作成したプレビュー画像とネットからダウンロードしたプレビュー画像を同時に使用し、自分で作成したプレビュー画像を優先的に使用できます。
+
+## プロンプト
+カード上の<kbd>Use prompt from preview image</kbd>ボタンは、Civitaiプレビュー画像から取得したキーワードであり、自分で作成した画像のキーワードではありません。
+
+Civitaiにはすべての画像にキーワードがあるわけではなく、1つのモデルに含まれるすべてのプレビュー画像のキーワードが同じであるわけでもありません。したがって、ここではすべてのCivitaiプレビュー画像情報を走査し、最初にキーワードがあるものを読み込みます。
+
+
+## SHA256
+ファイルのSHA256を作成するために、はファイル全体を読み取る必要があります。大きなファイルの場合、処理が遅くなります。
+
+Civitaiで対応するモデルのSHA256が見つからない場合は、次の2つの場合が考えられます：
+* 古すぎるモデルには、SHA256が保存されていません。
+* モデルの作成者が静かにモデルファイルを変更しましたが、説明やバージョンを変更していないため、サイト上ではわかりませんが、実際にはCivitaiに保存されているモデルファイルとローカルのモデルファイルは異なるものとなっています。  
+
+これらの場合は、拡張機能にモデルページのURLを提供することで、モデルの情報ファイルを取得できます。
+
+## Feature Request
+v1.5以降のv1.xには新機能はありません。すべての新機能は2.xに移行されます。
+2.xでは、カスタムモデル情報にフォーカスし、Civitaiだけではなく、`Model Info Helper`という名称に変更する可能性があります。
+v1.5からv1.xはメンテナンスのフェーズに入ります。
+
+お楽しみに!
+
+
+## よくある質問
+### 4つのカードボタンが表示されない
+#### ローカライズの問題
+新しいバージョンをダウンロードしてください。  
+最新バージョンでは、ローカライズによる問題が解決されています。
+[バイリンガル拡張機能](https://github.com/journey-ad/sd-webui-bilingual-localization)は、v1.6.1.1以降のバージョンでサポートされるようになりました。 
+
+#### クラウドサービスベースの翻訳機能を使用した
+クラウドサービスベースの翻訳機能を使用している場合は、通常のローカライズに変更してください。
+
+#### その他の場合
+まず、<kbd>Refresh Civitai Helper</kbd>をクリックして更新しましたか?  
+
+それでもこの問題が発生する場合は、おそらく最新バージョンのSD webuiを使用していないためです。  
+
+SD webuiのファイルを変更した場合、更新操作が失敗する可能性があります。更新が成功したかどうかを確認するには、gitコマンドラインの出力情報を確認する必要があります。  
+
+gitは、多くの場合、アップグレードを拒否し、手動で解決する必要があるいくつかの競合状態を示します。コマンドライン出力を見ない場合、更新が成功したと思うかもしれませんが、実際には成功していません。   
+
+ 
+### Request model info from civitai
+これはcivitaiに接続しています。情報がない場合は接続できないため、プロキシを使用してください。
+
+
+### スキャンまたはモデル情報の取得に失敗しました
+この拡張機能は現在非常に安定しているため、この問題の原因は基本的にはCivitaiが接続要求を拒否したためです。  
+
+Civitaiは大きなウェブサイトとは異なり、安定していません。彼らのウェブサイトはダウンしたり、API接続を拒否したり、APIリクエストをCpatchaページに転送してブロックしたりすることがあります。  
+
+Civitaiには接続プールの上限もあります。基本的に、同時に許可される最大接続数です。この数字に達すると、以降のAPI接続要求はすべて拒否されます。  
+
+そのため、このような場合はしばらく待ってから再試行するしかありません。  
+
+### civitaiから誤ったモデル情報とプレビュー画像を取得する(Translated by ChatGPT)
+悪いニュースですが、civitaiのデータベースには誤ったsha256で保存されたモデルがいくつかあります。詳細についてはこちらをご覧ください：  
+[https://github.com/civitai/civitai/issues/426](https://github.com/civitai/civitai/issues/426)  
+
+したがって、これらのモデルについては、この拡張機能では正しいモデル情報やプレビュー画像を取得できません。  
+
+この場合、モデル情報ファイルを削除し、この拡張機能のタブページでcivitaiのURLから正しいモデル情報を取得する必要があります。  
+
+また、誤ったsha256を持つこれらのモデルをcivitaiに報告することもできます。  
+[https://discord.com/channels/1037799583784370196/1096271712959615100/1096271712959615100](https://discord.com/channels/1037799583784370196/1096271712959615100/1096271712959615100)  
+
+civitaiにそのモデルを報告して修正してもらうようにしてください。  
+
+
+### colabを使用した際にスキャンに失敗する
+まず、表示されたエラーメッセージをGoogleで検索してください。おそらくcolabの問題が発生している可能性があります。表示されたエラーメッセージを検索して、原因を特定してください。  
+
+Google Driveに接続する際には、ファイルへのアクセス数に制限があるため、スキャンが失敗することがよくあります。これはGoogle Drive側の制限です。詳細についてはインターネットで[検索](https://google.com)してください。

README.kr.md

@@ -0,0 +1,206 @@
+# Civitai Helper
+Stable Diffusion Webui는 Civitai 모델을 더 쉽게 관리하고 사용하기 위한 Civitai Assistant 확장 기능입니다.
+
+[Civitai Url](https://civitai.com/models/16768/civitai-helper-sd-webui-civitai-extension)  
+
+# 주의사항
+**이 플러그인은 지금 매우 안정적이며 많은 사용자들이 잘 사용하고 있습니다. 문제가 발생하면, [자주 묻는 질문](#자주-묻는-질문)을 먼저 확인하고 명령 프롬프트 창의 세부 정보를 확인하세요.**   
+
+
+
+
+# 기능
+* 모든 모델을 스캔하여 Civitai에서 모델 정보 및 미리보기 이미지 다운로드
+* Civitai 모델 페이지 URL을 통해 로컬 모델 및 Civitai 모델 정보 연결
+* Civitai 모델 페이지 URL을 통해 모델(정보 및 미리보기 이미지 포함) 다운로드하여 SD 디렉토리 또는 하위 디렉토리에 저장
+* 이어받기 지원 다운로드
+* 로컬 모델에서 Civitai에 새 버전이 있는지 일괄 확인
+* 새 버전 모델을 SD 모델 디렉토리에 직접 다운로드(정보 및 미리보기 이미지 포함)
+* "Extra Network" 모델 카드 내부를 수정하여 다음과 같은 기능 버튼을 추가:
+  - 🖼: "replace preview" 텍스트를 이 아이콘으로 변경
+  - 🌐: 해당 모델의 Civitai 페이지를 새 탭에서 열기
+  - 💡: 이 모델의 트리거 단어를 키워드 입력란에 일괄 추가
+  - 🏷: 이 모델 미리보기 이미지에 사용된 키워드 사용
+* 위의 추가 기능 버튼은 썸네일 모드를 지원합니다.
+* 터치 스크린 사용자를 위해 항상 표시되는 버튼 옵션 추가
+
+
+# 설치
+이 프로젝트를 zip 파일로 다운로드하고 SD webui 디렉토리/extensions에 압축 해제하면 됩니다.  
+
+이 플러그인을 설치하거나 업그레이드하려면 SD Webui를 완전히 종료하고 다시 시작해야 합니다. UI 다시로드는 작동하지 않습니다.  
+
+# 사용 방법
+
+## SD Webui 업데이트
+이 확장 기능은 Extra Network 카드 목록 ID를 가져와야 합니다. 이것은 2023-02-06에 SD Webui에 추가된 것입니다.  
+
+따라서, 만약 사용 중인 버전이 이보다 이전 버전이라면, 먼저 SD Webui를 업데이트해야 합니다!  
+
+
+## 모델 스캔
+확장 페이지 "Civitai Helper"로 이동하고 "Scan Model"이라는 버튼을 클릭합니다.  
+
+![](img/extension_tab.jpg)  
+
+클릭하면 모든 모델을 스캔하고 SHA256 코드를 생성하여 Civitai에서 모델 정보 및 미리보기 이미지를 가져옵니다. 스캔에는 시간이 걸리므로 인내심을 가지고 기다려주세요.  
+
+이 확장 기능은 각 모델마다 Civitai에서 얻은 모델 정보를 저장하는 JSON 파일을 생성합니다. 이 파일은 모델이 있는 디렉토리에 "모델 이름.civitai.info"라는 이름으로 저장됩니다.  
+
+![](img/model_info_file.jpg)  
+
+모델 정보 파일이 이미 존재하는 경우 해당 모델은 스캔하지 않습니다. 모델이 Civitai가 아닌 경우 빈 정보 파일이 생성되어 나중에 중복 스캔을 피합니다.  
+
+### 새 모델 추가
+새 모델을 다운로드한 후 스캔 버튼을 다시 클릭하면 됩니다. 이미 스캔된 파일은 다시 스캔하지 않으며 새 모델의 정보와 미리보기 이미지를 자동으로 얻을 수 있습니다. SD Webui를 다시 시작할 필요가 없습니다.  
+
+## 모델 카드
+**(스캔을 완료한 후에 카드 기능을 사용하세요)**  
+SD Webui의 내장 "Extra Network" 페이지를 열어 모델 카드를 표시합니다.  
+
+![](img/extra_network.jpg)  
+
+
+마우스를 모델 카드 아래쪽으로 이동하면 4개의 버튼이 표시됩니다:  
+  - 🖼: "replace preview" 텍스트를이 아이콘으로 변경
+  - 🌐:이 모델의 Civitai 페이지를 새 탭에서 엽니다.
+  - 💡:이 모델의 트리거 단어를 키워드 입력 상자에 추가합니다.
+  - 🏷:이 모델 미리보기에 사용되는 키워드를 사용합니다.
+  
+![](img/model_card.jpg)  
+
+이러한 추가 버튼이 표시되지 않으면 Refresh Civitai Helper를 클릭하여 다시 추가하십시오.  
+
+![](img/refresh_ch.jpg)  
+
+Extra Network가 새로 고침될 때마다이 추가 수정이 제거되므로 버튼이 사라지면 Refresh Civitai Helper를 클릭하여 기능을 다시 추가해야합니다.  
+
+
+### 작은 미리보기 모드
+이러한 기능 버튼은 작은 미리보기 모드를 지원하지만 SD Webui의 CSS 문제로 인해 현재 항상 표시하거나 항상 표시하지 않아야합니다.  
+![](img/thumb_mode.jpg)  
+
+## 다운로드
+**(한 번에 하나씩, 하나를 다운로드하고 다른 것을 다운로드하세요)**  
+Civitai 모델 페이지 URL을 통해 모델을 다운로드하려면 3 단계가 필요합니다:  
+* URL을 입력하고 모델 정보를 가져 오는 버튼을 클릭합니다.
+* 확장 프로그램이 모델 이름과 유형을 자동으로 입력합니다. 다운로드 할 하위 디렉토리와 모델 버전을 선택해야합니다.
+* 다운로드를 클릭하십시오.  
+![](img/download_model.jpg)
+
+다운로드 과정은 진행률 표시 줄이있는 명령 줄 인터페이스에서 표시됩니다.  
+일시 중지 및 다시 시작을 지원하며 대용량 파일도 문제없이 처리합니다.  
+
+
+## 일괄적으로 모델 새 버전 확인
+Civitai에서 새 버전을 확인하기 위해 로컬 모델을 모델 유형 별로 일괄적으로 확인할 수 있습니다. 여러 모델 유형을 선택할 수 있습니다.  
+![](img/check_model_new_version.jpg)  
+
+새 버전을 확인 할 때마다 모델이 모두 확인 될 때까지 1 초의 지연이 있으므로 속도가 다소 느립니다.  
+
+이것은 Civitai가 이 플러그인으로 인해 일시적으로 DDos와 유사한 상황에 빠지지 않도록 보호하기 위한 것입니다. 일부 클라우드 서비스 제공 업체는 "무료 사용자의 초당 API 요청 수는 1 회를 초과 할 수 없다"는 보호 메커니즘이 있습니다. Civitai는 이러한 설정이 없습니다. 그러나 우리는 여전히 그것을 보호해야합니다. 왜냐하면 그것이 다운되면 모두에게 좋지 않기 때문입니다.     
+
+확인이 완료되면 다음과 같이 UI에 모든 새 버전을 찾은 정보가 표시됩니다.  
+
+각 모델 새 버전에는 3 개의 링크가 있습니다.  
+* 첫 번째는 이 모델의 웹 페이지입니다.
+* 두 번째는이 새 버전의 다운로드 주소입니다.  
+* 세 번째는 버튼입니다. Python 측에서 새 버전을 모델 디렉토리로 직접 다운로드합니다.  
+이 방식으로 다운로드하면 "모델 다운로드" 영역과 명령 줄 창에 다운로드 세부 정보가 표시됩니다. 한 번에 하나의 작업만 지원됩니다.  
+![](img/check_model_new_version_output.jpg)
+
+
+
+## URL을 기반으로 모델 정보 가져오기
+Civitai에서 모델의 SHA256을 찾을 수 없지만 여전히 Civitai 모델에 모델을 연결하고 싶다면 해당 확장 프로그램 페이지에서 모델을 선택하고 Civitai 모델 페이지의 URL을 제공할 수 있습니다.  
+
+버튼을 클릭하면 확장 프로그램이 해당 Civitai 모델의 정보를 다운로드하여 로컬 모델의 정보로 사용합니다.  
+
+![](img/get_one_model_info.jpg)  
+
+
+
+## 기타 설정
+**설정 저장 버튼은 스캔 모델 영역 및 기타 설정 두 영역의 옵션을 저장합니다.**  
+
+* "항상 표시 버튼"은 터치 스크린에서 편리하게 사용하기 위한 것입니다.  
+* "작은 그림 모드에서 기능 버튼 표시"는 작은 그림 모드에서 기능 버튼을 표시할지 여부를 전환합니다.  
+![](img/other_setting.jpg) 
+
+## 미리보기 이미지
+Extra Network는 model_name.png 및 model_name.preview.png 두 가지 미리보기 이미지 이름을 지원합니다. 여기서 model_name.png이 우선순위가 높습니다.  
+
+우선순위가 높은 미리보기 이미지가 없으면 자동으로 model_name.preview.png를 사용합니다.  
+
+이렇게 하면 직접 만든 미리보기 이미지와 인터넷에서 다운로드한 미리보기 이미지를 함께 사용할 수 있으며, 우선순위는 직접 만든 이미지가 높습니다.  
+
+## 키워드
+카드에 키워드 추가 버튼은 civitai 미리보기 이미지에서 얻은 키워드를 추가하는 것이며, 사용자가 직접 만든 이미지의 키워드가 아닙니다.  
+
+모든 이미지에 키워드가 있는 것은 아니며, 모델에 따라 미리보기 이미지의 키워드가 모두 같지 않을 수 있습니다. 따라서 여기서는 civitai 모든 미리보기 이미지 정보를 탐색하여 첫 번째 키워드가 있는 이미지를 로드합니다.  
+
+
+## SHA256
+파일의 SHA256을 생성하려면 플러그인에서 전체 파일을 읽어야 합니다. 대형 파일의 경우 시스템이 느려질 수 있습니다.  
+
+SHA256은 civitai에서 해당 모델을 찾을 수 없는 두 가지 경우가 있습니다.
+* 너무 오래된 모델이므로 civitai에 SHA256이 저장되어 있지 않습니다.
+* 모델 작성자가 모델 파일을 조용히 교체했지만 설명 및 버전을 수정하지 않았습니다. 따라서 웹 페이지에서는 확인할 수 없지만 civitai 및 로컬 모델 파일은 이미 다른 파일입니다.  
+
+이러한 경우에는 플러그인에서 모델 페이지 URL을 제공하여 모델 정보 파일을 얻을 수 있습니다  
+
+
+## 자주 묻는 질문
+### 4개의 카드 버튼이 표시되지 않습니다.
+#### 한국어 플러그인을 사용했습니다
+새 버전을 다운로드하면, 최신 버전에서 한국어 번역으로 인한 문제가 해결되었습니다. 양방향 다국어 플러그인은 v1.6.1.1 이후 버전부터 지원됩니다.  
+
+#### 클라우드 기반 한국어 플러그인을 사용했습니다
+클라우드 기반 한국어 플러그인을 사용한 경우 일반적인 한국어 플러그인으로 변경���십시오.  
+
+
+#### 다른 경우
+먼저 "Refresh Civitai Helper" 버튼을 클릭하여 Civitai Helper를 새로고침했는지 확인하세요.  
+
+그런 다음 이 문제가 계속되는 경우, 유일한 이유는 최신 버전의 SD webui를 사용하지 않았기 때문입니다.  
+
+만약 SD webui의 파일을 수정했다면, 업데이트 작업이 실패할 수 있습니다. 업데이트가 제대로 이루어졌는지 확인하려면 git 명령 줄의 출력 정보를 확인해야 합니다.  
+
+git은 종종 업그레이드를 거부하고, 일부 충돌을 수동으로 해결해야 한다는 메시지를 보여줍니다. 명령 줄 출력을 확인하지 않으면 업그레이드가 성공했다고 잘못 생각할 수 있습니다.  
+
+ 
+### Request model info from civitai
+이것은 Civitai에 연결하고 있음을 나타내며, 정보가 없으면 연결할 수 없으므로 프록시를 사용해야 합니다.  
+
+
+### 모델 정보 스캔 또는 가져오기 실패
+이 플러그인은 이제 매우 안정적이므로, 이 문제의 원인은 대부분 Civitai가 연결 요청을 거부했기 때문입니다.  
+
+Civitai는 대형 웹사이트와 같이 안정적이지 않습니다. 웹사이트가 다운되거나 API 연결을 거부할 수 있고, API 요청을 실제 검증 페이지로 전환하여 차단할 수도 있습니다.  
+
+Civitai에는 연결 풀 설정이 있습니다. 이는 동시에 허용되는 최대 연결 수입니다. 이 수치에 도달하면 다음 API 연결 요청은 모두 거부됩니다. 이 때는 잠시 기다렸다가 다시 시도해야 합니다.  
+
+또한 국내 사용자들에게는 프록시 문제가 있습니다. 대개는 프록시를 사용해야만 연결할 수 있습니다.  
+
+
+### civitai에서 잘못된 모델 정보 및 미리보기 이미지 가져오기
+안타깝게도, civitai의 데이터베이스에 일부 모델이 잘못된 sha256으로 저장되어 있습니다. 자세한 내용은 여기를 확인하십시오:  
+[https://github.com/civitai/civitai/issues/426](https://github.com/civitai/civitai/issues/426)  
+
+따라서 이 확장 프로그램은 해당 모델의 올바른 모델 정보나 미리보기 이미지를 가져올 수 없습니다.  
+
+이 경우 모델 정보 파일을 제거하고 이 확장 프로그램의 탭 페이지에서 civitai url로 올바른 모델 정보를 가져와야 합니다.  
+
+또한, 잘못된 sha256을 가진 해당 모델을 civitai에 신고할 수 있습니다.  
+[https://discord.com/channels/1037799583784370196/1096271712959615100/1096271712959615100](https://discord.com/channels/1037799583784370196/1096271712959615100/1096271712959615100)  
+
+civitai에 그 모델을 신고하여 수정할 수 있도록 해주시기 바랍니다.  
+
+
+### Colab 사용시 스캔 실패
+먼저 보이는 오류 메시지를 Google에서 검색해보세요. 대개 Colab의 문제일 가능성이 높습니다.  
+
+그리고 Colab이 Google 드라이브에 연결되어 있다면, 파일에 대한 일회성 액세스 제한으로 인해 스캔이 실패할 수 있습니다. 이는 Google 드라이브의 제한 사항으로, 자세한 내용은 Google 검색을 통해 알아보세요.  
+
+
+

README.md

@@ -0,0 +1,329 @@
+### Language
+[中文](README.cn.md)   
+[日本語](README.jp.md)  
+[한국어(ChatGPT)](README.kr.md)  
+
+## About Civitai Helper2: Model Info Helper
+Civitai Helper 2 will be renamed to **ModelInfo Helper**. It is under development, you can watch its UI demo video to see how it gonna look like:    
+[YouTube](https://youtu.be/mPcKwQDDH8s)  
+
+# Notice
+**This extension now is very stable and works well for many people. If you have an issue, check console log window's detail and read [common issue](#common-issue) part**   
+
+If you want to claim it doesn't work, check this first: [Claim Wall](claim_wall.md)  
+
+
+# Civitai Helper
+Stable Diffusion Webui Extension for Civitai, to handle your models much more easily.  
+
+Civitai: [Civitai Url](https://civitai.com/models/16768/civitai-helper-sd-webui-civitai-extension)  
+
+# Features
+* Scans all models to download model information and preview images from Civitai.  
+* Link local model to a civitai model by civitai model's url
+* Download a model(with info+preview) by Civitai Url into SD's model folder or subfolder.
+* Downloading can resume at break-point, which is good for large file. 
+* Checking all your local model's new version from Civitai
+* Download a new version directly into SD model folder (with info+preview)
+* Modified Built-in "Extra Network" cards, to add the following buttons on each card:
+  - 🖼️: Modified "replace preview" text into this icon
+  - 🌐: Open this model's Civitai url in a new tab
+  - 💡: Add this model's trigger words to prompt
+  - 🏷️: Use this model's preview image's prompt
+* Above buttons support thumbnail mode of Extra Network
+* Option to always show additional buttons, to work with touchscreen.  
+
+
+# Install
+Go to SD webui's extension tab, go to `Install from url` sub-tab.
+Copy this project's url into it, click install.  
+
+Alternatively, download this project as a zip file, and unzip it to `Your SD webui folder/extensions`.
+
+Everytime you install or update this extension, you need to shutdown SD Webui and Relaunch it. Just "Reload UI" won't work for this extension.
+
+Done.
+
+# How to Use
+
+## Update Your SD Webui
+This extension need to get extra network's cards id. Which is added since **2023-02-06**.  
+**If your SD webui is an earlier version, you need to update it!**  
+
+## Scanning Models
+Go to extension tab "Civitai Helper". There is a button called "Scan model".  
+
+![](img/extension_tab.jpg)
+
+Click it and the extension will scan all your models to generate SHA256 hashes, using them to retreive model information and preview images from Civitai.
+
+**Scanning takes time, just wait it finish**
+
+For each model, it will create a json file to save all model info from Civitai. This model info file will be "Your_model_name.civitai.info" in your model folder.
+
+![](img/model_info_file.jpg)
+
+If a model info file already exists, it will be skipped. If a model cannot be found in Civitai, it will create an empty model info file, so the model won't be scanned twice.
+
+### Adding New Models
+When you have some new models, just click scan button again, to get new model's information and preview images. It won't scan the same model twice. 
+
+## Model Card
+**(Use this only after scanning finished)**   
+Open SD webui's build-in "Extra Network" tab, to show model cards.
+
+![](img/extra_network.jpg)
+
+
+Move your mouse on to the bottom of a model card. It will show 4 icon buttons:
+  - 🖼: Replace preview (a build-in button, modified from text to icon)
+  - 🌐: Open this model's Civitai url in a new tab
+  - 💡: Add this model's trigger words to prompt
+  - 🏷: Use this model's preview image's prompt
+
+![](img/model_card.jpg)
+
+**If these additional buttons are not there**, click the `Refresh Civitai Helper` button to bring them back.  
+
+![](img/refresh_ch.jpg)  
+Everytime after Extra Network tab refreshed, it will remove all these additional buttons. So, you need to click `Refresh Civitai Helper` button to bring them back.  
+
+### Thumbnail Mode
+Additional buttons work on thumbnail too, but due to SD webui's CSS issue, for now, they must be always displayed on thumbnail or don't display at all.   
+![](img/thumb_mode.jpg)
+
+
+## Download 
+To download a model by Civitai Model Page's Url, you need 3 steps:
+* Fill url, click button to get model info
+* It will show model name and type automatically. Just choose sub-folder and model version
+* Click download.
+![](img/download_model.jpg)
+
+Detail will be displayed on console log, with a progress bar.   
+Downloading can resume from break-point, so no fear for large file.   
+
+## Checking Model's New Version
+You can checking your local model's new version from civitai by model types. You can select multiple model types.   
+![](img/check_model_new_version.jpg)  
+
+The checking process has a "1 second delay" after each model's new version checking request. So it is a little slow.  
+
+This is to protect Civitai from issue like DDos from this extension. Some cloud service provider has a rule as "no more than 1 API request in a second for free user". Civitai doesn't have this rule yet, but we still need to protect it. There is no good for us if it is down.  
+
+**After checking process done**, it will display all new version's information on UI.  
+
+There are 3 urls for each new version. 
+* First one is model's civitai page.  
+* Second one is new version's download url.    
+* Third one is a button to download it into your SD's model folder with python.  
+With this one, output information is on "Download Model" section's log and console log. **One task at a time**.  
+
+![](img/check_model_new_version_output.jpg)
+
+
+## Get Model Info By Url
+This is used to force a local model links to a Civitai model. For example, you converted a model's format or pruned it. Then it can not be found on civitai when scanning.  
+
+In that case, if you still want to link it to a civitai model. You can use this funcion.   
+
+Choose this model from list, then offer a civitai model page's url.   
+
+After clicking button, extension will download that civitai model's info and preview image for the local file you picked.  
+
+![](img/get_one_model_info.jpg)  
+
+## Proxy
+**If you are updating to new version, you need to re-lanuch SD webui before using it.**   
+
+Proxy textbox is at the bottom of extension tab. 
+
+**Each time you fill or clear a proxy value, you need to save setting, and Re-load UI with setting tab's reload button.**  
+
+Then all requests to civitai will use the proxy.  
+
+For some sock5 proxy, need to be used as "socks5h://xxxxx".  
+
+
+
+
+## Other Setting
+**The Save Setting button, will save both "Scan Model"'s setting and other setting.**  
+
+* "Always Display Button" is good for touch screen.  
+* "Show Buttons on Thumb Mode" will turn on/off additional Buttons on thumbnail.  
+![](img/other_setting.jpg)
+
+
+
+
+## Preview Image
+Extra network uses both `model_file.png` and `model_file.preview.png` as preview image. But `model_file.png` has higher priority, because it is created by yourself.  
+
+When you don't have the higher priority one, it will use the other automatically.  
+
+## Prompt
+When you click the button "Use prompt from preview image", it does not use the prompt from your own preview image. It uses the one from civitai's preview image.  
+
+On civitai, a model's preview images may not has prompt. This extension will check this model's all civitai preview images' information and use the first one has prompt in it.  
+
+## SHA256
+To create a file SHA256, it need to read the whole file to generate a hash code. It gonna be slow for large files. 
+
+Also, extension uses Memory Optimized SHA256, which won't stuck your system and works with colab.  
+
+There are 2 cases this hash code can not find the model on civitai:
+* Some old models, which do not have SHA256 code on civitai.
+* The model's owner changed file on civitai, but does not change version name and description. So, the file on civitai is actually not the one on your manchine.  
+
+In these cases, you can always link a model to civitai by filling its URL in this extension.
+
+
+
+## Feature Request
+No new feature for v1.x after v1.5. All new feature will go to 2.x.
+
+2.x will focus on custom model information and may change name to "Model Info Helper", because it is not just focus on Civitai anymore. 
+
+From v1.5, v1.x goes into maintenance phase. 
+
+Enjoy!
+
+
+## Common Issue
+### 4 Buttons on card didn't show
+#### Localization
+There was a Localization issue if you are not using English version of SD webui. This is fixed in the latest version of this extension. **Bilingual localization extension is supported by PR since v1.6.1.1.**  
+
+##### Using cloud based localization extension
+Turn off cloud based localization extension, use normal localization extension.  
+
+#### Other case
+First of all, make sure you clicked "Refresh Civitai Helper" button.  
+
+If issue is still there, then only reason is you are not using the latest SD webui. So, Make sure you updated it.  
+
+Your update could be failed if you have modified SD webui's file. You need to check git command's console log to make sure it is updated. 
+
+In many cases, git will just refuse to update and tell you there are some conflicts need you to handle manually. If you don't check the consloe log, you will think your SD webui is updated, but it is not.  
+
+### Request, Scan or Get model info failed
+This extension is stable. So, the reason for this most likely is your internet connection to Civitai API service.  
+
+Civitai is not as stable as those rich websites, it can be down or refuse your API connection.  
+
+Civitai has a connection pool setting. Basicly, it's a max connection number that civitai can have at the same time. So, if there are already too manny connections on civitai, it will refuse your API connection.  
+
+In those cases, the only thing you can do is just wait a while then try again.  
+
+### Get Wrong model info and preview images from civitai
+A bad news is, some models are saved with a wrong sha256 in civitai's database. Check here for more detail:  
+[https://github.com/civitai/civitai/issues/426](https://github.com/civitai/civitai/issues/426)  
+
+So, for those models, this extension can not get the right model info or preview images.   
+
+In this case, you have to remove the model info file and get the right model info by a civitai url on this extension's tab page.  
+
+Also, you can report those models with wrong sha256 to civitai at following page:   
+[https://discord.com/channels/1037799583784370196/1096271712959615100/1096271712959615100](https://discord.com/channels/1037799583784370196/1096271712959615100/1096271712959615100)  
+
+Please report that model to civitai, so they can fix it.  
+
+
+
+
+### Scanning fail when using colab
+First of, search your error message with google. Most likely, it will be a colab issue.    
+
+If you are sure it is a out of memory issue when scanning models, and you are using this extension's latest version, then there is nothing we can do.   
+
+Since v1.5.5, we've already optimized the SHA256 function to the top. So the only 2 choices for you are:  
+* try again  
+* or use a pro account of colab.  
+
+
+
+
+
+# Change Log
+## v1.6.4
+* Add "Download All files" checkbox for downloading model section. Uncheck means only download 1 file.
+
+## v1.6.3
+* Support downloading multiple files, not avaiable when checking new version.
+
+## v1.6.2.1
+* when parsing civitai url, remove query string by PR
+
+## v1.6.2
+* When downloading, re-name file if file already exists
+
+## v1.6.1.1
+* Support bilingual localization extension by PR
+
+## v1.6.1
+* Fix Localization issue for 4 addtional buttons on cards. (Forgot that again...)
+
+## v1.6.0
+* Fix some UI issues to work with gradio 3.23.0
+* Support Proxy when connecting to civitai. Check document for detail.
+* check realpath when opening file, to fix error when using junction
+* Fix multiple addtional buttons issue after switching tabs. 
+
+## v1.5.7
+* Fix Localization issue for 4 addtional buttons on cards
+
+## v1.5.6
+* update error msg when can not connect to civitai API service
+* update thumb mode for SD webui new version's metadata button
+
+## v1.5.5
+* update SHA256 function, now it just use the code from pip
+
+## v1.5.4
+* set sys.stdout to utf-8
+* Add default header for requests to prevent from being blocked by civitai.
+* merge other v1.5.x change log to v1.5.4
+* When downloading a model by url, check if target model version is already existed in user selected sub-folder.
+* Support scanning only selected model types. 
+* Force TI scanning delay 1 second to prevent from civitai treating this extension's requests as attacking.
+
+## v1.5.0
+* Download a model by Civitai model page's url
+* Resume downloading from break-point
+* Download new version into SD Webui's model folder
+* Addtional button now works on thumbnail mode
+* Option to always show addtion button, for touch screen.
+
+## v1.4.2
+* ignore .vae file in model folder when scanning
+
+## v1.4.1
+* When checking new versions, also searching and ignore already existed ones.
+* Add version number to the bottom of this extension's tab
+
+## v1.4
+* Support checking model's new version, display the result in UI and offer download url
+* Remove addintional sub tabs on extension tab. make ui simpler.
+
+## v1.3
+* Open url at client side
+* Link selected model to civitai by url or model id
+* Save and load extension setting to file
+* Show button action's output to UI
+* Code refactoring
+
+## v1.2.1
+* Add more error checking to work with different versions of SD webui. 
+
+## v1.2
+* Support customer model folder
+* Support readable model info file
+* Support download preview image with max size
+* Remove card buttons when extra network is in thumbnail mode
+
+## v1.1
+* Support subfolders
+* Check if refresh is needed when clicking "Refresh Civitai Helper"
+* Add space when adding trigger words
+* Add memory Optimized sha256 as an option

claim_wall.md

@@ -0,0 +1,91 @@
+# Claim Wall
+
+Since this extension got a little hot, some users come to **claim many other issues to this extension**.   
+
+Following is a wall, to show a few examples how they claim this extension doesn't work, because they don't read document or forget what they did before.  
+
+If you are looking for guideline, go to section [What you should do](#what-you-should-do)  
+
+# Wall
+
+### Didn't even update SD Webui and claim "tried everything"
+
+![](img/user_claim_wall/have_not_update_sdwebui.jpg)  
+
+
+### Havn't even scanned model
+After 4 replies, find that out, and modified his comment.  
+
+![](img/user_claim_wall/have_not_scan_model.jpg)  
+
+### Claim "pretty sure" this extension breaks his UI, takes 2days to find out it is not
+Then removed his comment from civitai, but his post on reddit is still there, so you can know what's really going on there.  
+
+1. Claim "pretty sure" this extension breaks his UI
+
+![](img/user_claim_wall/css_issue_part1.jpg)  
+
+![](img/user_claim_wall/css_issue_part2.jpg)  
+
+2. Find out it is not, after 2 days  
+
+![](img/user_claim_wall/css_issue_part3.jpg)  
+
+3. Still don't remember what he did with other extensions, until another user tells him, about 4 days later.  
+
+![](img/user_claim_wall/css_issue_part4.jpg)  
+
+### **Blame SD Webui's modification to this extension**  
+Latest SD webui removed a button from UI, they claim this extension did that, and want it back by this extension  
+
+![](img/user_claim_wall/blame_sdweui_update_to_this_ext.jpg)  
+
+### Claim other extension's error to this extension
+Just because both extensions have "Civitai" in extension's name  
+
+![](img/user_claim_wall/do_not_even_use_this_ext.jpg)   
+
+
+### **Didn't even use this extension and request a feature it already has**  
+
+![](img/user_claim_wall/request_a_feature_it_already_has.jpg)  
+
+### **Renamed model folder's name carelessly and forgot that**
+Takes about 8 hours to find out why this extension doesn't work on his SDwebui and ready to re-install SD webui from beginning. 
+
+1. claim this extension can not open civitai url on checkpoint models  
+  
+![](img/user_claim_wall/changed_model_folder_name_then_forget_part1.jpg)  
+
+2. I reply that model he mentioned works well in my SDwebui  
+  
+![](img/user_claim_wall/changed_model_folder_name_then_forget_part2.jpg)  
+
+3. After 6 hours' trying, find out his model folder's name is modified.  
+  
+![](img/user_claim_wall/changed_model_folder_name_then_forget_part3.jpg)  
+
+![](img/user_claim_wall/changed_model_folder_name_then_forget_part4.jpg)  
+
+
+# What you should do
+Above are just a very small piece of this kind of claims. Those claims won't help you. If you have an issue, following is the guidline:   
+
+* If you want to make your extension work, read the document.   
+
+* If your SD webui is broken, before you claim it is caused by this extension, you can disable it and try again.   
+
+* If you followed document, but it still doesn't work well, you can check console log's msg to find out the reason. If you can not understand those msg, you can come and ask for help, with console log's msg or screenshot.    
+
+* If you are using colab, and get an error from colab, then search that error msg in google. Because it's a colab's issue or limitation.    
+
+* If you checked console log window's msg and understand what it means, you are welcome to submit your issue.  
+
+
+
+
+
+
+
+
+

javascript/civitai_helper.js

@@ -0,0 +1,728 @@
+"use strict";
+
+
+function ch_convert_file_path_to_url(path){
+    let prefix = "file=";
+    let path_to_url = path.replaceAll('\\', '/');
+    return prefix+path_to_url;
+}
+
+function ch_img_node_str(path){
+    return `<img src='${ch_convert_file_path_to_url(path)}' style="width:24px"/>`;
+}
+
+
+function ch_gradio_version(){
+    let foot = gradioApp().getElementById("footer");
+    if (!foot){return null;}
+
+    let versions = foot.querySelector(".versions");
+    if (!versions){return null;}
+
+    if (versions.innerHTML.indexOf("gradio: 3.16.2")>0) {
+        return "3.16.2";
+    } else {
+        return "3.23.0";
+    }
+    
+}
+
+
+// send msg to python side by filling a hidden text box
+// then will click a button to trigger an action
+// msg is an object, not a string, will be stringify in this function
+function send_ch_py_msg(msg){
+    console.log("run send_ch_py_msg")
+    let js_msg_txtbox = gradioApp().querySelector("#ch_js_msg_txtbox textarea");
+    if (js_msg_txtbox && msg) {
+        // fill to msg box
+        js_msg_txtbox.value = JSON.stringify(msg);
+        js_msg_txtbox.dispatchEvent(new Event("input"));
+    }
+
+}
+
+// get msg from python side from a hidden textbox
+// normally this is an old msg, need to wait for a new msg
+function get_ch_py_msg(){
+    console.log("run get_ch_py_msg")
+    const py_msg_txtbox = gradioApp().querySelector("#ch_py_msg_txtbox textarea");
+    if (py_msg_txtbox && py_msg_txtbox.value) {
+        console.log("find py_msg_txtbox");
+        console.log("py_msg_txtbox value: ");
+        console.log(py_msg_txtbox.value)
+        return py_msg_txtbox.value
+    } else {
+        return ""
+    }
+}
+
+
+// get msg from python side from a hidden textbox
+// it will try once in every sencond, until it reach the max try times
+const get_new_ch_py_msg = (max_count=3) => new Promise((resolve, reject) => {
+    console.log("run get_new_ch_py_msg")
+
+    let count = 0;
+    let new_msg = "";
+    let find_msg = false;
+    const interval = setInterval(() => {
+        const py_msg_txtbox = gradioApp().querySelector("#ch_py_msg_txtbox textarea");
+        count++;
+
+        if (py_msg_txtbox && py_msg_txtbox.value) {
+            console.log("find py_msg_txtbox");
+            console.log("py_msg_txtbox value: ");
+            console.log(py_msg_txtbox.value)
+
+            new_msg = py_msg_txtbox.value
+            if (new_msg != "") {
+                find_msg=true
+            }
+        }
+
+        if (find_msg) {
+            //clear msg in both sides
+            py_msg_txtbox.value = "";
+            py_msg_txtbox.dispatchEvent(new Event("input"));
+
+            resolve(new_msg);
+            clearInterval(interval);
+        } else if (count > max_count) {
+            //clear msg in both sides
+            py_msg_txtbox.value = "";
+            py_msg_txtbox.dispatchEvent(new Event("input"));
+
+            reject('');
+            clearInterval(interval);
+        }
+
+    }, 1000);
+})
+
+
+function getActiveTabType() {
+    const currentTab = get_uiCurrentTabContent();
+    switch (currentTab.id) {
+        case "tab_txt2img":
+            return "txt2img";
+        case "tab_img2img":
+            return "img2img";
+    }
+    return null;
+}
+
+
+
+function getActivePrompt() {
+    const currentTab = get_uiCurrentTabContent();
+    switch (currentTab.id) {
+        case "tab_txt2img":
+            return currentTab.querySelector("#txt2img_prompt textarea");
+        case "tab_img2img":
+            return currentTab.querySelector("#img2img_prompt textarea");
+    }
+    return null;
+}
+
+function getActiveNegativePrompt() {
+    const currentTab = get_uiCurrentTabContent();
+    switch (currentTab.id) {
+        case "tab_txt2img":
+            return currentTab.querySelector("#txt2img_neg_prompt textarea");
+        case "tab_img2img":
+            return currentTab.querySelector("#img2img_neg_prompt textarea");
+    }
+    return null;
+}
+
+
+//button's click function
+async function open_model_url(event, model_type, search_term){
+    console.log("start open_model_url");
+
+    //get hidden components of extension 
+    let js_open_url_btn = gradioApp().getElementById("ch_js_open_url_btn");
+    if (!js_open_url_btn) {
+        return
+    }
+
+
+    //msg to python side
+    let msg = {
+        "action": "",
+        "model_type": "",
+        "search_term": "",
+        "prompt": "",
+        "neg_prompt": "",
+    }
+
+
+    msg["action"] = "open_url";
+    msg["model_type"] = model_type;
+    msg["search_term"] = search_term;
+    msg["prompt"] = "";
+    msg["neg_prompt"] = "";
+
+    // fill to msg box
+    send_ch_py_msg(msg)
+
+    //click hidden button
+    js_open_url_btn.click();
+
+    // stop parent event
+    event.stopPropagation()
+    event.preventDefault()
+
+    //check response msg from python
+    let new_py_msg = await get_new_ch_py_msg();
+    console.log("new_py_msg:");
+    console.log(new_py_msg);
+
+    //check msg
+    if (new_py_msg) {
+        let py_msg_json = JSON.parse(new_py_msg);
+        //check for url
+        if (py_msg_json && py_msg_json.content) {
+            if (py_msg_json.content.url) {
+                window.open(py_msg_json.content.url, "_blank");
+            }
+
+        }
+
+
+    }
+
+    
+    console.log("end open_model_url");
+
+
+}
+
+function add_trigger_words(event, model_type, search_term){
+    console.log("start add_trigger_words");
+
+    //get hidden components of extension 
+    let js_add_trigger_words_btn = gradioApp().getElementById("ch_js_add_trigger_words_btn");
+    if (!js_add_trigger_words_btn) {
+        return
+    }
+
+
+    //msg to python side
+    let msg = {
+        "action": "",
+        "model_type": "",
+        "search_term": "",
+        "prompt": "",
+        "neg_prompt": "",
+    }
+
+    msg["action"] = "add_trigger_words";
+    msg["model_type"] = model_type;
+    msg["search_term"] = search_term;
+    msg["neg_prompt"] = "";
+
+    // get active prompt
+    let act_prompt = getActivePrompt();
+    msg["prompt"] = act_prompt.value;
+
+    // fill to msg box
+    send_ch_py_msg(msg)
+
+    //click hidden button
+    js_add_trigger_words_btn.click();
+
+    console.log("end add_trigger_words");
+
+    event.stopPropagation()
+    event.preventDefault()
+
+    
+}
+
+function use_preview_prompt(event, model_type, search_term){
+    console.log("start use_preview_prompt");
+
+    //get hidden components of extension 
+    let js_use_preview_prompt_btn = gradioApp().getElementById("ch_js_use_preview_prompt_btn");
+    if (!js_use_preview_prompt_btn) {
+        return
+    }
+
+    //msg to python side
+    let msg = {
+        "action": "",
+        "model_type": "",
+        "search_term": "",
+        "prompt": "",
+        "neg_prompt": "",
+    }
+
+    msg["action"] = "use_preview_prompt";
+    msg["model_type"] = model_type;
+    msg["search_term"] = search_term;
+
+    // get active prompt
+    let act_prompt = getActivePrompt();
+    msg["prompt"] = act_prompt.value;
+
+    // get active neg prompt
+    let neg_prompt = getActiveNegativePrompt();
+    msg["neg_prompt"] = neg_prompt.value;
+
+    // fill to msg box
+    send_ch_py_msg(msg)
+
+    //click hidden button
+    js_use_preview_prompt_btn.click();
+
+    console.log("end use_preview_prompt");
+
+    event.stopPropagation()
+    event.preventDefault()
+
+}
+
+
+
+// download model's new version into SD at python side
+function ch_dl_model_new_version(event, model_path, version_id, download_url){
+    console.log("start ch_dl_model_new_version");
+
+    // must confirm before downloading
+    let dl_confirm = "\nConfirm to download.\n\nCheck Download Model Section's log and console log for detail.";
+    if (!confirm(dl_confirm)) {
+        return
+    }
+
+    //get hidden components of extension 
+    let js_dl_model_new_version_btn = gradioApp().getElementById("ch_js_dl_model_new_version_btn");
+    if (!js_dl_model_new_version_btn) {
+        return
+    }
+
+    //msg to python side
+    let msg = {
+        "action": "",
+        "model_path": "",
+        "version_id": "",
+        "download_url": "",
+    }
+
+    msg["action"] = "dl_model_new_version";
+    msg["model_path"] = model_path;
+    msg["version_id"] = version_id;
+    msg["download_url"] = download_url;
+
+    // fill to msg box
+    send_ch_py_msg(msg)
+
+    //click hidden button
+    js_dl_model_new_version_btn.click();
+
+    console.log("end dl_model_new_version");
+
+    event.stopPropagation()
+    event.preventDefault()
+
+
+}
+
+
+onUiLoaded(() => {
+
+    //get gradio version
+    let gradio_ver = ch_gradio_version();
+    console.log("gradio_ver:" + gradio_ver);
+
+    // get all extra network tabs
+    let tab_prefix_list = ["txt2img", "img2img"];
+    let model_type_list = ["textual_inversion", "hypernetworks", "checkpoints", "lora"];
+    let cardid_suffix = "cards";
+
+    //get init py msg
+    // let init_py_msg_str = get_ch_py_msg();
+    // let extension_path = "";
+    // if (!init_py_msg_str) {
+    //     console.log("Can not get init_py_msg");
+    // } else {
+    //     init_py_msg = JSON.parse(init_py_msg_str);
+    //     if (init_py_msg) {
+    //         extension_path = init_py_msg.extension_path;
+    //         console.log("get extension path: " + extension_path);
+    //     }
+    // }
+
+    // //icon image node as string
+    // function icon(icon_name){
+    //     let icon_path = extension_path+"/icon/"+icon_name;
+    //     return ch_img_node_str(icon_path);
+    // }
+
+
+    // update extra network tab pages' cards
+    // * replace "replace preview" text button into an icon
+    // * add 3 button to each card:
+    //  - open model url 🌐
+    //  - add trigger words 💡
+    //  - use preview image's prompt 🏷️
+    // notice: javascript can not get response from python side
+    // so, these buttons just sent request to python
+    // then, python side gonna open url and update prompt text box, without telling js side.
+    function update_card_for_civitai(){
+
+        //css
+        let btn_margin = "0px 5px";
+        let btn_fontSize = "200%";
+        let btn_thumb_fontSize = "100%";
+        let btn_thumb_display = "inline";
+        let btn_thumb_pos = "static";
+        let btn_thumb_backgroundImage = "none";
+        let btn_thumb_background = "rgba(0, 0, 0, 0.8)";
+
+        let ch_btn_txts = ['🌐', '💡', '🏷️'];
+        let replace_preview_text = getTranslation("replace preview");
+        if (!replace_preview_text) {
+            replace_preview_text = "replace preview";
+        }
+        
+
+
+        // get component
+        let ch_always_display_ckb = gradioApp().querySelector("#ch_always_display_ckb input");
+        let ch_show_btn_on_thumb_ckb = gradioApp().querySelector("#ch_show_btn_on_thumb_ckb input");
+        let ch_always_display = false;
+        let ch_show_btn_on_thumb = false;
+        if (ch_always_display_ckb) {
+            ch_always_display = ch_always_display_ckb.checked;
+        }
+        if (ch_show_btn_on_thumb_ckb) {
+            ch_show_btn_on_thumb = ch_show_btn_on_thumb_ckb.checked;
+        }
+
+
+        //change all "replace preview" into an icon
+        let extra_network_id = "";
+        let extra_network_node = null;
+        let metadata_button = null;
+        let additional_node = null;
+        let replace_preview_btn = null;
+        let ul_node = null;
+        let search_term_node = null;
+        let search_term = "";
+        let model_type = "";
+        let cards = null;
+        let need_to_add_buttons = false;
+        let is_thumb_mode = false;
+
+        //get current tab
+        let active_tab_type = getActiveTabType();
+        if (!active_tab_type){active_tab_type = "txt2img";}
+
+        for (const tab_prefix of tab_prefix_list) {
+            if (tab_prefix != active_tab_type) {continue;}
+
+
+            //find out current selected model type tab
+            let active_extra_tab_type = "";
+            let extra_tabs = gradioApp().getElementById(tab_prefix+"_extra_tabs");
+            if (!extra_tabs) {console.log("can not find extra_tabs: " + tab_prefix+"_extra_tabs");}
+
+            //get active extratab
+            const active_extra_tab = Array.from(get_uiCurrentTabContent().querySelectorAll('.extra-network-cards,.extra-network-thumbs'))
+                .find(el => el.closest('.tabitem').style.display === 'block')
+                ?.id.match(/^(txt2img|img2img)_(.+)_cards$/)[2]
+
+                
+            console.log("found active tab: " + active_extra_tab);
+
+            switch (active_extra_tab) {
+                case "textual_inversion":
+                    active_extra_tab_type = "ti";
+                    break;
+                case "hypernetworks":
+                    active_extra_tab_type = "hyper";
+                    break;
+                case "checkpoints":
+                    active_extra_tab_type = "ckp";
+                    break;
+                case "lora":
+                    active_extra_tab_type = "lora";
+                    break;
+            }
+
+
+            for (const js_model_type of model_type_list) {
+                //get model_type for python side
+                switch (js_model_type) {
+                    case "textual_inversion":
+                        model_type = "ti";
+                        break;
+                    case "hypernetworks":
+                        model_type = "hyper";
+                        break;
+                    case "checkpoints":
+                        model_type = "ckp";
+                        break;
+                    case "lora":
+                        model_type = "lora";
+                        break;
+                }
+
+                if (!model_type) {
+                    console.log("can not get model_type from: " + js_model_type);
+                    continue;
+                }
+
+
+                //only handle current sub-tab
+                if (model_type != active_extra_tab_type) {
+                    continue;
+                }
+
+                console.log("handle active extra tab");
+
+
+                extra_network_id = tab_prefix+"_"+js_model_type+"_"+cardid_suffix;
+                // console.log("searching extra_network_node: " + extra_network_id);
+                extra_network_node = gradioApp().getElementById(extra_network_id);
+                // check if extr network is under thumbnail mode
+                is_thumb_mode = false
+                if (extra_network_node) {
+                    if (extra_network_node.className == "extra-network-thumbs") {
+                        console.log(extra_network_id + " is in thumbnail mode");
+                        is_thumb_mode = true;
+                        // if (!ch_show_btn_on_thumb) {continue;}
+                    }
+                } else {
+                    console.log("can not find extra_network_node: " + extra_network_id);
+                    continue;
+                }
+                // console.log("find extra_network_node: " + extra_network_id);
+
+                // get all card nodes
+                cards = extra_network_node.querySelectorAll(".card");
+                for (let card of cards) {
+                    //metadata_buttoncard
+                    metadata_button = card.querySelector(".metadata-button");
+                    //additional node
+                    additional_node = card.querySelector(".actions .additional");
+                    //get ul node, which is the parent of all buttons
+                    ul_node = card.querySelector(".actions .additional ul");
+                    // replace preview text button
+                    replace_preview_btn = card.querySelector(".actions .additional a");
+
+                    // check thumb mode
+                    if (is_thumb_mode) {
+                        additional_node.style.display = null;
+
+                        if (ch_show_btn_on_thumb) {
+                            ul_node.style.background = btn_thumb_background;
+                        } else {
+                            //reset
+                            ul_node.style.background = null;
+                            // console.log("remove existed buttons");
+                            // remove existed buttons
+                            if (ul_node) {
+                                // find all .a child nodes
+                                let atags = ul_node.querySelectorAll("a");
+                                
+                                for (let atag of atags) {
+                                    //reset display
+                                    atag.style.display = null;
+                                    //remove extension's button
+                                    if (ch_btn_txts.indexOf(atag.innerHTML)>=0) {
+                                        //need to remove
+                                        ul_node.removeChild(atag);
+                                    } else {
+                                        //do not remove, just reset
+                                        atag.innerHTML = replace_preview_text;
+                                        atag.style.display = null;
+                                        atag.style.fontSize = null;
+                                        atag.style.position = null;
+                                        atag.style.backgroundImage = null;
+                                    }
+                                }
+
+                                //also remove br tag in ul
+                                let brtag = ul_node.querySelector("br");
+                                if (brtag) {
+                                    ul_node.removeChild(brtag);
+                                }
+
+                            }
+                            //just reset and remove nodes, do nothing else
+                            continue;
+
+                        }
+
+                    } else {
+                        // full preview mode
+                        if (ch_always_display) {
+                            additional_node.style.display = "block";
+                        } else {
+                            additional_node.style.display = null;
+                        }
+
+                        // remove br tag
+                        let brtag = ul_node.querySelector("br");
+                        if (brtag) {
+                            ul_node.removeChild(brtag);
+                        }
+
+                    }
+
+                    // change replace preview text button into icon
+                    if (replace_preview_btn) {
+                        if (replace_preview_btn.innerHTML !== "🖼️") {
+                            need_to_add_buttons = true;
+                            replace_preview_btn.innerHTML = "🖼️";
+                            if (!is_thumb_mode) {
+                                replace_preview_btn.style.fontSize = btn_fontSize;
+                                replace_preview_btn.style.margin = btn_margin;
+                            } else {
+                                replace_preview_btn.style.display = btn_thumb_display;
+                                replace_preview_btn.style.fontSize = btn_thumb_fontSize;
+                                replace_preview_btn.style.position = btn_thumb_pos;
+                                replace_preview_btn.style.backgroundImage = btn_thumb_backgroundImage;
+                            }
+
+                        }
+                    }
+
+                    if (!need_to_add_buttons) {
+                        continue;
+                    }
+
+
+                    // search_term node
+                    // search_term = subfolder path + model name + ext
+                    search_term_node = card.querySelector(".actions .additional .search_term");
+                    if (!search_term_node){
+                        console.log("can not find search_term node for cards in " + extra_network_id);
+                        continue;
+                    }
+
+                    // get search_term
+                    search_term = search_term_node.innerHTML;
+                    if (!search_term) {
+                        console.log("search_term is empty for cards in " + extra_network_id);
+                        continue;
+                    }
+
+
+
+                    // if (is_thumb_mode) {
+                    //     ul_node.style.background = btn_thumb_background;
+                    // }
+
+                    // then we need to add 3 buttons to each ul node:
+                    let open_url_node = document.createElement("a");
+                    open_url_node.href = "#";
+                    open_url_node.innerHTML = "🌐";
+                    if (!is_thumb_mode) {
+                        open_url_node.style.fontSize = btn_fontSize;
+                        open_url_node.style.margin = btn_margin;
+                    } else {
+                        open_url_node.style.display = btn_thumb_display;
+                        open_url_node.style.fontSize = btn_thumb_fontSize;
+                        open_url_node.style.position = btn_thumb_pos;
+                        open_url_node.style.backgroundImage = btn_thumb_backgroundImage;
+                    }
+                    open_url_node.title = "Open this model's civitai url";
+                    open_url_node.setAttribute("onclick","open_model_url(event, '"+model_type+"', '"+search_term+"')");
+
+                    let add_trigger_words_node = document.createElement("a");
+                    add_trigger_words_node.href = "#";
+                    add_trigger_words_node.innerHTML = "💡";
+                    if (!is_thumb_mode) {
+                        add_trigger_words_node.style.fontSize = btn_fontSize;
+                        add_trigger_words_node.style.margin = btn_margin;
+                    } else {
+                        add_trigger_words_node.style.display = btn_thumb_display;
+                        add_trigger_words_node.style.fontSize = btn_thumb_fontSize;
+                        add_trigger_words_node.style.position = btn_thumb_pos;
+                        add_trigger_words_node.style.backgroundImage = btn_thumb_backgroundImage;
+                    }
+
+                    add_trigger_words_node.title = "Add trigger words to prompt";
+                    add_trigger_words_node.setAttribute("onclick","add_trigger_words(event, '"+model_type+"', '"+search_term+"')");
+
+                    let use_preview_prompt_node = document.createElement("a");
+                    use_preview_prompt_node.href = "#";
+                    use_preview_prompt_node.innerHTML = "🏷️";
+                    if (!is_thumb_mode) {
+                        use_preview_prompt_node.style.fontSize = btn_fontSize;
+                        use_preview_prompt_node.style.margin = btn_margin;
+                    } else {
+                        use_preview_prompt_node.style.display = btn_thumb_display;
+                        use_preview_prompt_node.style.fontSize = btn_thumb_fontSize;
+                        use_preview_prompt_node.style.position = btn_thumb_pos;
+                        use_preview_prompt_node.style.backgroundImage = btn_thumb_backgroundImage;
+                    }
+                    use_preview_prompt_node.title = "Use prompt from preview image";
+                    use_preview_prompt_node.setAttribute("onclick","use_preview_prompt(event, '"+model_type+"', '"+search_term+"')");
+
+                    //add to card
+                    ul_node.appendChild(open_url_node);
+                    //add br if metadata_button exists
+                    if (is_thumb_mode && metadata_button) {
+                        ul_node.appendChild(document.createElement("br"));
+                    }
+                    ul_node.appendChild(add_trigger_words_node);
+                    ul_node.appendChild(use_preview_prompt_node);
+
+
+
+
+                }
+
+                
+            }
+        }
+
+
+    }
+
+
+    let tab_id = ""
+    let extra_tab = null;
+    let extra_toolbar = null;
+    let extra_network_refresh_btn = null;
+    //add refresh button to extra network's toolbar
+    for (let prefix of tab_prefix_list) {
+        tab_id = prefix + "_extra_tabs";
+        extra_tab = gradioApp().getElementById(tab_id);
+
+        //get toolbar
+        //get Refresh button
+        extra_network_refresh_btn = gradioApp().getElementById(prefix+"_extra_refresh");
+
+
+        if (!extra_network_refresh_btn){
+            console.log("can not get extra network refresh button for " + tab_id);
+            continue;
+        }
+
+        // add refresh button to toolbar
+        let ch_refresh = document.createElement("button");
+        ch_refresh.innerHTML = "🔁";
+        ch_refresh.title = "Refresh Civitai Helper's additional buttons";
+        ch_refresh.className = "lg secondary gradio-button";
+        ch_refresh.style.fontSize = "200%";
+        ch_refresh.onclick = update_card_for_civitai;
+
+        extra_network_refresh_btn.parentNode.appendChild(ch_refresh);
+
+    }
+
+
+    //run it once
+    update_card_for_civitai();
+
+
+});
+
+
+

scripts/ch_lib/civitai.py

@@ -0,0 +1,612 @@
+# -*- coding: UTF-8 -*-
+# handle msg between js and python side
+import os
+import time
+import json
+import re
+import requests
+from . import util
+from . import model
+from . import setting
+
+suffix = ".civitai"
+
+url_dict = {
+    "modelPage":"https://civitai.com/models/",
+    "modelId": "https://civitai.com/api/v1/models/",
+    "modelVersionId": "https://civitai.com/api/v1/model-versions/",
+    "hash": "https://civitai.com/api/v1/model-versions/by-hash/"
+}
+
+model_type_dict = {
+    "Checkpoint": "ckp",
+    "TextualInversion": "ti",
+    "Hypernetwork": "hyper",
+    "LORA": "lora",
+    "LoCon": "lora",
+}
+
+
+
+# get image with full size
+# width is in number, not string
+# return: url str
+def get_full_size_image_url(image_url, width):
+    return re.sub('/width=\d+/', '/width=' + str(width) + '/', image_url)
+
+
+# use this sha256 to get model info from civitai
+# return: model info dict
+def get_model_info_by_hash(hash:str):
+    util.printD("Request model info from civitai")
+
+    if not hash:
+        util.printD("hash is empty")
+        return
+
+    r = requests.get(url_dict["hash"]+hash, headers=util.def_headers, proxies=util.proxies)
+    if not r.ok:
+        if r.status_code == 404:
+            # this is not a civitai model
+            util.printD("Civitai does not have this model")
+            return {}
+        else:
+            util.printD("Get error code: " + str(r.status_code))
+            util.printD(r.text)
+            return
+
+    # try to get content
+    content = None
+    try:
+        content = r.json()
+    except Exception as e:
+        util.printD("Parse response json failed")
+        util.printD(str(e))
+        util.printD("response:")
+        util.printD(r.text)
+        return
+    
+    if not content:
+        util.printD("error, content from civitai is None")
+        return
+    
+    return content
+
+
+
+def get_model_info_by_id(id:str) -> dict:
+    util.printD("Request model info from civitai")
+
+    if not id:
+        util.printD("id is empty")
+        return
+
+    r = requests.get(url_dict["modelId"]+str(id), headers=util.def_headers, proxies=util.proxies)
+    if not r.ok:
+        if r.status_code == 404:
+            # this is not a civitai model
+            util.printD("Civitai does not have this model")
+            return {}
+        else:
+            util.printD("Get error code: " + str(r.status_code))
+            util.printD(r.text)
+            return
+
+    # try to get content
+    content = None
+    try:
+        content = r.json()
+    except Exception as e:
+        util.printD("Parse response json failed")
+        util.printD(str(e))
+        util.printD("response:")
+        util.printD(r.text)
+        return
+    
+    if not content:
+        util.printD("error, content from civitai is None")
+        return
+    
+    return content
+
+
+def get_version_info_by_version_id(id:str) -> dict:
+    util.printD("Request version info from civitai")
+
+    if not id:
+        util.printD("id is empty")
+        return
+
+    r = requests.get(url_dict["modelVersionId"]+str(id), headers=util.def_headers, proxies=util.proxies)
+    if not r.ok:
+        if r.status_code == 404:
+            # this is not a civitai model
+            util.printD("Civitai does not have this model version")
+            return {}
+        else:
+            util.printD("Get error code: " + str(r.status_code))
+            util.printD(r.text)
+            return
+
+    # try to get content
+    content = None
+    try:
+        content = r.json()
+    except Exception as e:
+        util.printD("Parse response json failed")
+        util.printD(str(e))
+        util.printD("response:")
+        util.printD(r.text)
+        return
+    
+    if not content:
+        util.printD("error, content from civitai is None")
+        return
+    
+    return content
+
+
+def get_version_info_by_model_id(id:str) -> dict:
+
+    model_info = get_model_info_by_id(id)
+    if not model_info:
+        util.printD(f"Failed to get model info by id: {id}")
+        return
+    
+    # check content to get version id
+    if "modelVersions" not in model_info.keys():
+        util.printD("There is no modelVersions in this model_info")
+        return
+    
+    if not model_info["modelVersions"]:
+        util.printD("modelVersions is None")
+        return
+    
+    if len(model_info["modelVersions"])==0:
+        util.printD("modelVersions is Empty")
+        return
+    
+    def_version = model_info["modelVersions"][0]
+    if not def_version:
+        util.printD("default version is None")
+        return
+    
+    if "id" not in def_version.keys():
+        util.printD("default version has no id")
+        return
+    
+    version_id = def_version["id"]
+    
+    if not version_id:
+        util.printD("default version's id is None")
+        return
+
+    # get version info
+    version_info = get_version_info_by_version_id(str(version_id))
+    if not version_info:
+        util.printD(f"Failed to get version info by version_id: {version_id}")
+        return
+
+    return version_info
+
+
+
+
+# get model info file's content by model type and search_term
+# parameter: model_type, search_term
+# return: model_info
+def load_model_info_by_search_term(model_type, search_term):
+    util.printD(f"Load model info of {search_term} in {model_type}")
+    if model_type not in model.folders.keys():
+        util.printD("unknow model type: " + model_type)
+        return
+    
+    # search_term = subfolderpath + model name + ext. And it always start with a / even there is no sub folder
+    base, ext = os.path.splitext(search_term)
+    model_info_base = base
+    if base[:1] == "/":
+        model_info_base = base[1:]
+
+    model_folder = model.folders[model_type]
+    model_info_filename = model_info_base + suffix + model.info_ext
+    model_info_filepath = os.path.join(model_folder, model_info_filename)
+
+    if not os.path.isfile(model_info_filepath):
+        util.printD("Can not find model info file: " + model_info_filepath)
+        return
+    
+    return model.load_model_info(model_info_filepath)
+
+
+
+
+
+# get model file names by model type
+# parameter: model_type - string
+# parameter: filter - dict, which kind of model you need
+# return: model name list
+def get_model_names_by_type_and_filter(model_type:str, filter:dict) -> list:
+    
+    model_folder = model.folders[model_type]
+
+    # set filter
+    # only get models don't have a civitai info file
+    no_info_only = False
+    empty_info_only = False
+
+    if filter:
+        if "no_info_only" in filter.keys():
+            no_info_only = filter["no_info_only"]
+        if "empty_info_only" in filter.keys():
+            empty_info_only = filter["empty_info_only"]
+
+
+
+    # get information from filter
+    # only get those model names don't have a civitai model info file
+    model_names = []
+    for root, dirs, files in os.walk(model_folder, followlinks=True):
+        for filename in files:
+            item = os.path.join(root, filename)
+            # check extension
+            base, ext = os.path.splitext(item)
+            if ext in model.exts:
+                # find a model
+
+                # check filter
+                if no_info_only:
+                    # check model info file
+                    info_file = base + suffix + model.info_ext
+                    if os.path.isfile(info_file):
+                        continue
+
+                if empty_info_only:
+                    # check model info file
+                    info_file = base + suffix + model.info_ext
+                    if os.path.isfile(info_file):
+                        # load model info
+                        model_info = model.load_model_info(info_file)
+                        # check content
+                        if model_info:
+                            if "id" in model_info.keys():
+                                # find a non-empty model info file
+                                continue
+
+                model_names.append(filename)
+
+
+    return model_names
+
+def get_model_names_by_input(model_type, empty_info_only):
+    return get_model_names_by_type_and_filter(model_type, {"empty_info_only":empty_info_only})
+    
+
+# get id from url
+def get_model_id_from_url(url:str) -> str:
+    util.printD("Run get_model_id_from_url")
+    id = ""
+
+    if not url:
+        util.printD("url or model id can not be empty")
+        return ""
+
+    if url.isnumeric():
+        # is already an id
+        id = str(url)
+        return id
+    
+    s = re.sub("\\?.+$", "", url).split("/")
+    if len(s) < 2:
+        util.printD("url is not valid")
+        return ""
+    
+    if s[-2].isnumeric():
+        id  = s[-2]
+    elif s[-1].isnumeric():
+        id  = s[-1]
+    else:
+        util.printD("There is no model id in this url")
+        return ""
+    
+    return id
+
+
+# get preview image by model path
+# image will be saved to file, so no return
+def get_preview_image_by_model_path(model_path:str, max_size_preview, skip_nsfw_preview):
+    if not model_path:
+        util.printD("model_path is empty")
+        return
+
+    if not os.path.isfile(model_path):
+        util.printD("model_path is not a file: "+model_path)
+        return
+
+    base, ext = os.path.splitext(model_path)
+    first_preview = base+".png"
+    sec_preview = base+".preview.png"
+    info_file = base + suffix + model.info_ext
+
+    # check preview image
+    if not os.path.isfile(sec_preview):
+        # need to download preview image
+        util.printD("Checking preview image for model: " + model_path)
+        # load model_info file
+        if os.path.isfile(info_file):
+            model_info = model.load_model_info(info_file)
+            if not model_info:
+                util.printD("Model Info is empty")
+                return
+
+            if "images" in model_info.keys():
+                if model_info["images"]:
+                    for img_dict in model_info["images"]:
+                        if "nsfw" in img_dict.keys():
+                            if img_dict["nsfw"]:
+                                util.printD("This image is NSFW")
+                                if skip_nsfw_preview:
+                                    util.printD("Skip NSFW image")
+                                    continue
+                        
+                        if "url" in img_dict.keys():
+                            img_url = img_dict["url"]
+                            if max_size_preview:
+                                # use max width
+                                if "width" in img_dict.keys():
+                                    if img_dict["width"]:
+                                        img_url = get_full_size_image_url(img_url, img_dict["width"])
+
+                            util.download_file(img_url, sec_preview)
+                            # we only need 1 preview image
+                            break
+
+
+
+# search local model by version id in 1 folder, no subfolder
+# return - model_info
+def search_local_model_info_by_version_id(folder:str, version_id:int) -> dict:
+    util.printD("Searching local model by version id")
+    util.printD("folder: " + folder)
+    util.printD("version_id: " + str(version_id))
+
+    if not folder:
+        util.printD("folder is none")
+        return
+
+    if not os.path.isdir(folder):
+        util.printD("folder is not a dir")
+        return
+    
+    if not version_id:
+        util.printD("version_id is none")
+        return
+    
+    # search civitai model info file
+    for filename in os.listdir(folder):
+        # check ext
+        base, ext = os.path.splitext(filename)
+        if ext == model.info_ext:
+            # find info file
+            if len(base) < 9:
+                # not a civitai info file
+                continue
+
+            if base[-8:] == suffix:
+                # find a civitai info file
+                path = os.path.join(folder, filename)
+                model_info = model.load_model_info(path)
+                if not model_info:
+                    continue
+
+                if "id" not in model_info.keys():
+                    continue
+
+                id = model_info["id"]
+                if not id:
+                    continue
+
+                # util.printD(f"Compare version id, src: {id}, target:{version_id}")
+                if str(id) == str(version_id):
+                    # find the one
+                    return model_info
+                    
+
+    return
+
+
+
+
+
+# check new version for a model by model path
+# return (model_path, model_id, model_name, new_verion_id, new_version_name, description, download_url, img_url)
+def check_model_new_version_by_path(model_path:str, delay:float=1) -> tuple:
+    if not model_path:
+        util.printD("model_path is empty")
+        return
+
+    if not os.path.isfile(model_path):
+        util.printD("model_path is not a file: "+model_path)
+        return
+    
+    # get model info file name
+    base, ext = os.path.splitext(model_path)
+    info_file = base + suffix + model.info_ext
+    
+    if not os.path.isfile(info_file):
+        return
+    
+    # get model info
+    model_info_file = model.load_model_info(info_file)
+    if not model_info_file:
+        return
+
+    if "id" not in model_info_file.keys():
+        return
+    
+    local_version_id = model_info_file["id"]
+    if not local_version_id:
+        return
+
+    if "modelId" not in model_info_file.keys():
+        return
+    
+    model_id = model_info_file["modelId"]
+    if not model_id:
+        return
+    
+    # get model info by id from civitai
+    model_info = get_model_info_by_id(model_id)
+    # delay before next request, to prevent to be treat as DDoS 
+    util.printD(f"delay:{delay} second")
+    time.sleep(delay)
+
+    if not model_info:
+        return
+    
+    if "modelVersions" not in model_info.keys():
+        return
+    
+    modelVersions = model_info["modelVersions"]
+    if not modelVersions:
+        return
+    
+    if not len(modelVersions):
+        return
+    
+    current_version = modelVersions[0]
+    if not current_version:
+        return
+    
+    if "id" not in current_version.keys():
+        return
+    
+    current_version_id = current_version["id"]
+    if not current_version_id:
+        return
+
+    util.printD(f"Compare version id, local: {local_version_id}, remote: {current_version_id} ")
+    if current_version_id == local_version_id:
+        return
+
+    model_name = ""
+    if "name" in model_info.keys():
+        model_name = model_info["name"]
+    
+    if not model_name:
+        model_name = ""
+
+
+    new_version_name = ""
+    if "name" in current_version.keys():
+        new_version_name = current_version["name"]
+    
+    if not new_version_name:
+        new_version_name = ""
+
+    description = ""
+    if "description" in current_version.keys():
+        description = current_version["description"]
+    
+    if not description:
+        description = ""
+
+    downloadUrl = ""
+    if "downloadUrl" in current_version.keys():
+        downloadUrl = current_version["downloadUrl"]
+    
+    if not downloadUrl:
+        downloadUrl = ""
+
+    # get 1 preview image
+    img_url = ""
+    if "images" in current_version.keys():
+        if current_version["images"]:
+            if current_version["images"][0]:
+                if "url" in current_version["images"][0].keys():
+                    img_url = current_version["images"][0]["url"]
+                    if not img_url:
+                        img_url = ""
+
+
+    
+    return (model_path, model_id, model_name, current_version_id, new_version_name, description, downloadUrl, img_url)
+
+
+
+
+# check model's new version
+# parameter: delay - float, how many seconds to delay between each request to civitai
+# return: new_versions - a list for all new versions, each one is (model_path, model_id, model_name, new_verion_id, new_version_name, description, download_url, img_url)
+def check_models_new_version_by_model_types(model_types:list, delay:float=1) -> list:
+    util.printD("Checking models' new version")
+
+    if not model_types:
+        return []
+
+    # check model types, which cloud be a string as 1 type
+    mts = []
+    if type(model_types) == str:
+        mts.append(model_types)
+    elif type(model_types) == list:
+        mts = model_types
+    else:
+        util.printD("Unknow model types:")
+        util.printD(model_types)
+        return []
+
+    # output is a markdown document string to show a list of new versions on UI
+    output = ""
+    # new version list
+    new_versions = []
+
+    # walk all models
+    for model_type, model_folder in model.folders.items():
+        if model_type not in mts:
+            continue
+
+        util.printD("Scanning path: " + model_folder)
+        for root, dirs, files in os.walk(model_folder, followlinks=True):
+            for filename in files:
+                # check ext
+                item = os.path.join(root, filename)
+                base, ext = os.path.splitext(item)
+                if ext in model.exts:
+                    # find a model
+                    r = check_model_new_version_by_path(item, delay)
+
+                    if not r:
+                        continue
+
+                    model_path, model_id, model_name, current_version_id, new_version_name, description, downloadUrl, img_url = r
+                    # check exist
+                    if not current_version_id:
+                        continue
+
+                    # check this version id in list
+                    is_already_in_list = False
+                    for new_version in new_versions:
+                        if current_version_id == new_version[3]:
+                            # already in list
+                            is_already_in_list = True
+                            break
+
+                    if is_already_in_list:
+                        util.printD("New version is already in list")
+                        continue
+
+                    # search this new version id to check if this model is already downloaded
+                    target_model_info = search_local_model_info_by_version_id(root, current_version_id)
+                    if target_model_info:
+                        util.printD("New version is already existed")
+                        continue
+
+                    # add to list
+                    new_versions.append(r)
+
+
+
+
+    return new_versions
+
+
+

scripts/ch_lib/downloader.py

@@ -0,0 +1,115 @@
+# -*- coding: UTF-8 -*-
+import sys
+import requests
+import os
+from . import util
+
+
+dl_ext = ".downloading"
+
+# disable ssl warning info
+requests.packages.urllib3.disable_warnings()
+
+# output is downloaded file path
+def dl(url, folder, filename, filepath):
+    util.printD("Start downloading from: " + url)
+    # get file_path
+    file_path = ""
+    if filepath:
+        file_path = filepath
+    else:
+        # if file_path is not in parameter, then folder must be in parameter
+        if not folder:
+            util.printD("folder is none")
+            return
+        
+        if not os.path.isdir(folder):
+            util.printD("folder does not exist: "+folder)
+            return
+        
+        if filename:
+            file_path = os.path.join(folder, filename)
+
+    # first request for header
+    rh = requests.get(url, stream=True, verify=False, headers=util.def_headers, proxies=util.proxies)
+    # get file size
+    total_size = 0
+    total_size = int(rh.headers['Content-Length'])
+    util.printD(f"File size: {total_size}")
+
+    # if file_path is empty, need to get file name from download url's header
+    if not file_path:
+        filename = ""
+        if "Content-Disposition" in rh.headers.keys():
+            cd = rh.headers["Content-Disposition"]
+            # Extract the filename from the header
+            # content of a CD: "attachment;filename=FileName.txt"
+            # in case "" is in CD filename's start and end, need to strip them out
+            filename = cd.split("=")[1].strip('"')
+            if not filename:
+                util.printD("Fail to get file name from Content-Disposition: " + cd)
+                return
+            
+        if not filename:
+            util.printD("Can not get file name from download url's header")
+            return
+        
+        # with folder and filename, now we have the full file path
+        file_path = os.path.join(folder, filename)
+
+
+    util.printD("Target file path: " + file_path)
+    base, ext = os.path.splitext(file_path)
+
+    # check if file is already exist
+    count = 2
+    new_base = base
+    while os.path.isfile(file_path):
+        util.printD("Target file already exist.")
+        # re-name
+        new_base = base + "_" + str(count)
+        file_path = new_base + ext
+        count += 1
+
+    # use a temp file for downloading
+    dl_file_path = new_base+dl_ext
+
+
+    util.printD(f"Downloading to temp file: {dl_file_path}")
+
+    # check if downloading file is exsited
+    downloaded_size = 0
+    if os.path.exists(dl_file_path):
+        downloaded_size = os.path.getsize(dl_file_path)
+
+    util.printD(f"Downloaded size: {downloaded_size}")
+
+    # create header range
+    headers = {'Range': 'bytes=%d-' % downloaded_size}
+    headers['User-Agent'] = util.def_headers['User-Agent']
+
+    # download with header
+    r = requests.get(url, stream=True, verify=False, headers=headers, proxies=util.proxies)
+
+    # write to file
+    with open(dl_file_path, "ab") as f:
+        for chunk in r.iter_content(chunk_size=1024):
+            if chunk:
+                downloaded_size += len(chunk)
+                f.write(chunk)
+                # force to write to disk
+                f.flush()
+
+                # progress
+                progress = int(50 * downloaded_size / total_size)
+                sys.stdout.reconfigure(encoding='utf-8')
+                sys.stdout.write("\r[%s%s] %d%%" % ('-' * progress, ' ' * (50 - progress), 100 * downloaded_size / total_size))
+                sys.stdout.flush()
+
+    print()
+
+    # rename file
+    os.rename(dl_file_path, file_path)
+    util.printD(f"File Downloaded to: {file_path}")
+    return file_path
+

scripts/ch_lib/js_action_civitai.py

@@ -0,0 +1,256 @@
+# -*- coding: UTF-8 -*-
+# handle msg between js and python side
+import os
+import json
+import requests
+import webbrowser
+from . import util
+from . import model
+from . import civitai
+from . import msg_handler
+from . import downloader
+
+
+
+# get civitai's model url and open it in browser
+# parameter: model_type, search_term
+# output: python msg - will be sent to hidden textbox then picked by js side
+def open_model_url(msg, open_url_with_js):
+    util.printD("Start open_model_url")
+
+    output = ""
+    result = msg_handler.parse_js_msg(msg)
+    if not result:
+        util.printD("Parsing js ms failed")
+        return
+    
+    model_type = result["model_type"]
+    search_term = result["search_term"]
+
+    model_info = civitai.load_model_info_by_search_term(model_type, search_term)
+    if not model_info:
+        util.printD(f"Failed to get model info for {model_type} {search_term}")
+        return ""
+
+    if "modelId" not in model_info.keys():
+        util.printD(f"Failed to get model id from info file for {model_type} {search_term}")
+        return ""
+
+    model_id = model_info["modelId"]
+    if not model_id:
+        util.printD(f"model id from info file of {model_type} {search_term} is None")
+        return ""
+
+    url = civitai.url_dict["modelPage"]+str(model_id)
+
+
+    # msg content for js
+    content = {
+        "url":""
+    }
+
+    if not open_url_with_js:
+        util.printD("Open Url: " + url)
+        # open url
+        webbrowser.open_new_tab(url)
+    else:
+        util.printD("Send Url to js")
+        content["url"] = url
+        output = msg_handler.build_py_msg("open_url", content)
+
+    util.printD("End open_model_url")
+    return output
+
+
+
+# add trigger words to prompt
+# parameter: model_type, search_term, prompt
+# return: [new_prompt, new_prompt] - new prompt with trigger words, return twice for txt2img and img2img
+def add_trigger_words(msg):
+    util.printD("Start add_trigger_words")
+
+    result = msg_handler.parse_js_msg(msg)
+    if not result:
+        util.printD("Parsing js ms failed")
+        return
+    
+    model_type = result["model_type"]
+    search_term = result["search_term"]
+    prompt = result["prompt"]
+
+
+    model_info = civitai.load_model_info_by_search_term(model_type, search_term)
+    if not model_info:
+        util.printD(f"Failed to get model info for {model_type} {search_term}")
+        return [prompt, prompt]
+    
+    if "trainedWords" not in model_info.keys():
+        util.printD(f"Failed to get trainedWords from info file for {model_type} {search_term}")
+        return [prompt, prompt]
+    
+    trainedWords = model_info["trainedWords"]
+    if not trainedWords:
+        util.printD(f"No trainedWords from info file for {model_type} {search_term}")
+        return [prompt, prompt]
+    
+    if len(trainedWords) == 0:
+        util.printD(f"trainedWords from info file for {model_type} {search_term} is empty")
+        return [prompt, prompt]
+    
+    # get ful trigger words
+    trigger_words = ""
+    for word in trainedWords:
+        trigger_words = trigger_words + word + ", "
+
+    new_prompt = prompt + " " + trigger_words
+    util.printD("trigger_words: " + trigger_words)
+    util.printD("prompt: " + prompt)
+    util.printD("new_prompt: " + new_prompt)
+
+    util.printD("End add_trigger_words")
+
+    # add to prompt
+    return [new_prompt, new_prompt]
+
+
+
+# use preview image's prompt as prompt
+# parameter: model_type, model_name, prompt, neg_prompt
+# return: [new_prompt, new_neg_prompt, new_prompt, new_neg_prompt,] - return twice for txt2img and img2img
+def use_preview_image_prompt(msg):
+    util.printD("Start use_preview_image_prompt")
+
+    result = msg_handler.parse_js_msg(msg)
+    if not result:
+        util.printD("Parsing js ms failed")
+        return
+    
+    model_type = result["model_type"]
+    search_term = result["search_term"]
+    prompt = result["prompt"]
+    neg_prompt = result["neg_prompt"]
+
+
+    model_info = civitai.load_model_info_by_search_term(model_type, search_term)
+    if not model_info:
+        util.printD(f"Failed to get model info for {model_type} {search_term}")
+        return [prompt, neg_prompt, prompt, neg_prompt]
+    
+    if "images" not in model_info.keys():
+        util.printD(f"Failed to get images from info file for {model_type} {search_term}")
+        return [prompt, neg_prompt, prompt, neg_prompt]
+    
+    images = model_info["images"]
+    if not images:
+        util.printD(f"No images from info file for {model_type} {search_term}")
+        return [prompt, neg_prompt, prompt, neg_prompt]
+    
+    if len(images) == 0:
+        util.printD(f"images from info file for {model_type} {search_term} is empty")
+        return [prompt, neg_prompt, prompt, neg_prompt]
+    
+    # get prompt from preview images' meta data
+    preview_prompt = ""
+    preview_neg_prompt = ""
+    for img in images:
+        if "meta" in img.keys():
+            if img["meta"]:
+                if "prompt" in img["meta"].keys():
+                    if img["meta"]["prompt"]:
+                        preview_prompt = img["meta"]["prompt"]
+                
+                if "negativePrompt" in img["meta"].keys():
+                    if img["meta"]["negativePrompt"]:
+                        preview_neg_prompt = img["meta"]["negativePrompt"]
+
+                # we only need 1 prompt
+                if preview_prompt:
+                    break
+            
+    if not preview_prompt:
+        util.printD(f"There is no prompt of {model_type} {search_term} in its preview image")
+        return [prompt, neg_prompt, prompt, neg_prompt]
+    
+    util.printD("End use_preview_image_prompt")
+    
+    return [preview_prompt, preview_neg_prompt, preview_prompt, preview_neg_prompt]
+
+
+# download model's new verson by model path, version id and download url
+# output is a md log
+def dl_model_new_version(msg, max_size_preview, skip_nsfw_preview):
+    util.printD("Start dl_model_new_version")
+
+    output = ""
+
+    result = msg_handler.parse_js_msg(msg)
+    if not result:
+        output = "Parsing js ms failed"
+        util.printD(output)
+        return output
+    
+    model_path = result["model_path"]
+    version_id = result["version_id"]
+    download_url = result["download_url"]
+
+    util.printD("model_path: " + model_path)
+    util.printD("version_id: " + str(version_id))
+    util.printD("download_url: " + download_url)
+
+    # check data
+    if not model_path:
+        output = "model_path is empty"
+        util.printD(output)
+        return output
+
+    if not version_id:
+        output = "version_id is empty"
+        util.printD(output)
+        return output
+    
+    if not download_url:
+        output = "download_url is empty"
+        util.printD(output)
+        return output
+
+    if not os.path.isfile(model_path):
+        output = "model_path is not a file: "+ model_path
+        util.printD(output)
+        return output
+
+    # get model folder from model path
+    model_folder = os.path.dirname(model_path)
+
+    # no need to check when downloading new version, since checking new version is already checked
+    # check if this model is already existed
+    # r = civitai.search_local_model_info_by_version_id(model_folder, version_id)
+    # if r:
+    #     output = "This model version is already existed"
+    #     util.printD(output)
+    #     return output
+
+    # download file
+    new_model_path = downloader.dl(download_url, model_folder, None, None)
+    if not new_model_path:
+        output = "Download failed, check console log for detail. Download url: " + download_url
+        util.printD(output)
+        return output
+
+    # get version info
+    version_info = civitai.get_version_info_by_version_id(version_id)
+    if not version_info:
+        output = "Model downloaded, but failed to get version info, check console log for detail. Model saved to: " + new_model_path
+        util.printD(output)
+        return output
+
+    # now write version info to file
+    base, ext = os.path.splitext(new_model_path)
+    info_file = base + civitai.suffix + model.info_ext
+    model.write_model_info(info_file, version_info)
+
+    # then, get preview image
+    civitai.get_preview_image_by_model_path(new_model_path, max_size_preview, skip_nsfw_preview)
+    
+    output = "Done. Model downloaded to: " + new_model_path
+    util.printD(output)
+    return output

scripts/ch_lib/model.py

@@ -0,0 +1,120 @@
+# -*- coding: UTF-8 -*-
+# handle msg between js and python side
+import os
+import json
+from . import util
+from modules import shared
+
+
+# this is the default root path
+root_path = os.getcwd()
+
+# if command line arguement is used to change model folder, 
+# then model folder is in absolute path, not based on this root path anymore.
+# so to make extension work with those absolute model folder paths, model folder also need to be in absolute path
+folders = {
+    "ti": os.path.join(root_path, "embeddings"),
+    "hyper": os.path.join(root_path, "models", "hypernetworks"),
+    "ckp": os.path.join(root_path, "models", "Stable-diffusion"),
+    "lora": os.path.join(root_path, "models", "Lora"),
+}
+
+exts = (".bin", ".pt", ".safetensors", ".ckpt")
+info_ext = ".info"
+vae_suffix = ".vae"
+
+
+# get cusomter model path
+def get_custom_model_folder():
+    util.printD("Get Custom Model Folder")
+
+    global folders
+
+    if shared.cmd_opts.embeddings_dir and os.path.isdir(shared.cmd_opts.embeddings_dir):
+        folders["ti"] = shared.cmd_opts.embeddings_dir
+
+    if shared.cmd_opts.hypernetwork_dir and os.path.isdir(shared.cmd_opts.hypernetwork_dir):
+        folders["hyper"] = shared.cmd_opts.hypernetwork_dir
+
+    if shared.cmd_opts.ckpt_dir and os.path.isdir(shared.cmd_opts.ckpt_dir):
+        folders["ckp"] = shared.cmd_opts.ckpt_dir
+
+    if shared.cmd_opts.lora_dir and os.path.isdir(shared.cmd_opts.lora_dir):
+        folders["lora"] = shared.cmd_opts.lora_dir
+
+
+
+
+
+# write model info to file
+def write_model_info(path, model_info):
+    util.printD("Write model info to file: " + path)
+    with open(os.path.realpath(path), 'w') as f:
+        f.write(json.dumps(model_info, indent=4))
+
+
+def load_model_info(path):
+    # util.printD("Load model info from file: " + path)
+    model_info = None
+    with open(os.path.realpath(path), 'r') as f:
+        try:
+            model_info = json.load(f)
+        except Exception as e:
+            util.printD("Selected file is not json: " + path)
+            util.printD(e)
+            return
+        
+    return model_info
+
+
+# get model file names by model type
+# parameter: model_type - string
+# return: model name list
+def get_model_names_by_type(model_type:str) -> list:
+    
+    model_folder = folders[model_type]
+
+    # get information from filter
+    # only get those model names don't have a civitai model info file
+    model_names = []
+    for root, dirs, files in os.walk(model_folder, followlinks=True):
+        for filename in files:
+            item = os.path.join(root, filename)
+            # check extension
+            base, ext = os.path.splitext(item)
+            if ext in exts:
+                # find a model
+                model_names.append(filename)
+
+
+    return model_names
+
+
+# return 2 values: (model_root, model_path)
+def get_model_path_by_type_and_name(model_type:str, model_name:str) -> str:
+    util.printD("Run get_model_path_by_type_and_name")
+    if model_type not in folders.keys():
+        util.printD("unknown model_type: " + model_type)
+        return
+    
+    if not model_name:
+        util.printD("model name can not be empty")
+        return
+    
+    folder = folders[model_type]
+
+    # model could be in subfolder, need to walk.
+    model_root = ""
+    model_path = ""
+    for root, dirs, files in os.walk(folder, followlinks=True):
+        for filename in files:
+            if filename == model_name:
+                # find model
+                model_root = root
+                model_path = os.path.join(root, filename)
+                return (model_root, model_path)
+
+    return
+
+
+

scripts/ch_lib/model_action_civitai.py

@@ -0,0 +1,511 @@
+# -*- coding: UTF-8 -*-
+# handle msg between js and python side
+import os
+import time
+from . import util
+from . import model
+from . import civitai
+from . import downloader
+
+
+# scan model to generate SHA256, then use this SHA256 to get model info from civitai
+# return output msg
+def scan_model(scan_model_types, max_size_preview, skip_nsfw_preview):
+    util.printD("Start scan_model")
+    output = ""
+
+    # check model types
+    if not scan_model_types:
+        output = "Model Types is None, can not scan."
+        util.printD(output)
+        return output
+    
+    model_types = []
+    # check type if it is a string
+    if type(scan_model_types) == str:
+        model_types.append(scan_model_types)
+    else:
+        model_types = scan_model_types
+    
+    model_count = 0
+    image_count = 0
+    # scan_log = ""
+    for model_type, model_folder in model.folders.items():
+        if model_type not in model_types:
+            continue
+
+        util.printD("Scanning path: " + model_folder)
+        for root, dirs, files in os.walk(model_folder, followlinks=True):
+            for filename in files:
+                # check ext
+                item = os.path.join(root, filename)
+                base, ext = os.path.splitext(item)
+                if ext in model.exts:
+                    # ignore vae file
+                    if len(base) > 4:
+                        if base[-4:] == model.vae_suffix:
+                            # find .vae
+                            util.printD("This is a vae file: " + filename)
+                            continue
+
+                    # find a model
+                    # get info file
+                    info_file = base + civitai.suffix + model.info_ext
+                    # check info file
+                    if not os.path.isfile(info_file):
+                        util.printD("Creating model info for: " + filename)
+                        # get model's sha256
+                        hash = util.gen_file_sha256(item)
+
+                        if not hash:
+                            output = "failed generating SHA256 for model:" + filename
+                            util.printD(output)
+                            return output
+                        
+                        # use this sha256 to get model info from civitai
+                        model_info = civitai.get_model_info_by_hash(hash)
+                        # delay 1 second for ti
+                        if model_type == "ti":
+                            util.printD("Delay 1 second for TI")
+                            time.sleep(1)
+
+                        if model_info is None:
+                            output = "Connect to Civitai API service failed. Wait a while and try again"
+                            util.printD(output)
+                            return output+", check console log for detail"
+
+                        # write model info to file
+                        model.write_model_info(info_file, model_info)
+
+                    # set model_count
+                    model_count = model_count+1
+
+                    # check preview image
+                    civitai.get_preview_image_by_model_path(item, max_size_preview, skip_nsfw_preview)
+                    image_count = image_count+1
+
+
+    # scan_log = "Done"
+
+    output = f"Done. Scanned {model_count} models, checked {image_count} images"
+
+    util.printD(output)
+
+    return output
+
+
+
+# Get model info by model type, name and url
+# output is log info to display on markdown component
+def get_model_info_by_input(model_type, model_name, model_url_or_id, max_size_preview, skip_nsfw_preview):
+    output = ""
+    # parse model id
+    model_id = civitai.get_model_id_from_url(model_url_or_id)
+    if not model_id:
+        output = "failed to parse model id from url: " + model_url_or_id
+        util.printD(output)
+        return output
+
+    # get model file path
+    # model could be in subfolder
+    result = model.get_model_path_by_type_and_name(model_type, model_name)
+    if not result:
+        output = "failed to get model file path"
+        util.printD(output)
+        return output
+    
+    model_root, model_path = result
+    if not model_path:
+        output = "model path is empty"
+        util.printD(output)
+        return output
+    
+    # get info file path
+    base, ext = os.path.splitext(model_path)
+    info_file = base + civitai.suffix + model.info_ext
+
+    # get model info    
+    #we call it model_info, but in civitai, it is actually version info
+    model_info = civitai.get_version_info_by_model_id(model_id)
+
+    if not model_info:
+        output = "failed to get model info from url: " + model_url_or_id
+        util.printD(output)
+        return output
+    
+    # write model info to file
+    model.write_model_info(info_file, model_info)
+
+    util.printD("Saved model info to: "+ info_file)
+
+    # check preview image
+    civitai.get_preview_image_by_model_path(model_path, max_size_preview, skip_nsfw_preview)
+
+    output = "Model Info saved to: " + info_file
+    return output
+
+
+
+# check models' new version and output to UI as markdown doc
+def check_models_new_version_to_md(model_types:list) -> str:
+    new_versions = civitai.check_models_new_version_by_model_types(model_types, 1)
+
+    count = 0
+    output = ""
+    if not new_versions:
+        output = "No model has new version"
+    else:
+        output = "Found new version for following models:  <br>"
+        for new_version in new_versions:
+            count = count+1
+            model_path, model_id, model_name, new_verion_id, new_version_name, description, download_url, img_url = new_version
+            # in md, each part is something like this:
+            # [model_name](model_url)
+            # [version_name](download_url)
+            # version description
+            url = civitai.url_dict["modelPage"]+str(model_id)
+
+            part = f'<div style="font-size:20px;margin:6px 0px;"><b>Model: <a href="{url}" target="_blank"><u>{model_name}</u></a></b></div>'
+            part = part + f'<div style="font-size:16px">File: {model_path}</div>'
+            if download_url:
+                # replace "\" to "/" in model_path for windows
+                model_path = model_path.replace('\\', '\\\\')
+                part = part + f'<div style="font-size:16px;margin:6px 0px;">New Version: <u><a href="{download_url}" target="_blank" style="margin:0px 10px;">{new_version_name}</a></u>'
+                # add js function to download new version into SD webui by python
+                part = part + "    "
+                # in embed HTML, onclick= will also follow a ", never a ', so have to write it as following
+                part = part + f"<u><a href='#' style='margin:0px 10px;' onclick=\"ch_dl_model_new_version(event, '{model_path}', '{new_verion_id}', '{download_url}')\">[Download into SD]</a></u>"
+                
+            else:
+                part = part + f'<div style="font-size:16px;margin:6px 0px;">New Version: {new_version_name}'
+            part = part + '</div>'
+
+            # description
+            if description:
+                part = part + '<blockquote style="font-size:16px;margin:6px 0px;">'+ description + '</blockquote><br>'
+
+            # preview image            
+            if img_url:
+                part = part + f"<img src='{img_url}'><br>"
+                
+
+            output = output + part
+
+    util.printD(f"Done. Find {count} models have new version. Check UI for detail.")
+
+    return output
+
+
+# get model info by url
+def get_model_info_by_url(model_url_or_id:str) -> tuple:
+    util.printD("Getting model info by: " + model_url_or_id)
+
+    # parse model id
+    model_id = civitai.get_model_id_from_url(model_url_or_id)
+    if not model_id:
+        util.printD("failed to parse model id from url or id")
+        return    
+
+    model_info = civitai.get_model_info_by_id(model_id)
+    if model_info is None:
+        util.printD("Connect to Civitai API service failed. Wait a while and try again")
+        return
+    
+    if not model_info:
+        util.printD("failed to get model info from url or id")
+        return
+    
+    # parse model type, model name, subfolder, version from this model info
+    # get model type
+    if "type" not in model_info.keys():
+        util.printD("model type is not in model_info")
+        return
+    
+    civitai_model_type = model_info["type"]
+    if civitai_model_type not in civitai.model_type_dict.keys():
+        util.printD("This model type is not supported:"+civitai_model_type)
+        return
+    
+    model_type = civitai.model_type_dict[civitai_model_type]
+
+    # get model type
+    if "name" not in model_info.keys():
+        util.printD("model name is not in model_info")
+        return
+
+    model_name = model_info["name"]
+    if not model_name:
+        util.printD("model name is Empty")
+        model_name = ""
+
+    # get version list
+    if "modelVersions" not in model_info.keys():
+        util.printD("modelVersions is not in model_info")
+        return
+    
+    modelVersions = model_info["modelVersions"]
+    if not modelVersions:
+        util.printD("modelVersions is Empty")
+        return
+    
+    version_strs = []
+    for version in modelVersions:
+        # version name can not be used as id
+        # version id is not readable
+        # so , we use name_id as version string
+        version_str = version["name"]+"_"+str(version["id"])
+        version_strs.append(version_str)
+
+    # get folder by model type
+    folder = model.folders[model_type]
+    # get subfolders
+    subfolders = util.get_subfolders(folder)
+    if not subfolders:
+        subfolders = []
+
+    # add default root folder
+    subfolders.append("/")
+
+    util.printD("Get following info for downloading:")
+    util.printD(f"model_name:{model_name}")
+    util.printD(f"model_type:{model_type}")
+    util.printD(f"subfolders:{subfolders}")
+    util.printD(f"version_strs:{version_strs}")
+
+    return (model_info, model_name, model_type, subfolders, version_strs)
+
+# get version info by version string
+def get_ver_info_by_ver_str(version_str:str, model_info:dict) -> dict:
+    if not version_str:
+        util.printD("version_str is empty")
+        return
+    
+    if not model_info:
+        util.printD("model_info is None")
+        return
+    
+    # get version list
+    if "modelVersions" not in model_info.keys():
+        util.printD("modelVersions is not in model_info")
+        return
+
+    modelVersions = model_info["modelVersions"]
+    if not modelVersions:
+        util.printD("modelVersions is Empty")
+        return
+    
+    # find version by version_str
+    version = None
+    for ver in modelVersions:
+        # version name can not be used as id
+        # version id is not readable
+        # so , we use name_id as version string
+        ver_str = ver["name"]+"_"+str(ver["id"])
+        if ver_str == version_str:
+            # find version
+            version = ver
+
+    if not version:
+        util.printD("can not find version by version string: " + version_str)
+        return
+    
+    # get version id
+    if "id" not in version.keys():
+        util.printD("this version has no id")
+        return
+    
+    return version
+
+
+# get download url from model info by version string
+# return - (version_id, download_url)
+def get_id_and_dl_url_by_version_str(version_str:str, model_info:dict) -> tuple:
+    if not version_str:
+        util.printD("version_str is empty")
+        return
+    
+    if not model_info:
+        util.printD("model_info is None")
+        return
+    
+    # get version list
+    if "modelVersions" not in model_info.keys():
+        util.printD("modelVersions is not in model_info")
+        return
+
+    modelVersions = model_info["modelVersions"]
+    if not modelVersions:
+        util.printD("modelVersions is Empty")
+        return
+    
+    # find version by version_str
+    version = None
+    for ver in modelVersions:
+        # version name can not be used as id
+        # version id is not readable
+        # so , we use name_id as version string
+        ver_str = ver["name"]+"_"+str(ver["id"])
+        if ver_str == version_str:
+            # find version
+            version = ver
+
+    if not version:
+        util.printD("can not find version by version string: " + version_str)
+        return
+    
+    # get version id
+    if "id" not in version.keys():
+        util.printD("this version has no id")
+        return
+    
+    version_id = version["id"]
+    if not version_id:
+        util.printD("version id is Empty")
+        return
+
+    # get download url
+    if "downloadUrl" not in version.keys():
+        util.printD("downloadUrl is not in this version")
+        return
+    
+    downloadUrl = version["downloadUrl"]
+    if not downloadUrl:
+        util.printD("downloadUrl is Empty")
+        return
+    
+    util.printD("Get Download Url: " + downloadUrl)
+    
+    return (version_id, downloadUrl)
+    
+
+# download model from civitai by input
+# output to markdown log
+def dl_model_by_input(model_info:dict, model_type:str, subfolder_str:str, version_str:str, dl_all_bool:bool, max_size_preview:bool, skip_nsfw_preview:bool) -> str:
+
+    output = ""
+
+    if not model_info:
+        output = "model_info is None"
+        util.printD(output)
+        return output
+    
+    if not model_type:
+        output = "model_type is None"
+        util.printD(output)
+        return output
+    
+    if not subfolder_str:
+        output = "subfolder string is None"
+        util.printD(output)
+        return output
+    
+    if not version_str:
+        output = "version_str is None"
+        util.printD(output)
+        return output
+    
+    # get model root folder
+    if model_type not in model.folders.keys():
+        output = "Unknow model type: "+model_type
+        util.printD(output)
+        return output
+    
+    model_root_folder = model.folders[model_type]
+
+
+    # get subfolder
+    subfolder = ""
+    if subfolder_str == "/" or subfolder_str == "\\":
+        subfolder = ""
+    elif subfolder_str[:1] == "/" or subfolder_str[:1] == "\\":
+        subfolder = subfolder_str[1:]
+    else:
+        subfolder = subfolder_str
+
+    # get model folder for downloading
+    model_folder = os.path.join(model_root_folder, subfolder)
+    if not os.path.isdir(model_folder):
+        output = "Model folder is not a dir: "+ model_folder
+        util.printD(output)
+        return output
+    
+    # get version info
+    ver_info = get_ver_info_by_ver_str(version_str, model_info)
+    if not ver_info:
+        output = "Fail to get version info, check console log for detail"
+        util.printD(output)
+        return output
+    
+    version_id = ver_info["id"]
+
+
+    if dl_all_bool:
+        # get all download url from files info
+        # some model versions have multiple files
+        download_urls = []
+        if "files" in ver_info.keys():
+            for file_info in ver_info["files"]:
+                if "downloadUrl" in file_info.keys():
+                    download_urls.append(file_info["downloadUrl"])
+
+        if not len(download_urls):
+            if "downloadUrl" in ver_info.keys():
+                download_urls.append(ver_info["downloadUrl"])
+
+
+        # check if this model is already existed
+        r = civitai.search_local_model_info_by_version_id(model_folder, version_id)
+        if r:
+            output = "This model version is already existed"
+            util.printD(output)
+            return output
+        
+        # download
+        filepath = ""
+        for url in download_urls:
+            model_filepath = downloader.dl(url, model_folder, None, None)
+            if not model_filepath:
+                output = "Downloading failed, check console log for detail"
+                util.printD(output)
+                return output
+            
+            if url == ver_info["downloadUrl"]:
+                filepath = model_filepath
+    else:
+        # only download one file
+        # get download url
+        url = ver_info["downloadUrl"]
+        if not url:
+            output = "Fail to get download url, check console log for detail"
+            util.printD(output)
+            return output
+        
+        # download
+        filepath = downloader.dl(url, model_folder, None, None)
+        if not filepath:
+            output = "Downloading failed, check console log for detail"
+            util.printD(output)
+            return output
+
+
+    if not filepath:
+        filepath = model_filepath
+    
+    # get version info
+    version_info = civitai.get_version_info_by_version_id(version_id)
+    if not version_info:
+        output = "Model downloaded, but failed to get version info, check console log for detail. Model saved to: " + filepath
+        util.printD(output)
+        return output
+
+    # write version info to file
+    base, ext = os.path.splitext(filepath)
+    info_file = base + civitai.suffix + model.info_ext
+    model.write_model_info(info_file, version_info)
+
+    # then, get preview image
+    civitai.get_preview_image_by_model_path(filepath, max_size_preview, skip_nsfw_preview)
+    
+    output = "Done. Model downloaded to: " + filepath
+    util.printD(output)
+    return output

scripts/ch_lib/msg_handler.py

@@ -0,0 +1,64 @@
+# -*- coding: UTF-8 -*-
+# handle msg between js and python side
+import json
+from . import util
+
+# action list
+js_actions = ("open_url", "add_trigger_words", "use_preview_prompt", "dl_model_new_version")
+py_actions = ("open_url")
+
+
+# handle request from javascript
+# parameter: msg - msg from js as string in a hidden textbox
+# return: dict for result
+def parse_js_msg(msg):
+    util.printD("Start parse js msg")
+    msg_dict = json.loads(msg)
+
+    # in case client side run JSON.stringify twice
+    if (type(msg_dict) == str):
+        msg_dict = json.loads(msg_dict)
+
+    if "action" not in msg_dict.keys():
+        util.printD("Can not find action from js request")
+        return
+
+    action = msg_dict["action"]
+    if not action:
+        util.printD("Action from js request is None")
+        return
+
+    if action not in js_actions:
+        util.printD("Unknow action: " + action)
+        return
+
+    util.printD("End parse js msg")
+
+    return msg_dict
+
+
+# build python side msg for sending to js
+# parameter: content dict
+# return: msg as string, to fill into a hidden textbox
+def build_py_msg(action:str, content:dict):
+    util.printD("Start build_msg")
+    if not content:
+        util.printD("Content is None")
+        return
+    
+    if not action:
+        util.printD("Action is None")
+        return
+
+    if action not in py_actions:
+        util.printD("Unknow action: " + action)
+        return
+
+    msg = {
+        "action" : action,
+        "content": content
+    }
+
+
+    util.printD("End build_msg")
+    return json.dumps(msg)

scripts/ch_lib/setting.py

@@ -0,0 +1,113 @@
+# -*- coding: UTF-8 -*-
+# collecting settings to here
+import json
+import os
+import modules.scripts as scripts
+from . import util
+
+
+name = "setting.json"
+path = os.path.join(scripts.basedir(), name)
+
+data = {
+    "model":{
+        "max_size_preview": True,
+        "skip_nsfw_preview": False
+    },
+    "general":{
+        "open_url_with_js": True,
+        "always_display": False,
+        "show_btn_on_thumb": True,
+        "proxy": "",
+    },
+    "tool":{
+    }
+}
+
+
+
+# save setting
+# return output msg for log
+def save():
+    print("Saving setting to: " + path)
+
+    json_data = json.dumps(data, indent=4)
+
+    output = ""
+
+    #write to file
+    try:
+        with open(path, 'w') as f:
+            f.write(json_data)
+    except Exception as e:
+        util.printD("Error when writing file:"+path)
+        output = str(e)
+        util.printD(str(e))
+        return output
+
+    output = "Setting saved to: " + path
+    util.printD(output)
+
+    return output
+
+
+# load setting to global data
+def load():
+    # load data into globel data
+    global data
+
+    util.printD("Load setting from: " + path)
+
+    if not os.path.isfile(path):
+        util.printD("No setting file, use default")
+        return
+
+    json_data = None
+    with open(path, 'r') as f:
+        json_data = json.load(f)
+
+    # check error
+    if not json_data:
+        util.printD("load setting file failed")
+        return
+
+    data = json_data
+
+    # check for new key
+    if "always_display" not in data["general"].keys():
+        data["general"]["always_display"] = False
+
+    if "show_btn_on_thumb" not in data["general"].keys():
+        data["general"]["show_btn_on_thumb"] = True
+
+    if "proxy" not in data["general"].keys():
+        data["general"]["proxy"] = ""
+
+
+    return
+
+# save setting from parameter
+def save_from_input(max_size_preview, skip_nsfw_preview, open_url_with_js, always_display, show_btn_on_thumb, proxy):
+    global data
+    data = {
+        "model":{
+            "max_size_preview": max_size_preview,
+            "skip_nsfw_preview": skip_nsfw_preview
+        },
+        "general":{
+            "open_url_with_js": open_url_with_js,
+            "always_display": always_display,
+            "show_btn_on_thumb": show_btn_on_thumb,
+            "proxy": proxy,
+        },
+        "tool":{
+        }
+    }
+
+    output = save()
+
+    if not output:
+        output = ""
+
+    return output
+

scripts/ch_lib/util.py

@@ -0,0 +1,105 @@
+# -*- coding: UTF-8 -*-
+import os
+import io
+import hashlib
+import requests
+import shutil
+
+
+version = "1.6.4"
+
+def_headers = {'User-Agent': 'Mozilla/5.0 (iPad; CPU OS 12_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148'}
+
+
+proxies = None
+
+
+# print for debugging
+def printD(msg):
+    print(f"Civitai Helper: {msg}")
+
+
+def read_chunks(file, size=io.DEFAULT_BUFFER_SIZE):
+    """Yield pieces of data from a file-like object until EOF."""
+    while True:
+        chunk = file.read(size)
+        if not chunk:
+            break
+        yield chunk
+
+# Now, hashing use the same way as pip's source code.
+def gen_file_sha256(filname):
+    printD("Use Memory Optimized SHA256")
+    blocksize=1 << 20
+    h = hashlib.sha256()
+    length = 0
+    with open(os.path.realpath(filname), 'rb') as f:
+        for block in read_chunks(f, size=blocksize):
+            length += len(block)
+            h.update(block)
+
+    hash_value =  h.hexdigest()
+    printD("sha256: " + hash_value)
+    printD("length: " + str(length))
+    return hash_value
+
+
+
+# get preview image
+def download_file(url, path):
+    printD("Downloading file from: " + url)
+    # get file
+    r = requests.get(url, stream=True, headers=def_headers, proxies=proxies)
+    if not r.ok:
+        printD("Get error code: " + str(r.status_code))
+        printD(r.text)
+        return
+    
+    # write to file
+    with open(os.path.realpath(path), 'wb') as f:
+        r.raw.decode_content = True
+        shutil.copyfileobj(r.raw, f)
+
+    printD("File downloaded to: " + path)
+
+# get subfolder list
+def get_subfolders(folder:str) -> list:
+    printD("Get subfolder for: " + folder)
+    if not folder:
+        printD("folder can not be None")
+        return
+    
+    if not os.path.isdir(folder):
+        printD("path is not a folder")
+        return
+    
+    prefix_len = len(folder)
+    subfolders = []
+    for root, dirs, files in os.walk(folder, followlinks=True):
+        for dir in dirs:
+            full_dir_path = os.path.join(root, dir)
+            # get subfolder path from it
+            subfolder = full_dir_path[prefix_len:]
+            subfolders.append(subfolder)
+
+    return subfolders
+
+
+# get relative path
+def get_relative_path(item_path:str, parent_path:str) -> str:
+    # printD("item_path:"+item_path)
+    # printD("parent_path:"+parent_path)
+    # item path must start with parent_path
+    if not item_path:
+        return ""
+    if not parent_path:
+        return ""
+    if not item_path.startswith(parent_path):
+        return item_path
+
+    relative = item_path[len(parent_path):]
+    if relative[:1] == "/" or relative[:1] == "\\":
+        relative = relative[1:]
+
+    # printD("relative:"+relative)
+    return relative

scripts/civitai_helper.py

@@ -0,0 +1,218 @@
+# -*- coding: UTF-8 -*-
+# This extension can help you manage your models from civitai. It can download preview, add trigger words, open model page and use the prompt from preview image
+# repo: https://github.com/butaixianran/
+
+
+
+import modules.scripts as scripts
+import gradio as gr
+import os
+import webbrowser
+import requests
+import random
+import hashlib
+import json
+import shutil
+import re
+import modules
+from modules import script_callbacks
+from modules import shared
+from scripts.ch_lib import model
+from scripts.ch_lib import js_action_civitai
+from scripts.ch_lib import model_action_civitai
+from scripts.ch_lib import setting
+from scripts.ch_lib import civitai
+from scripts.ch_lib import util
+
+
+# init
+
+# root path
+root_path = os.getcwd()
+
+# extension path
+extension_path = scripts.basedir()
+
+model.get_custom_model_folder()
+setting.load()
+
+# set proxy
+if setting.data["general"]["proxy"]:
+    util.printD("Set Proxy: "+setting.data["general"]["proxy"])
+    util.proxies = {
+        "http": setting.data["general"]["proxy"],
+        "https": setting.data["general"]["proxy"],
+    }
+
+
+
+
+def on_ui_tabs():
+    # init
+    # init_py_msg = {
+    #     # relative extension path
+    #     "extension_path": util.get_relative_path(extension_path, root_path),
+    # }
+    # init_py_msg_str = json.dumps(init_py_msg)
+
+
+    # get prompt textarea
+    # check modules/ui.py, search for txt2img_paste_fields
+    # Negative prompt is the second element
+    txt2img_prompt = modules.ui.txt2img_paste_fields[0][0]
+    txt2img_neg_prompt = modules.ui.txt2img_paste_fields[1][0]
+    img2img_prompt = modules.ui.img2img_paste_fields[0][0]
+    img2img_neg_prompt = modules.ui.img2img_paste_fields[1][0]
+
+    # ====Event's function====
+    def get_model_names_by_input(model_type, empty_info_only):
+        names = civitai.get_model_names_by_input(model_type, empty_info_only)
+        return model_name_drop.update(choices=names)
+
+
+    def get_model_info_by_url(url):
+        r = model_action_civitai.get_model_info_by_url(url)
+
+        model_info = {}
+        model_name = ""
+        model_type = ""
+        subfolders = []
+        version_strs = []
+        if r:
+            model_info, model_name, model_type, subfolders, version_strs = r
+
+        return [model_info, model_name, model_type, dl_subfolder_drop.update(choices=subfolders), dl_version_drop.update(choices=version_strs)]
+
+    # ====UI====
+    with gr.Blocks(analytics_enabled=False) as civitai_helper:
+    # with gr.Blocks(css=".block.padded {padding: 10px !important}") as civitai_helper:
+
+        # init
+        max_size_preview = setting.data["model"]["max_size_preview"]
+        skip_nsfw_preview = setting.data["model"]["skip_nsfw_preview"]
+        open_url_with_js = setting.data["general"]["open_url_with_js"]
+        always_display = setting.data["general"]["always_display"]
+        show_btn_on_thumb = setting.data["general"]["show_btn_on_thumb"]
+        proxy = setting.data["general"]["proxy"]
+
+        model_types = list(model.folders.keys())
+        no_info_model_names = civitai.get_model_names_by_input("ckp", False)
+
+        # session data
+        dl_model_info = gr.State({})
+
+
+
+        with gr.Box(elem_classes="ch_box"):
+            with gr.Column():
+                gr.Markdown("### Scan Models for Civitai")
+                with gr.Row():
+                    max_size_preview_ckb = gr.Checkbox(label="Download Max Size Preview", value=max_size_preview, elem_id="ch_max_size_preview_ckb")
+                    skip_nsfw_preview_ckb = gr.Checkbox(label="Skip NSFW Preview Images", value=skip_nsfw_preview, elem_id="ch_skip_nsfw_preview_ckb")
+                    scan_model_types_ckbg = gr.CheckboxGroup(choices=model_types, label="Model Types", value=model_types)
+
+                # with gr.Row():
+                scan_model_civitai_btn = gr.Button(value="Scan", variant="primary", elem_id="ch_scan_model_civitai_btn")
+                # with gr.Row():
+                scan_model_log_md = gr.Markdown(value="Scanning takes time, just wait. Check console log for detail", elem_id="ch_scan_model_log_md")
+
+        
+        with gr.Box(elem_classes="ch_box"):
+            with gr.Column():
+                gr.Markdown("### Get Model Info from Civitai by URL")
+                gr.Markdown("Use this when scanning can not find a local model on civitai")
+                with gr.Row():
+                    model_type_drop = gr.Dropdown(choices=model_types, label="Model Type", value="ckp", multiselect=False)
+                    empty_info_only_ckb = gr.Checkbox(label="Only Show Models have no Info", value=False, elem_id="ch_empty_info_only_ckb", elem_classes="ch_vpadding")
+                    model_name_drop = gr.Dropdown(choices=no_info_model_names, label="Model", value="ckp", multiselect=False)
+
+                model_url_or_id_txtbox = gr.Textbox(label="Civitai URL", lines=1, value="")
+                get_civitai_model_info_by_id_btn = gr.Button(value="Get Model Info from Civitai", variant="primary")
+                get_model_by_id_log_md = gr.Markdown("")
+
+        with gr.Box(elem_classes="ch_box"):
+            with gr.Column():
+                gr.Markdown("### Download Model")
+                with gr.Row():
+                    dl_model_url_or_id_txtbox = gr.Textbox(label="Civitai URL", lines=1, value="")
+                    dl_model_info_btn = gr.Button(value="1. Get Model Info by Civitai Url", variant="primary")
+
+                gr.Markdown(value="2. Pick Subfolder and Model Version")
+                with gr.Row():
+                    dl_model_name_txtbox = gr.Textbox(label="Model Name", interactive=False, lines=1, value="")
+                    dl_model_type_txtbox = gr.Textbox(label="Model Type", interactive=False, lines=1, value="")
+                    dl_subfolder_drop = gr.Dropdown(choices=[], label="Sub-folder", value="", interactive=True, multiselect=False)
+                    dl_version_drop = gr.Dropdown(choices=[], label="Model Version", value="", interactive=True, multiselect=False)
+                    dl_all_ckb = gr.Checkbox(label="Download All files", value=False, elem_id="ch_dl_all_ckb", elem_classes="ch_vpadding")
+                
+                dl_civitai_model_by_id_btn = gr.Button(value="3. Download Model", variant="primary")
+                dl_log_md = gr.Markdown(value="Check Console log for Downloading Status")
+
+        with gr.Box(elem_classes="ch_box"):
+            with gr.Column():
+                gr.Markdown("### Check models' new version")
+                with gr.Row():
+                    model_types_ckbg = gr.CheckboxGroup(choices=model_types, label="Model Types", value=["lora"])
+                    check_models_new_version_btn = gr.Button(value="Check New Version from Civitai", variant="primary")
+
+                check_models_new_version_log_md = gr.HTML("It takes time, just wait. Check console log for detail")
+
+        with gr.Box(elem_classes="ch_box"):
+            with gr.Column():
+                gr.Markdown("### Other Setting")
+                with gr.Row():
+                    open_url_with_js_ckb = gr.Checkbox(label="Open Url At Client Side", value=open_url_with_js, elem_id="ch_open_url_with_js_ckb")
+                    always_display_ckb = gr.Checkbox(label="Always Display Buttons", value=always_display, elem_id="ch_always_display_ckb")
+                    show_btn_on_thumb_ckb = gr.Checkbox(label="Show Button On Thumb Mode", value=show_btn_on_thumb, elem_id="ch_show_btn_on_thumb_ckb")
+
+                proxy_txtbox = gr.Textbox(label="Proxy", interactive=True, lines=1, value=proxy, info="format: http://127.0.0.1:port")
+
+                save_setting_btn = gr.Button(value="Save Setting")
+                general_log_md = gr.Markdown(value="")
+
+
+        # ====Footer====
+        gr.Markdown(f"<center>version:{util.version}</center>")
+
+        # ====hidden component for js, not in any tab====
+        js_msg_txtbox = gr.Textbox(label="Request Msg From Js", visible=False, lines=1, value="", elem_id="ch_js_msg_txtbox")
+        py_msg_txtbox = gr.Textbox(label="Response Msg From Python", visible=False, lines=1, value="", elem_id="ch_py_msg_txtbox")
+
+        js_open_url_btn = gr.Button(value="Open Model Url", visible=False, elem_id="ch_js_open_url_btn")
+        js_add_trigger_words_btn = gr.Button(value="Add Trigger Words", visible=False, elem_id="ch_js_add_trigger_words_btn")
+        js_use_preview_prompt_btn = gr.Button(value="Use Prompt from Preview Image", visible=False, elem_id="ch_js_use_preview_prompt_btn")
+        js_dl_model_new_version_btn = gr.Button(value="Download Model's new version", visible=False, elem_id="ch_js_dl_model_new_version_btn")
+
+        # ====events====
+        # Scan Models for Civitai
+        scan_model_civitai_btn.click(model_action_civitai.scan_model, inputs=[scan_model_types_ckbg, max_size_preview_ckb, skip_nsfw_preview_ckb], outputs=scan_model_log_md)
+
+        # Get Civitai Model Info by Model Page URL
+        model_type_drop.change(get_model_names_by_input, inputs=[model_type_drop, empty_info_only_ckb], outputs=model_name_drop)
+        empty_info_only_ckb.change(get_model_names_by_input, inputs=[model_type_drop, empty_info_only_ckb], outputs=model_name_drop)
+
+        get_civitai_model_info_by_id_btn.click(model_action_civitai.get_model_info_by_input, inputs=[model_type_drop, model_name_drop, model_url_or_id_txtbox, max_size_preview_ckb, skip_nsfw_preview_ckb], outputs=get_model_by_id_log_md)
+
+        # Download Model
+        dl_model_info_btn.click(get_model_info_by_url, inputs=dl_model_url_or_id_txtbox, outputs=[dl_model_info, dl_model_name_txtbox, dl_model_type_txtbox, dl_subfolder_drop, dl_version_drop])
+        dl_civitai_model_by_id_btn.click(model_action_civitai.dl_model_by_input, inputs=[dl_model_info, dl_model_type_txtbox, dl_subfolder_drop, dl_version_drop, dl_all_ckb, max_size_preview_ckb, skip_nsfw_preview_ckb], outputs=dl_log_md)
+
+        # Check models' new version
+        check_models_new_version_btn.click(model_action_civitai.check_models_new_version_to_md, inputs=model_types_ckbg, outputs=check_models_new_version_log_md)
+
+        # Other Setting
+        save_setting_btn.click(setting.save_from_input, inputs=[max_size_preview_ckb, skip_nsfw_preview_ckb, open_url_with_js_ckb, always_display_ckb, show_btn_on_thumb_ckb, proxy_txtbox], outputs=general_log_md)
+
+        # js action
+        js_open_url_btn.click(js_action_civitai.open_model_url, inputs=[js_msg_txtbox, open_url_with_js_ckb], outputs=py_msg_txtbox)
+        js_add_trigger_words_btn.click(js_action_civitai.add_trigger_words, inputs=[js_msg_txtbox], outputs=[txt2img_prompt, img2img_prompt])
+        js_use_preview_prompt_btn.click(js_action_civitai.use_preview_image_prompt, inputs=[js_msg_txtbox], outputs=[txt2img_prompt, txt2img_neg_prompt, img2img_prompt, img2img_neg_prompt])
+        js_dl_model_new_version_btn.click(js_action_civitai.dl_model_new_version, inputs=[js_msg_txtbox, max_size_preview_ckb, skip_nsfw_preview_ckb], outputs=dl_log_md)
+
+    # the third parameter is the element id on html, with a "tab_" as prefix
+    return (civitai_helper , "Civitai Helper", "civitai_helper"),
+
+script_callbacks.on_ui_tabs(on_ui_tabs)
+
+
+

style.css

@@ -0,0 +1,18 @@
+blockquote ul {
+    list-style:disc;
+    margin:4px 40px;
+}
+
+blockquote ol {
+    list-style:decimal;
+    margin:4px 40px;
+}
+
+.block.padded.ch_box {
+    padding: 10px !important;
+}
+
+.block.padded.ch_vpadding {
+    padding: 10px 0 !important;
+}
+