Maintenance codes

add_post.py

@@ -0,0 +1,128 @@
+import os
+import json
+import requests
+import glob
+from tqdm import tqdm
+from db import *
+
+def yield_posts(file_dir=r"G:\database\post", from_id=0, end_id=7110548):
+    """
+    Yields the posts
+    """
+    # using listdir instead of glob because glob is slow
+    files = []
+    # walk through all files
+    for root, dirs, filenames in os.walk(file_dir):
+        for filename in filenames:
+            if "_" not in filename:
+                continue
+            # 0_19.jsonl -> 0, 19
+            start_id, end_id = filename.split(".")[0].split("_")
+            start_id = int(start_id)
+            end_id = int(end_id)
+            if start_id > end_id:
+                continue
+            if end_id < from_id:
+                continue
+            files.append(os.path.join(root, filename))
+    print(f"Total {len(files)} files")
+    for file in files:
+        with open(file, 'r') as f:
+            yield from f.readlines()
+            
+def add_post_if_not_exist(post_string):
+    try:
+        post_data = json.loads(post_string)
+    except Exception as e:
+        print(f"Exception: {e} when loading {post_string}")
+        return
+    post_id = post_data['id']
+    if (post:=Post.get_or_none(Post.id == post_id)) is not None:
+        # check if it has valid tag list
+        if not post.tag_list:
+            # remove post
+            Post.delete_by_id(post_id)
+        else:
+            return
+    # prepare tags first
+    for keys in ["tag_string_general, tag_string_artist, tag_string_character, tag_string_meta", "tag_string", "tag_string_copyright"]:
+        if keys not in post_data:
+            continue
+        values = post_data[keys]
+        if not values:
+            continue
+        if not isinstance(values, list):
+            values = values.split(" ")
+        current_value = []
+        for value in values:
+            tag = Tag.get_or_none(name=value)
+            if tag is None:
+                tag = Tag.create(name=value, type=keys.split("_")[-1], popularity=0)
+            # assert unique, tag should not be iterable
+            assert not isinstance(tag, list), f"Error: {tag} is iterable"
+            current_value.append(tag.id)
+        post_data[keys.replace("tag_string", "tag_list")] = current_value
+        post_data[keys.replace("tag_string", "tag_count")] = len(current_value)
+    # add post
+    data = dict(
+        id=post_id,
+        created_at=post_data.get('created_at', None),
+        source=post_data.get('source', ""),
+        rating=post_data.get('rating', 'q'),
+        score=post_data.get('score', 0),
+        up_score=post_data.get('up_score', 0),
+        down_score=post_data.get('down_score', 0),
+        fav_count=post_data.get('fav_count', 0),
+        tag_list_general=post_data.get('tag_list_general', []),
+        tag_list_artist=post_data.get('tag_list_artist', []),
+        tag_list_character=post_data.get('tag_list_character', []),
+        tag_list_meta=post_data.get('tag_list_meta', []),
+        tag_list=post_data.get('tag_list', []),
+        tag_list_copyright=post_data.get('tag_list', []),
+        tag_count_general=post_data.get('tag_count_general', 0),
+        tag_count_artist=post_data.get('tag_count_artist', 0),
+        tag_count_character=post_data.get('tag_count_character', 0),
+        tag_count_meta=post_data.get('tag_count_meta', 0),
+        tag_count=post_data.get('tag_count', 0),
+        tag_count_copyright=post_data.get('tag_count', 0),
+        uploader_id=post_data.get('uploader_id', 0),
+        md5=post_data.get('md5', None),
+        parent_id=post_data.get('parent_id', None),
+        has_children=post_data.get('has_children', False),
+        is_deleted=post_data.get('is_deleted', False),
+        is_banned=post_data.get('is_banned', False),
+        pixiv_id=post_data.get('pixiv_id', None),
+        has_active_children=post_data.get('has_active_children', False),
+        bit_flags=post_data.get('bit_flags', 0),
+        has_large=post_data.get('has_large', False),
+        has_visible_children=post_data.get('has_visible_children', False),
+        image_width=post_data.get('image_width', 0),
+        image_height=post_data.get('image_height', 0),
+        file_size=post_data.get('file_size', 0),
+        file_ext=post_data.get('file_ext', "jpg"),
+        file_url=post_data.get('file_url', ""),
+        large_file_url=post_data.get('large_file_url', ""),
+        preview_file_url=post_data.get('preview_file_url', "")
+    )
+    # create from dict
+    Post.create(**data)
+    print(f"Added post {post_id}")
+
+def main():
+    last_post_id = Post.select().order_by(Post.id.desc()).get().id
+    print(f"Last post id: {last_post_id}")
+    with db.atomic():
+        pbar = tqdm(total=7110548 - last_post_id)
+        for post_string in yield_posts(from_id=last_post_id):
+            try:
+                add_post_if_not_exist(post_string)
+            except Exception as e:
+                if isinstance(e, KeyboardInterrupt):
+                    raise e
+                print(f"Exception: {e} when adding {post_string}")
+                raise e
+            pbar.update(1)
+    print("Done")
+
+if __name__ == "__main__":
+    main()

