Fix DB and update until post id 7349999 (#3)

- Fix DB and update until post id 7349999 (ad69f1277fc07e9c310e75242ca60e11b870c421)


Co-authored-by: AngelBottomless@aria4th <AngelBottomless@users.noreply.huggingface.co>

create_db.py

@@ -0,0 +1,164 @@
+from db import *
+import json
+import os
+from tqdm import tqdm
+from functools import cache
+
+@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"]
+    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":
+            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),
+                        #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):
+            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}")
+
+if __name__ == "__main__":
+    db = load_db("danbooru2023.db")
+    #read_and_create_posts(r"C:\sqlite\0_99.jsonl")
+    #create_db_from_folder(r'D:\danbooru-0319') # if you have a folder of jsonl files

danbooru2023.db

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:82901925689e08817e369a8cc8e9934bfac828473fa319ac4fd5541c484cc718
-size 15443382272
+oid sha256:dc54df5f67ecf571263dae8d5513076b2ddde6178ff6e963cc41fd9a3df82baa
+size 18653368320

db.py

@@ -1,8 +1,8 @@
+import os
 import sqlite3
 
 from peewee import *
 
-
 class MemoryConnection(sqlite3.Connection):
     def __init__(self, dbname, *args, **kwargs):
         load_conn = sqlite3.connect(dbname)
@@ -34,16 +34,13 @@ class SqliteMemDatabase(SqliteDatabase):
         finally:
             save_conn.close()
 
-
 db: SqliteDatabase = None
 tag_cache_map = {}
 
-
-def get_tag_by_id(id):
-    if id not in tag_cache_map:
-        tag_cache_map[id] = Tag.get_by_id(id)
-    return tag_cache_map[id]
-
+def get_tag_by_id(tag_id):
+    if tag_id not in tag_cache_map:
+        tag_cache_map[tag_id] = Tag.get_by_id(tag_id)
+    return tag_cache_map[tag_id]
 
 class EnumField(IntegerField):
     def __init__(self, enum_list, *args, **kwargs):
@@ -85,11 +82,9 @@ class Tag(BaseModel):
         return f"<Tag '{self.name}'>"
 
     def __repr__(self):
-        from objprint import objstr
-
+        #from objprint import objstr
         return f"<Tag|#{self.id}|{self.name}|{self.type[:2]}>"
 
-
 class Post(BaseModel):
     id = IntegerField(primary_key=True)
     created_at = CharField()
@@ -117,20 +112,36 @@ class Post(BaseModel):
     down_score = IntegerField()
     fav_count = IntegerField()
 
-    file_url = CharField()
-    large_file_url = CharField()
-    preview_file_url = CharField()
+    file_url = CharField(null=True)
+    large_file_url = CharField(null=True)
+    preview_file_url = CharField(null=True)
 
-    _tags: ManyToManyField
+    _tags: ManyToManyField = None # set by tags.bind
     _tags_cache = None
-    _tag_list = TextField(column_name="tag_list")
 
-    tag_count = IntegerField()
-    tag_count_general = IntegerField()
-    tag_count_artist = IntegerField()
-    tag_count_character = IntegerField()
-    tag_count_copyright = IntegerField()
-    tag_count_meta = IntegerField()
+    @property
+    def tag_count(self):
+        return len(self.tag_list) if self.tag_list else 0
+
+    @property
+    def tag_count_general(self):
+        return len(self.tag_list_general) if self.tag_list else 0
+
+    @property
+    def tag_count_artist(self):
+        return len(self.tag_list_artist) if self.tag_list else 0
+
+    @property
+    def tag_count_character(self):
+        return len(self.tag_list_character) if self.tag_list else 0
+
+    @property
+    def tag_count_copyright(self):
+        return len(self.tag_list_copyright) if self.tag_list else 0
+
+    @property
+    def tag_count_meta(self):
+        return len(self.tag_list_meta) if self.tag_list else 0
 
     @property
     def tag_list(self):
@@ -158,6 +169,19 @@ class Post(BaseModel):
     def tag_list_meta(self):
         return [tag for tag in self.tag_list if tag.type == "meta"]
 
+# create table LocalPost Table that can contain "filepath", "latentpath"
+class LocalPost(BaseModel):
+    # Usage : LocalPost.create(filepath="path/to/file", latentpath="path/to/latent", post=post)
+    id = IntegerField(primary_key=True)
+    filepath = CharField(null=True)
+    latentpath = CharField(null=True)
+    post = ForeignKeyField(Post, backref="localpost")
+
+    def __str__(self):
+        return f"<LocalPost '{self.filepath}'>"
+
+    def __repr__(self):
+        return f"<LocalPost|#{self.id}|{self.filepath}|{self.latentpath}|{self.post}>"
 
 class PostTagRelation(BaseModel):
     post = ForeignKeyField(Post, backref="post_tags")
@@ -170,26 +194,47 @@ tags.bind(Post, "_tags", set_attribute=True)
 
 def load_db(db_file: str):
     global db
+    file_exists = os.path.exists(db_file)
     db = SqliteDatabase(db_file)
     Post._meta.database = db
     Tag._meta.database = db
     PostTagRelation._meta.database = db
+    LocalPost._meta.database = db
     db.connect()
-
-
-if __name__ == "__main__":
-    load_db("danbooru2023.db")
-    post = Post.get_by_id(1)
-    print(post.tag_count_general, len(post.tag_list_general), post.tag_list_general)
-    print(post.tag_count_artist, len(post.tag_list_artist), post.tag_list_artist)
+    print("Database connected.")
+    if not file_exists:
+        db.create_tables([Post, Tag, PostTagRelation])
+        db.create_tables([LocalPost])
+        db.commit()
+        print("Database initialized.")
+    assert db is not None, "Database is not loaded"
+    return db
+
+def print_post_info(post):
+    """
+    Debugging function to print out a post's tags
+    """
+    print(f"Post id : {post.id}")
+    print("General Tags: ", post.tag_count_general, len(post.tag_list_general), post.tag_list_general)
+    print("Artist Tags: ", post.tag_count_artist, len(post.tag_list_artist), post.tag_list_artist)
     print(
-        post.tag_count_character, len(post.tag_list_character), post.tag_list_character
+        "Character Tags: ", post.tag_count_character, len(post.tag_list_character), post.tag_list_character
     )
     print(
-        post.tag_count_copyright, len(post.tag_list_copyright), post.tag_list_copyright
+        "Copyright Tags: ", post.tag_count_copyright, len(post.tag_list_copyright), post.tag_list_copyright
     )
-    print(post.tag_count_meta, len(post.tag_list_meta), post.tag_list_meta)
+    print("Meta Tags: ", post.tag_count_meta, len(post.tag_list_meta), post.tag_list_meta)
+
 
-    tag = Tag.select().where(Tag.name == "umamusume").first()
-    print(tag)
-    print(len(tag.posts))
+if __name__ == "__main__":
+    db_existed = os.path.exists("danbooru2023.db")
+    db = load_db("danbooru2023.db")
+    if db_existed:
+        # run sanity check
+        post = Post.get_by_id(1)
+        print_post_info(post)
+        tag = Tag.select().where(Tag.name == "kousaka_kirino").get()
+        print(f"Tag {tag} has {len(tag.posts)} posts")
+        # get last post
+        post = Post.select().order_by(Post.id.desc()).limit(1).get()
+        print_post_info(post)