Temporary DB Upload. The tags are currently all "unknown" categories

.gitattributes

@@ -53,3 +53,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
 *.jpeg filter=lfs diff=lfs merge=lfs -text
 *.webp filter=lfs diff=lfs merge=lfs -text
+gelbooru2024-02.db filter=lfs diff=lfs merge=lfs -text

create_db.py

@@ -0,0 +1,208 @@
+from db import *
+import json
+import os
+from tqdm import tqdm
+from functools import cache
+import tarfile
+
+Tag = None
+Post = None
+PostTagRelation = None
+LocalPost = None
+tags = None
+get_tag_by_id = None
+db = None
+
+
+@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.
+    """
+    if isinstance(file_path, str) and os.path.exists(file_path):
+        with open(file_path, "r") as f:
+            for line in f:
+                yield json.loads(line)
+    elif hasattr(file_path, "read"):
+        for line in file_path:
+            yield json.loads(line)
+    else:
+        raise ValueError("file_path must be a string or a file-like object")
+JSONL_RATING_CONVERSION = {
+    "q": "questionable",
+    "s": "sensitive",
+    "e": "explicit",
+    "g": "general",
+    "safe" : "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
+# 'id', 'created_at', 'score', 'width', 'height', 'md5', 'directory', 'image', 'rating', 'source', 'change', 'owner', 'creator_id', 'parent_id', 'sample', 'preview_height', 'preview_width', 'tags', 'title', 'has_notes', 'has_comments', 'file_url', 'preview_url', 'sample_url', 'sample_height', 'sample_width', 'status', 'post_locked', 'has_children'
+
+def get_conversion_key(data, key: str):
+    """
+    Get the conversion key for a key.
+    """
+    access_key = DANBOORU_KEYS_TO_GELBOORU.get(key, key)
+    if access_key == "rating":
+        return JSONL_RATING_CONVERSION.get(data.get(access_key, None), data.get(access_key, None))
+    return data.get(access_key, None)
+
+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.get("tag_string_general", ""), "general")]
+    all_tags += [create_tags(json_data.get("tag_string_artist", ""), "artist")]
+    all_tags += [create_tags(json_data.get("tag_string_character", ""), "character")]
+    all_tags += [create_tags(json_data.get("tag_string_copyright", ""), "copyright")]
+    all_tags += [create_tags(json_data.get("tag_string_meta", ""), "meta")]
+    # tags -> unknown
+    all_tags += [create_tags(json_data.get("tags", ""), "unknown")]
+    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(
+        **{key: get_conversion_key(json_data, key) for key in[
+            "id", "created_at", "uploader_id", "source", "md5", "parent_id", "has_children", "is_deleted", "is_banned", "pixiv_id", "has_active_children", "bit_flags", "has_large", "has_visible_children", "image_width", "image_height", "file_size", "file_ext", "rating", "score", "up_score", "down_score", "fav_count", "file_url", "large_file_url", "preview_file_url"
+        ]
+        }
+    )
+    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 create_db_from_tarfile(tarfile_path: str, policy="ignore", read_method="r:gz"):
+    """
+    Create a database from a tarfile of jsonl files.
+        Policy can be 'ignore' or 'replace'
+    """
+    global db
+    assert db is not None, "Database is not loaded"
+    all_jsonl_files = []
+    with tarfile.open(tarfile_path, read_method) as tar:
+        for tarinfo in tar:
+            if tarinfo.isfile() and tarinfo.name.endswith(".jsonl"):
+                all_jsonl_files.append(tarinfo)
+        with db.atomic():
+            for tarinfo in tqdm(all_jsonl_files):
+                with tar.extractfile(tarinfo) as f:
+                    for json_data in iterate_jsonl(f):
+                        create_post(json_data, policy)
+                        #print(f"Created post {json_data['id']}")
+
+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_dict = load_db("gelbooru2024-02.db")
+    Post, Tag, PostTagRelation = db_dict["Post"], db_dict["Tag"], db_dict["PostTagRelation"]
+    db = db_dict["db"]
+    LocalPost = db_dict["LocalPost"]
+    
+    #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
+    for i in range(2,10):
+        create_db_from_tarfile(rf"G:\gelboorupost\{i}M.tar.gz")

db.py

@@ -0,0 +1,228 @@
+from peewee import *
+import tarfile
+import jsonlines
+import json
+import sqlite3
+import os
+
+GELBOORU_KEYS_TO_DANBOORU = {
+    "creator_id": "uploader_id",
+    "width": "image_width",
+    "has_children": "has_active_children",
+    "file_url": "large_file_url",
+    "preview_url": "file_url",
+    "sample_url": "preview_file_url",
+    "width": "image_width",
+    "height": "image_height",
+}
+
+DANBOORU_KEYS_TO_GELBOORU = {value: key for key, value in GELBOORU_KEYS_TO_DANBOORU.items()}
+
+
+def load_db(db_file: str):
+    """
+    Return a dictionary with the database objects.
+    This allows multiple databases to be loaded in one program.
+    """
+    tag_cache_map = {}
+    class BaseModel(Model):
+        class Meta:
+            database = SqliteDatabase(db_file)
+
+
+    class EnumField(IntegerField):
+        def __init__(self, enum_list, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.enum_list = enum_list
+            self.enum_map = {value: index for index, value in enumerate(enum_list)}
+
+        def db_value(self, value):
+            if isinstance(value, str):
+                return self.enum_map[value]
+            assert isinstance(value, int)
+            return value
+
+        def python_value(self, value):
+            if value is not None:
+                return self.enum_list[value]
+
+
+    # 'id', 'created_at', 'score', 'width', 'height', 'md5', 'directory', 'image', 'rating', 'source', 'change', 'owner', 'creator_id', 'parent_id', 'sample', 'preview_height', 'preview_width', 'tags', 'title', 'has_notes', 'has_comments', 'file_url', 'preview_url', 'sample_url', 'sample_height', 'sample_width', 'status', 'post_locked', 'has_children'
+
+    class Post(BaseModel):
+        # "id", "created_at", "uploader_id", "source", "md5", "parent_id", "has_children", "is_deleted", "is_banned", "pixiv_id", "has_active_children", "bit_flags", "has_large", "has_visible_children", "image_width", "image_height", "file_size", "file_ext", "rating", "score", "up_score", "down_score", "fav_count", "file_url", "large_file_url", "preview_file_url"
+        id = IntegerField(primary_key=True)
+        created_at = CharField()
+        uploader_id = IntegerField() # creator_id in gelbooru
+        source = CharField()
+        md5 = CharField(null=True)
+        parent_id = IntegerField(null=True)
+        has_children = BooleanField()
+        is_deleted = BooleanField(default=False, null=True)
+        is_banned = BooleanField(default=False, null=True)
+        pixiv_id = IntegerField(null=True)
+        has_active_children = BooleanField(default=False, null=True) # has_children in gelbooru
+        bit_flags = IntegerField(default=0, null=True)
+        has_large = BooleanField(default=False, null=True)
+        has_visible_children = BooleanField(default=False, null=True)
+
+        image_width = IntegerField() # width in gelbooru
+        image_height = IntegerField() # height in gelbooru
+        file_size = IntegerField(default=0, null=True)
+        file_ext = CharField(default="jpg", null=True)
+
+        rating = EnumField(["general", "sensitive", "questionable", "explicit"])
+        score = IntegerField()
+        up_score = IntegerField(default=0, null=True)
+        down_score = IntegerField(default=0, null=True)
+        fav_count = IntegerField(default=0, null=True)
+
+        file_url = CharField(null=True) # preview_url in gelbooru
+        large_file_url = CharField(null=True) # sample_url in gelbooru
+        preview_file_url = CharField(null=True) # file_url in gelbooru
+
+        _tags: ManyToManyField = None # set by tags.bind
+        _tags_cache = None
+
+        @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):
+            if self._tags_cache is None:
+                self._tags_cache = list(self._tags)
+            return self._tags_cache
+
+        @property
+        def tag_list_general(self):
+            return [tag for tag in self.tag_list if tag.type == "general"]
+
+        @property
+        def tag_list_artist(self):
+            return [tag for tag in self.tag_list if tag.type == "artist"]
+
+        @property
+        def tag_list_character(self):
+            return [tag for tag in self.tag_list if tag.type == "character"]
+
+        @property
+        def tag_list_copyright(self):
+            return [tag for tag in self.tag_list if tag.type == "copyright"]
+
+        @property
+        def tag_list_meta(self):
+            return [tag for tag in self.tag_list if tag.type == "meta"]
+
+        @property
+        def tag_list_unknown(self):
+            return [tag for tag in self.tag_list if tag.type == "unknown"]
+
+
+    class Tag(BaseModel):
+        id = IntegerField(primary_key=True)
+        name = CharField(unique=True)
+        type = EnumField(["general", "artist", "character", "copyright", "meta", "unknown"]) # unknown is for gelbooru unbased tags, should be fixed in future
+        popularity = IntegerField()
+        _posts: ManyToManyField = None
+        _posts_cache = None
+
+        @property
+        def posts(self):
+            if self._posts_cache is None:
+                self._posts_cache = list(self._posts)
+            return self._posts_cache
+
+        def __str__(self):
+            return f"<Tag '{self.name}'>"
+
+        def __repr__(self):
+            return f"<Tag|#{self.id}|{self.name}|{self.type[:2]}>"
+
+    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 PostTagRelation(BaseModel):
+        post = ForeignKeyField(Post, backref="post_tags")
+        tag = ForeignKeyField(Tag, backref="tag_posts")
+
+    class LocalPost(BaseModel):
+        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}>"
+
+    tags = ManyToManyField(Tag, backref="_posts", through_model=PostTagRelation)
+    tags.bind(Post, "_tags", set_attribute=True)
+    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()
+    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 {
+        "Post": Post,
+        "Tag": Tag,
+        "PostTagRelation": PostTagRelation,
+        "LocalPost": LocalPost,
+        "tags": tags,
+        "get_tag_by_id": get_tag_by_id,
+        "db": db,
+    }
+
+if __name__ == "__main__":
+    test_tarfile = r'G:\gelboorupost\0M.tar.gz'
+    # get first jsonl file from tarfile
+    with tarfile.open(test_tarfile, 'r:gz') as tar:
+        while True:
+            member = tar.next()
+            if member is None:
+                break
+            if member.isfile():
+                if member.name.endswith('.jsonl'):
+                    f = tar.extractfile(member)
+                    json_data = jsonlines.Reader(f)
+                    for line in json_data:
+                        # get keys
+                        print(line.keys())
+                        print(line.values())
+                        break
+                    break
+            else:
+                print('not a file')

gelbooru2024-02.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4f2ae54e29175dfc64d9cfa277498c1a79430311b12403b4d28998573cabdd65
+size 14257557504