commit_difference.py

@@ -0,0 +1,133 @@
+"""
+Reads and commits differences from difference_cache.jsonl files to database
+Uses batch commit to speed up commit process
+"""
+
+import glob
+from random import choice
+from db import *
+import os
+import json
+from tqdm import tqdm
+
+def is_different(diff_0, diff_1):
+    if not diff_0 and not diff_1:
+        return False
+    return True
+    
+def get_differences(filepath):
+    """
+    Reads differences from difference_cache.jsonl
+    Returns list of differences
+    """
+    differences = {}
+    with open(filepath, 'r') as file:
+        for line in file:
+            try:
+                loaded_dict = json.loads(line)
+                if not loaded_dict['difference']:
+                    continue
+                if not is_different(loaded_dict['difference'][0], loaded_dict['difference'][1]):
+                    continue
+                differences[loaded_dict['id']] = loaded_dict['difference']
+            except:
+                pass
+    return differences
+
+def commit_differences(differences):
+    """
+    Commits differences to database
+    Returns number of differences committed
+    """
+    for ids in tqdm(differences):
+        if not is_different(differences[ids][0], differences[ids][1]):
+            continue
+        commit_difference(ids, differences[ids])
+def commit_difference(id, difference):
+    """
+    Commits difference to database
+    """
+    if difference:
+        post_by_id = Post.get_by_id(id)
+        new_dict, old_dict = difference
+        for keys in new_dict:
+            if keys not in old_dict:
+                post_by_id.__setattr__(keys, new_dict[keys])
+            else:
+                # replace old value with new value
+                if "tag" not in keys:
+                    print(f"Warning: {keys} is not a tag")
+                current_value = post_by_id.__getattribute__(keys)
+                target_values_to_remove = old_dict[keys]
+                target_values_to_add = new_dict[keys]
+                # remove old values
+                for values in current_value:
+                    name = values.name
+                    if name in target_values_to_remove:
+                        current_value.remove(values)
+                # add new values
+                for values in target_values_to_add:
+                    # no int values allowed
+                    assert isinstance(values, str), f"Error: {values} is not a string"
+                    tag = Tag.get_or_none(Tag.name == values)
+                    if tag is None:
+                        print(f"Warning: {values} is not in database, adding")
+                        tag = Tag.create(name=values, type=keys.split("_")[-1], popularity=0)
+                    # assert unique, tag should not be iterable
+                    assert not isinstance(tag, list), f"Error: {tag} is iterable"
+                    current_value.append(tag)
+        post_by_id.save()
+    else:
+        return
+def main(filepath="difference_cache.jsonl"):
+    print(f"Reading differences from {filepath}")
+    differences = get_differences(filepath)
+    with db.atomic():# commit all changes at once
+        commit_differences(differences)
+    # sample random post from differences and show
+    sample_post_id = choice(list(differences.keys()))
+    print(f"Sample Post: {sample_post_id}")
+    print(f"Sample Difference: {differences[sample_post_id]}")
+    # get real state of post
+    post = Post.get_by_id(sample_post_id)
+    for fields in FIELDS_TO_EXTRACT:
+        attr = post.__getattribute__(FIELDS_TO_EXTRACT[fields])
+        if isinstance(attr, list):
+            print(f"{fields}: {[tag.name for tag in attr]}")
+        else:
+            print(f"{fields}: {attr}")
+
+FIELDS_TO_EXTRACT = {
+    'id': 'id',
+    'created_at': 'created_at',
+    'source': 'source',
+    'rating': 'rating',
+    'score': 'score',
+    'fav_count': 'fav_count',
+    'tag_list_general': 'tag_list_general',
+    'tag_list_artist': 'tag_list_artist',
+    'tag_list_character': 'tag_list_character',
+    'tag_list_copyright': 'tag_list_copyright',
+    'tag_list_meta': 'tag_list_meta',
+}
+
+def save_post(idx:int):
+    folder = "danbooru2023_fixed"
+    dump = {}
+    if not os.path.exists(f"{folder}/posts"):
+        os.makedirs(f"{folder}/posts")
+    post = Post.get_by_id(idx)
+    with open(f"{folder}/posts/{idx}.json",'w') as file:
+        for field in FIELDS_TO_EXTRACT:
+            dump[field] = post.__getattribute__(FIELDS_TO_EXTRACT[field])
+            # if list, convert to list of string instead of tag objects
+            if isinstance(dump[field], list):
+                dump[field] = [tag.name for tag in dump[field]]
+        json.dump(dump, file)
+
+if __name__ == "__main__":
+    jsonl_files = glob.glob(r"G:\database\finished\*.jsonl")
+    # sort by number
+    jsonl_files.sort()
+    for file in tqdm(jsonl_files):
+        main(file)

