File size: 8,643 Bytes
740a4e4 8b8fe59 740a4e4 8b8fe59 740a4e4 8b8fe59 740a4e4 8b8fe59 740a4e4 8b8fe59 740a4e4 8b8fe59 740a4e4 8b8fe59 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 |
from db import *
import json
import os
from tqdm import tqdm
from functools import cache
from datetime import datetime
@cache
def get_or_create_tag(tag_name: str, tag_type: str, optional_tag_id: int = None):
"""
Get a tag if it exists, otherwise create it.
"""
tag = Tag.get_or_none(Tag.name == tag_name)
if tag is None:
if optional_tag_id is not None:
assert isinstance(optional_tag_id, int), f"optional_tag_id must be an integer, not {type(optional_tag_id)}"
tag = Tag.create(id=optional_tag_id, name=tag_name, type=tag_type, popularity=0)
else:
tag = Tag.create(name=tag_name, type=tag_type, popularity=0)
return tag
def create_tag_or_use(tag_name: str, tag_type: str, optional_tag_id: int = None):
"""
Create a tag if it does not exist, otherwise return the existing tag.
This function also increments the popularity of the tag.
"""
tag = get_or_create_tag(tag_name, tag_type, optional_tag_id)
# we don't have to check tag type since its unique
tag.popularity = 1
return tag
def iterate_jsonl(file_path: str):
"""
Iterate through a jsonl file and yield each line as a dictionary.
"""
with open(file_path, "r") as f:
for line in f:
yield json.loads(line)
JSONL_RATING_CONVERSION = {
"q": "questionable",
"s": "sensitive",
"e": "explicit",
"g": "general"
}
def create_tags(tag_string:str, tag_type:str):
"""
Create tags from a tag string.
"""
for tag in tag_string.split(" "):
if not tag or tag.isspace():
continue
tag = create_tag_or_use(tag, tag_type)
yield tag
def create_post(json_data, policy="ignore"):
"""
Create a post from a json dictionary.
Policy can be 'ignore' or 'replace'
Note that file_url, large_file_url, and preview_file_url are optional.
"""
assert "id" in json_data, "id is not in json_data"
post_id = json_data["id"]
#"updated_at": "2024-05-19T01:30:25.096-04:00"
all_tags = []
all_tags += [create_tags(json_data["tag_string_general"], "general")]
all_tags += [create_tags(json_data["tag_string_artist"], "artist")]
all_tags += [create_tags(json_data["tag_string_character"], "character")]
all_tags += [create_tags(json_data["tag_string_copyright"], "copyright")]
all_tags += [create_tags(json_data["tag_string_meta"], "meta")]
if Post.get_or_none(Post.id == post_id) is not None:
if policy == "ignore":
print(f"Post {post_id} already exists")
return
elif policy == "replace":
# get existing post, compare updated_at, delete if necessary
current_post = Post.get_by_id(post_id)
if current_post.updated_at == json_data["updated_at"]:
print(f"Post {post_id} already exists")
return
# compare the date
datetime_current = datetime.fromisoformat(current_post.updated_at)
datetime_new = datetime.fromisoformat(json_data["updated_at"])
if datetime_new <= datetime_current:
print(f"Post {post_id} is older than the existing post")
return
print(f"Post {post_id} is being replaced, old updated_at: {current_post.updated_at}, new updated_at: {json_data['updated_at']}")
Post.delete_by_id(post_id)
else:
raise ValueError(f"Unknown policy {policy}, must be 'ignore' or 'replace'")
post = Post.create(id=post_id, created_at=json_data["created_at"],
uploader_id=json_data["uploader_id"],
source=json_data["source"], md5=json_data.get("md5", None),
parent_id=json_data["parent_id"], has_children=json_data["has_children"],
is_deleted=json_data["is_deleted"], is_banned=json_data["is_banned"],
pixiv_id=json_data["pixiv_id"], has_active_children=json_data["has_active_children"],
bit_flags=json_data["bit_flags"], has_large=json_data["has_large"],
has_visible_children=json_data["has_visible_children"], image_width=json_data["image_width"],
image_height=json_data["image_height"], file_size=json_data["file_size"],
file_ext=json_data["file_ext"], rating=JSONL_RATING_CONVERSION[json_data["rating"]], score=json_data["score"],
up_score=json_data["up_score"], down_score=json_data["down_score"], fav_count=json_data["fav_count"],
file_url=json_data.get("file_url", None), large_file_url=json_data.get("large_file_url", None),
preview_file_url=json_data.get("preview_file_url", None),
updated_at=json_data["updated_at"],
#tag_list=json_data["tag_string"]
)
for tags in all_tags:
for tag in tags:
PostTagRelation.create(post=post, tag=tag)
return post
def read_and_create_posts(file_path: str, policy="ignore"):
"""
Read a jsonl file and create the posts in the database.
Policy can be 'ignore' or 'replace'
"""
for json_data in iterate_jsonl(file_path):
create_post(json_data, policy)
#print(f"Created post {json_data['id']}")
def create_db_from_folder(folder_path: str, policy="ignore"):
"""
Create a database from a folder of jsonl files.
This recursively searches the folder for jsonl files.
Policy can be 'ignore' or 'replace'
"""
global db
assert db is not None, "Database is not loaded"
all_jsonl_files = []
for root, dirs, files in os.walk(folder_path):
for file in files:
if file.endswith(".jsonl"):
all_jsonl_files.append(os.path.join(root, file))
with db.atomic():
for file in tqdm(all_jsonl_files[::-1]):
read_and_create_posts(file, policy)
def sanity_check(order="random"):
"""
Print out a random post and its informations
"""
if order == "random":
random_post = Post.select().order_by(fn.Random()).limit(1).get()
else:
random_post = Post.select().limit(1).get()
print(f"Post id : {random_post.id}")
print(f"Post tags: {random_post.tag_list}, {len(random_post.tag_list)} tags, {random_post.tag_count} tags")
print(f"Post general tags: {random_post.tag_list_general}, {len(random_post.tag_list_general)} tags, {random_post.tag_count_general} tags")
print(f"Post artist tags: {random_post.tag_list_artist}, {len(random_post.tag_list_artist)} tags, {random_post.tag_count_artist} tags")
print(f"Post character tags: {random_post.tag_list_character}, {len(random_post.tag_list_character)} tags, {random_post.tag_count_character} tags")
print(f"Post copyright tags: {random_post.tag_list_copyright}, {len(random_post.tag_list_copyright)} tags, {random_post.tag_count_copyright} tags")
print(f"Post meta tags: {random_post.tag_list_meta}, {len(random_post.tag_list_meta)} tags, {random_post.tag_count_meta} tags")
print(f"Post rating: {random_post.rating}")
print(f"Post score: {random_post.score}")
print(f"Post fav_count: {random_post.fav_count}")
print(f"Post source: {random_post.source}")
print(f"Post created_at: {random_post.created_at}")
print(f"Post file_url: {random_post.file_url}")
print(f"Post large_file_url: {random_post.large_file_url}")
print(f"Post preview_file_url: {random_post.preview_file_url}")
print(f"Post image_width: {random_post.image_width}")
print(f"Post image_height: {random_post.image_height}")
print(f"Post file_size: {random_post.file_size}")
print(f"Post file_ext: {random_post.file_ext}")
print(f"Post uploader_id: {random_post.uploader_id}")
print(f"Post pixiv_id: {random_post.pixiv_id}")
print(f"Post has_children: {random_post.has_children}")
print(f"Post is_deleted: {random_post.is_deleted}")
print(f"Post is_banned: {random_post.is_banned}")
print(f"Post has_active_children: {random_post.has_active_children}")
print(f"Post has_large: {random_post.has_large}")
print(f"Post has_visible_children: {random_post.has_visible_children}")
print(f"Post bit_flags: {random_post.bit_flags}")
print(f"Post updated_at: {random_post.updated_at}")
if __name__ == "__main__":
db = load_db("danbooru2023.db")
#read_and_create_posts(r"C:\sqlite\0_99.jsonl")
sanity_check()
#create_db_from_folder(r'D:\danbooru\post_danboorus', 'replace') # if you have a folder of jsonl files
|