Update peewee schema

db.py

@@ -1,13 +1,41 @@
-import pathlib
 import sqlite3
 
-from numpy import base_repr
 from peewee import *
-from playhouse.sqlite_ext import FTS5Model, SearchField
-from playhouse.shortcuts import model_to_dict
 
 
-db = SqliteDatabase(pathlib.Path(__file__).parent.resolve() / "danbooru2023.db")
+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: SqliteDatabase = None
 tag_cache_map = {}
 
 
@@ -17,23 +45,6 @@ def get_tag_by_id(id):
     return tag_cache_map[id]
 
 
-class TagListField(TextField, SearchField):
-    def db_value(self, value):
-        if isinstance(value, str):
-            return value
-        assert all(isinstance(tag, (Tag, int)) for tag in value)
-        return "".join(
-            f"${base_repr(tag.id, 36) if isinstance(tag, Tag) else base_repr(tag, 36)}#"
-            for tag in value
-        )
-
-    def python_value(self, value):
-        if value is not None:
-            return [
-                get_tag_by_id(int(tag, 36)) for tag in value[1:-1].split("#$") if tag
-            ]
-
-
 class EnumField(IntegerField):
     def __init__(self, enum_list, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -56,6 +67,29 @@ class BaseModel(Model):
         database = db
 
 
+class Tag(BaseModel):
+    id = IntegerField(primary_key=True)
+    name = CharField(unique=True)
+    type = EnumField(["general", "artist", "character", "copyright", "meta"])
+    popularity = IntegerField()
+    _posts: ManyToManyField
+    _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):
+        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()
@@ -87,12 +121,9 @@ class Post(BaseModel):
     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()
+    _tags: ManyToManyField
+    _tags_cache = None
+    _tag_list = TextField(column_name="tag_list")
 
     tag_count = IntegerField()
     tag_count_general = IntegerField()
@@ -101,32 +132,64 @@ class Post(BaseModel):
     tag_count_copyright = IntegerField()
     tag_count_meta = IntegerField()
 
+    @property
+    def tag_list(self):
+        if self._tags_cache is None:
+            self._tags_cache = list(self._tags)
+        return self._tags_cache
 
-class PostFTS(FTS5Model):
-    class Meta:
-        database = db
+    @property
+    def tag_list_general(self):
+        return [tag for tag in self.tag_list if tag.type == "general"]
 
-    tag_list = TagListField()
-    tag_list_general = TagListField()
-    tag_list_artist = TagListField()
-    tag_list_character = TagListField()
-    tag_list_copyright = TagListField()
-    tag_list_meta = TagListField()
+    @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"]
 
-class Tag(BaseModel):
-    id = IntegerField(primary_key=True)
-    name = CharField(unique=True)
-    type = EnumField(["general", "artist", "character", "copyright", "meta"])
-    popularity = IntegerField()
+    @property
+    def tag_list_copyright(self):
+        return [tag for tag in self.tag_list if tag.type == "copyright"]
 
-    def __str__(self):
-        return f"<Tag: {self.name}>"
+    @property
+    def tag_list_meta(self):
+        return [tag for tag in self.tag_list if tag.type == "meta"]
 
 
-if __name__ == "__main__":
+class PostTagRelation(BaseModel):
+    post = ForeignKeyField(Post, backref="post_tags")
+    tag = ForeignKeyField(Tag, backref="tag_posts")
+
+
+tags = ManyToManyField(Tag, backref="_posts", through_model=PostTagRelation)
+tags.bind(Post, "_tags", set_attribute=True)
+
+
+def load_db(db_file: str):
+    global db
+    db = SqliteDatabase(db_file)
+    Post._meta.database = db
+    Tag._meta.database = db
+    PostTagRelation._meta.database = db
     db.connect()
-    for index in db.get_indexes("post"):
-        print(index)
-    post = Post.select().first()
-    print(model_to_dict(post))
+
+
+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(
+        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
+    )
+    print(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))

db_utils.py

@@ -1,14 +1,8 @@
-from numpy import base_repr
 from db import *
 
 
 def get_post_by_tag(tag: Tag):
-    id_str = f''"${base_repr(tag.id, 36)}#''"
-    return (
-        Post.select()
-        .join(PostFTS, on=(Post.id == PostFTS.rowid))
-        .where(PostFTS.tag_list.contains(id_str))
-    )
+    return list(tag.posts)
 
 
 def get_tag_by_name(name: str):
@@ -16,4 +10,4 @@ def get_tag_by_name(name: str):
 
 
 def get_tags_by_popularity(n: int):
-    return Tag.select().where(Tag.popularity >= n)
+    return Tag.select().where(Tag.popularity >= n)