db.py

@@ -0,0 +1,116 @@
+import json
+import pathlib
+import sqlite3
+from peewee import *
+
+
+class MemoryConnection(sqlite3.Connection):
+    def __init__(self, dbname, *args, **kwargs):
+        load_conn = sqlite3.connect(dbname)
+        super(MemoryConnection, self).__init__(":memory:", *args, **kwargs)
+        load_conn.backup(self)
+        load_conn.close()
+
+
+class SqliteMemDatabase(SqliteDatabase):
+    def __init__(self, database, *args, **kwargs) -> None:
+        self.dbname = database
+        super().__init__(database, *args, factory=MemoryConnection, **kwargs)
+
+    def reload(self, dbname=None):
+        if dbname is None:
+            dbname = self.dbname
+        load_conn = sqlite3.connect(dbname)
+        try:
+            load_conn.backup(self._state.conn)
+        finally:
+            load_conn.close()
+
+    def save(self, dbname=None):
+        if dbname is None:
+            dbname = self.dbname
+        save_conn = sqlite3.connect(dbname)
+        try:
+            self._state.conn.backup(save_conn)
+        finally:
+            save_conn.close()
+
+
+# db = SqliteMemDatabase(pathlib.Path(__file__).parent.resolve() / "danbooru2023.db")
+db = SqliteDatabase(pathlib.Path(__file__).parent.resolve() / "danbooru2023.db")
+
+
+class TagListField(TextField):
+    def db_value(self, value):
+        assert all(isinstance(tag, (Tag, int)) for tag in value)
+        return json.dumps([tag.id if isinstance(tag, Tag) else tag for tag in value])
+
+    def python_value(self, value):
+        if value is not None:
+            id_list = json.loads(value)
+            tags = Tag.select().where(Tag.id << id_list)
+            return [tag for tag in tags]
+
+
+class BaseModel(Model):
+    class Meta:
+        database = db
+
+
+class Post(BaseModel):
+    id = IntegerField(primary_key=True)
+    created_at = CharField()
+    uploader_id = IntegerField()
+    source = CharField()
+    md5 = CharField(null=True)
+    parent_id = IntegerField(null=True)
+    has_children = BooleanField()
+    is_deleted = BooleanField()
+    is_banned = BooleanField()
+    pixiv_id = IntegerField(null=True)
+    has_active_children = BooleanField()
+    bit_flags = IntegerField()
+    has_large = BooleanField()
+    has_visible_children = BooleanField()
+
+    image_width = IntegerField()
+    image_height = IntegerField()
+    file_size = IntegerField()
+    file_ext = CharField()
+
+    rating = CharField()
+    score = IntegerField()
+    up_score = IntegerField()
+    down_score = IntegerField()
+    fav_count = IntegerField()
+
+    file_url = CharField()
+    large_file_url = CharField()
+    preview_file_url = CharField()
+
+    tag_list = TagListField()
+    tag_list_general = TagListField()
+    tag_list_artist = TagListField()
+    tag_list_character = TagListField()
+    tag_list_copyright = TagListField()
+    tag_list_meta = TagListField()
+
+    tag_count = IntegerField()
+    tag_count_general = IntegerField()
+    tag_count_artist = IntegerField()
+    tag_count_character = IntegerField()
+    tag_count_copyright = IntegerField()
+    tag_count_meta = IntegerField()
+
+
+class Tag(BaseModel):
+    id = IntegerField(primary_key=True)
+    name = CharField(unique=True)
+    type = CharField()
+    popularity = IntegerField()
+
+
+if __name__ == "__main__":
+    db.connect()
+    db.create_tables([Post, Tag])
+    db.save()

fix_tags.py

@@ -0,0 +1,29 @@
+"""
+Executing the script will update the popularity of tags with actual popularity
+Warn : this may take a long time
+"""
+
+from db import *
+from collections import Counter
+from peewee import fn
+from tqdm import tqdm
+
+def fix_tags_with_Counter():
+    # Calculate tag popularity
+    counter = Counter()
+    # post -> post select -> to tag list
+    get_tags_list_from_post_query = (Post.select(Post.id))
+    for post in tqdm(get_tags_list_from_post_query):
+        post = Post.get_by_id(post.id)
+        counter.update([tag.id for tag in post.tag_list])
+    # Bulk update tags
+    with db.atomic():
+        print("Updating tags for {} tags".format(len(counter)))
+        for tag, popularity in tqdm(counter.items()):
+            print(f"Updating {tag} with popularity {popularity}")
+            (Tag.update({Tag.popularity: popularity})
+             .where(Tag.id == tag)
+             .execute())
+
+if __name__ == "__main__":
+    fix_tags_with_Counter()

view-dataset.py

@@ -0,0 +1,57 @@
+from db import *
+
+# view 6719955 post
+
+def pretty_print(post_id:int) -> str:
+    """
+    Returns a pretty printed post
+    """
+    post = Post.get_by_id(post_id)
+    def pretty_print_tag(tag):
+        """
+        Returns a pretty printed tag
+        """
+        return f"{tag.name}({tag.id})"
+    
+    def pretty_print_tags(tags):
+        """
+        Returns a pretty printed list of tags
+        """
+        return ", ".join([pretty_print_tag(tag) for tag in tags])
+    
+    fields = {"tag_list_general", "tag_list_artist", "tag_list_character", "tag_list_meta", "tag_list_copyright"}
+    string = ""
+    # start printing
+    string += f"Post {post_id}\n"
+    for field in fields:
+        string += f"\t{field}: {pretty_print_tags(post.__getattribute__(field))}\n"
+    return string
+
+diff = {"tag_list_general": ["virtual_youtuber"], "tag_list_character": ["otonose_kanade"], "tag_list_artist": ["jb_jagbung"], "tag_list_copyright": ["hololive", "hololive_dev_is"]}
+
+def get_ids_of_tags_from_difference(difference):
+    """
+    Returns a list of ids of tags from the difference
+    """
+    ids = dict()
+    for tag_list in difference.values():
+        for tag in tag_list:
+            ids[tag] = Tag.get(Tag.name == tag).id
+    return ids
+
+def pretty_print_tags_from_difference(difference):
+    """
+    Returns a pretty printed string of tags from the difference
+    """
+    target_ids = get_ids_of_tags_from_difference(difference)
+    string = ""
+    for tag in target_ids:
+        string += f"{tag}({target_ids[tag]})\n"
+    return string
+
+def main():
+    print(pretty_print(6719955))
+    print(pretty_print_tags_from_difference(diff))
+
+if __name__ == '__main__':
+    main()