Update DB with some utils

db.py

@@ -139,7 +139,9 @@ def load_db(db_file: str):
             return [tag for tag in self.tag_list if tag.type == "unknown"]
 
 
-    class Tag(BaseModel):
+    class Tag(BaseModel):# table name is tags
+        class Meta:
+            db_table = "tags"
         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
@@ -190,6 +192,8 @@ def load_db(db_file: str):
     LocalPost._meta.database = db
     db.connect()
     print("Database connected.")
+    # print all tables
+    print(db.get_tables())
     if not file_exists:
         db.create_tables([Post, Tag, PostTagRelation])
         db.create_tables([LocalPost])
@@ -225,4 +229,4 @@ if __name__ == "__main__":
                         break
                     break
             else:
-                print('not a file')
+                print('not a file')

fix_tags.py

@@ -0,0 +1,46 @@
+from utils.gelboorutags import GelbooruTag as TagHandler
+from db import load_db
+from peewee import fn
+from tqdm import tqdm
+handler = TagHandler(exception_handle=0) #general for 0
+
+def fix_tags(tags):
+    result = handler.get_types(tags, verbose=True)[0]
+    if result == "deprecated":
+        return "general"
+    return result
+
+# test
+
+db_dict = load_db('gelbooru2024-02.db')
+GelbooruDB, GelbooruPost, GelbooruTag, GelbooruPostTagRelation = db_dict['db'], db_dict['Post'], db_dict['Tag'], db_dict['PostTagRelation']
+
+# get tags which is not unknown type
+tags = GelbooruTag.select().where(GelbooruTag.type != "unknown")
+print(tags.count())
+# get random post
+tags = GelbooruTag.select().where(GelbooruTag.type == "unknown")
+pbar = tqdm(tags, total=tags.count()) # Tag -> fix_tags(tag.name) -> [Tag.type]
+fixed_count = 0
+# batch update
+batch_size = 1000
+batch = []
+for tag in tags:
+    batch.append((fix_tags(tag.name), tag.id))
+    if len(batch) >= batch_size:
+        with GelbooruDB.atomic():
+            pbar.set_description("Updating")
+            for fixed_tag, tag_id in batch:
+                GelbooruTag.update(type=fixed_tag).where(GelbooruTag.id == tag_id).execute()
+        fixed_count += len(batch)
+        batch = []
+        pbar.update(batch_size)
+        pbar.set_postfix(fixed=fixed_count)
+    else:
+        pbar.set_description("Collecting")
+if batch:
+    with GelbooruDB.atomic():
+        for fixed_tag, tag_id in batch:
+            GelbooruTag.update(type=fixed_tag).where(GelbooruTag.id == tag_id).execute()
+    fixed_count += len(batch)
+    pbar.set_postfix(fixed=fixed_count)

gelbooru2024-02.db

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

utils/gelboorutags.py

@@ -0,0 +1,322 @@
+import os
+from .proxyhandler import ProxyHandler
+from typing import List
+import json
+import html
+import logging
+import datetime
+from urllib.parse import quote
+from threading import Lock
+
+class GelbooruTag:
+    """
+    Tag dictionary
+    """
+    TAG_TYPE = {
+        0: "general",
+        1: "artist",
+        3: "copyright",
+        4: "character",
+        5: "meta",
+        6: "deprecated"
+    }
+    def __init__(self, file_name="gelbooru_tags.jsonl", handler:ProxyHandler=None, exception_handle=None):
+        """
+        exception_handle -> tag type that will be used if tag is not found
+        """
+        self.file_name = file_name
+        self.tags = {}
+        self.type_by_name = {}
+        self.handler = handler
+        self.exception_handle = exception_handle # if tag not found, what to do
+        self.load()
+        self.filewrite_lock = Lock()
+    def load(self):
+        """
+        Loads the tags
+        """
+        if not os.path.exists(self.file_name):
+            return
+        with open(self.file_name, 'r', encoding='utf-8') as f:
+            for line in f:
+                try:
+                    tag = json.loads(line)
+                except Exception as exce:
+                    if isinstance(exce, KeyboardInterrupt):
+                        raise exce
+                    continue
+                self.tags[tag['name']] = tag
+                self.type_by_name[tag['name']] = tag['type']
+                # add html escaped version
+                escaped_tag_name = html.escape(tag['name']).replace("'", "'")
+                self.tags[escaped_tag_name] = tag
+                self.type_by_name[escaped_tag_name] = tag['type']
+    def save(self):
+        """
+        Saves the tags
+        """
+        with open(self.file_name, 'w', encoding='utf-8') as f:
+            for tag in self.tags.values():
+                f.write(json.dumps(tag) + "\n")
+    def save_tag(self, tag):
+        """
+        Saves the tag
+        """
+        with self.filewrite_lock:
+            with open(self.file_name, 'a', encoding='utf-8') as f:
+                f.write(json.dumps(tag) + "\n")
+    def get_missing_tags(self, tags_string):
+        """
+        Returns the missing tags (not locally stored)
+        """
+        tags_string_list = tags_string.split(" ")
+        tags = []
+        for tag in tags_string_list:
+            if self.get_tag(tag):
+                continue
+            tags.append(tag)
+        return tags
+    def reorganize(self, write_to_new_file=True):
+        # writes down the tags into a new file
+        if not write_to_new_file:
+            with open(self.file_name, 'w', encoding='utf-8') as f:
+                for tag_values in self.tags.values():
+                    f.write(json.dumps(tag_values) + "\n")
+            return
+        with open(self.file_name + "_new", 'w', encoding='utf-8') as f:
+            for tag_values in self.tags.values():
+                f.write(json.dumps(tag_values) + "\n")
+    def reorganize_and_reload(self):
+        """
+        Reorganizes and reloads the tags
+        Useful for broken jsonl files
+        """
+        self.reorganize(write_to_new_file=False)
+        self.load()
+    def get_tag(self, tag_name):
+        """
+        Returns the tag
+        """
+        # if startswith backslash, remove it
+        if tag_name.startswith("\\"):
+            tag_name = tag_name[1:]
+        #print(tag_name) #ninomae_ina'nis  -> ninomae_ina'nis
+        basic_escape = tag_name.replace("'", "'")
+        tag_name_urlsafe = html.unescape(tag_name).replace("'", "'")
+        lower_tag_name = tag_name.lower()
+        upper_tag_name = tag_name.upper()
+        #print(tag_name_urlsafe)
+        if tag_name not in self.tags and tag_name_urlsafe not in self.tags and basic_escape not in self.tags and lower_tag_name not in self.tags and upper_tag_name not in self.tags:
+            return None
+        if basic_escape in self.tags:
+            return self.tags[basic_escape]
+        if lower_tag_name in self.tags:
+            return self.tags[lower_tag_name]
+        if upper_tag_name in self.tags:
+            return self.tags[upper_tag_name]
+        return self.tags[tag_name] if tag_name in self.tags else self.tags[tag_name_urlsafe]
+    def _check_handler(self, handler:ProxyHandler):
+        """
+        Checks the handler
+        """
+        if handler is None:
+            handler = self.handler
+        if handler is None:
+            if self.exception_handle is None:
+                logging.error("Error: Tag was not in dictionary, but cannot get tag because handler is None")
+            raise RuntimeError("Error: Tag was not in dictionary, but cannot get tag because handler is None")
+        return handler
+    def get_types(self, tags_string, handler:ProxyHandler=None, max_retry=10, verbose=False):
+        """
+        Returns the types of given tags
+        This can be used for bulk processing
+        Use threaded version for faster processing (if you have proxy handler)
+        """
+        if tags_string.isspace():
+            return []
+        self.parse_tags(tags_string, handler, max_retry=max_retry)
+        types = []
+        for tag in tags_string.split(" "):
+            # search self.type_by_name first
+            if tag in self.type_by_name:
+                types.append(self.type_by_name[tag])
+                continue
+            else:
+                # first, search dictionary
+                if (tag_result:=self.get_tag(tag)) is not None:
+                    types.append(tag_result['type'])
+                    # add to self.type_by_name
+                    self.type_by_name[tag] = tag_result['type']
+                    continue
+                logging.error(f"Error: {tag} not found from dictionary")
+                if self.exception_handle is not None:
+                    self.type_by_name[tag] = self.exception_handle
+                    types.append(self.exception_handle)
+                else:
+                    raise Exception(f"Error: {tag} not found from type_by_name")
+        if not verbose:
+            return types
+        return [GelbooruTag.TAG_TYPE[t] for t in types]
+    def structured_tags(self, tags_string, handler:ProxyHandler=None, max_retry=10):
+        """
+        Returns the tags and classes as a dictionary
+        This can be used for any string input (maybe merged too) for bulk processing
+        """
+        tags_each = tags_string.split(" ")
+        tag_types = self.get_types(tags_string, handler, max_retry=max_retry,verbose=True)
+        tag_dict = {}
+        for tag, tag_type in zip(tags_each, tag_types):
+            if tag_type not in tag_dict:
+                tag_dict[tag_type] = []
+            tag_dict[tag_type].append(tag)
+        return tag_dict
+    def parse_tags(self, tags_string, handler:ProxyHandler=None, max_retry=10):
+        """
+        Returns the tags and classes
+        """
+        tags_string_list = tags_string.split(" ")
+        tags_string_list = [tag for tag in tags_string_list if tag.strip()]
+        tags = []
+        # prepare _get_tags
+        tag_query_prepared = []
+        # split into 100 tags per request
+        for i in range(0, len(tags_string_list), 100):
+            tag_query_prepared.append(tags_string_list[i:i+100])
+        # get tags
+        for tag_query in tag_query_prepared:
+            self._get_tags(tag_query, handler, max_retry=max_retry)
+            if handler is not None:
+                avg_response_time = handler.get_average_time()
+                if avg_response_time:
+                    print(f"Average response time: {avg_response_time}")
+        # get tags
+        for tag in tags_string_list:
+            if (tag_result:=self.get_tag(tag)) is None:
+                print(f"Error: {tag} not found")
+                continue
+            tags.append(tag_result)
+        return tags
+    def _get_tags(self, tag_names:List[str], handler:ProxyHandler=None, max_retry=10):
+        """
+        Returns the tag. The tag_names should not exceed 100 tags
+        This may require internet connection.
+        """
+        if not tag_names:
+            return
+        missing_tags = []
+        for tag_name in tag_names:
+            if self.get_tag(tag_name):
+                continue
+            missing_tags.append(tag_name)
+        if not missing_tags:
+            return
+        tag_name = " ".join(missing_tags)
+        # unescape html
+        tag_name = html.unescape(tag_name).replace("'", "'")
+        # url encode
+        tag_name = quote(tag_name, safe='')
+        try:
+            self._check_handler(handler)
+        except RuntimeError as e:
+            if self.exception_handle is not None:
+                for tag in missing_tags:
+                    self.type_by_name[tag] = self.exception_handle
+                return
+        for i in range(max_retry):
+            try:
+                response = handler.get_response(f"https://gelbooru.com/index.php?page=dapi&s=tag&q=index&json=1&names={tag_name}")
+                if response is None:
+                    continue
+                tag = json.loads(response) if isinstance(response, str) else response
+                if not tag:
+                    print(f"Error: {tag_name} not found from response {response}")
+                    continue
+                if "tag" not in tag:
+                    logging.error(f"Error: {tag_name} not found from response {response}")
+                    print(f"Error: {tag_name} not found from response {response}")
+                    continue
+                # {"@attributes":{"limit":100,"offset":0,"count":4},"tag":[{"id":152532,"name":"1girl","count":6177827,"type":0,"ambiguous":0},{"id":138893,"name":"1boy","count":1481404,"type":0,"ambiguous":0},{"id":444,"name":"apron","count":174832,"type":0,"ambiguous":0},{"id":135309,"name":"blunt_bangs","count":233912,"type":0,"ambiguous":0}]}
+                for tag in tag['tag']:
+                    self.tags[tag['name']] = tag
+                    self.type_by_name[tag['name']] = tag['type']
+                    # add html escaped version
+                    escaped_tag_name = html.escape(tag['name']).replace("'", "'")
+                    self.tags[escaped_tag_name] = tag
+                    self.type_by_name[escaped_tag_name] = tag['type']
+                    # lower case
+                    lower_tag_name = tag['name'].lower()
+                    self.tags[lower_tag_name] = tag
+                    self.type_by_name[lower_tag_name] = tag['type']
+                    self.save_tag(tag)
+                return
+            except Exception as e:
+                logging.exception(f"Exception: {e} when getting tag {tag_name}, retrying {i}/{max_retry}")
+                print(f"Exception: {e} when getting tag {tag_name}, retrying {i}/{max_retry}")
+                pass
+        print(f"Error: {tag_name} not found after {max_retry} retries")
+    def tag_exists(self, tag_name):
+        """
+        Returns if the tag exists
+        """
+        return tag_name in self.tags
+
+
+class GelbooruMetadata:
+    def __init__(self, **kwargs) -> None:
+        self.id = kwargs.get("id")
+        # convert to YYYY-MM-DD HH:MM:SS format
+        self.created_at = datetime.datetime.strptime(kwargs.get("created_at"), "%a %b %d %H:%M:%S %z %Y").strftime("%Y-%m-%d %H:%M:%S")
+        self.score = kwargs.get("score")
+        self.width = kwargs.get("width")
+        self.height = kwargs.get("height")
+        self.md5 = kwargs.get("md5")
+        self.image_ext = kwargs.get("image").split(".")[-1]
+        self.rating = kwargs.get("rating")
+        self.source = kwargs.get("source", "")
+        self.tags = kwargs.get("tags")
+        self.title = kwargs.get("title", "")
+        self.file_url = kwargs.get("file_url")
+        self.has_children = kwargs.get("has_children", False)
+        self.parent_id = kwargs.get("parent_id", 0)
+    def get_dict(self):
+        return dict(
+            id=self.id,
+            created_at=self.created_at,
+            score=self.score,
+            width=self.width,
+            height=self.height,
+            md5=self.md5,
+            image_ext=self.image_ext,
+            rating=self.rating,
+            source=self.source,
+            tags=self.tags,
+            title=self.title,
+            file_url=self.file_url,
+            has_children=self.has_children,
+            parent_id=self.parent_id,
+        )
+    def structured_dict(self, tag_handler:GelbooruTag, handler:ProxyHandler=None, max_retry=10):
+        """
+        Returns the structured dictionary
+        """
+        tags = tag_handler.structured_tags(self.tags, handler, max_retry=max_retry)
+        return dict(
+            id=self.id,
+            created_at=self.created_at,
+            score=self.score,
+            width=self.width,
+            height=self.height,
+            md5=self.md5,
+            image_ext=self.image_ext,
+            rating=self.rating,
+            source=self.source,
+            title=self.title,
+            file_url=self.file_url,
+            has_children=self.has_children,
+            parent_id=self.parent_id,
+            tag_list_general=tags.get("general", []),
+            tag_list_artist=tags.get("artist", []),
+            tag_list_character=tags.get("character", []),
+            tag_list_meta=tags.get("meta", []),
+            tag_list_copyright=tags.get("copyright", []),
+        )

utils/proxyhandler.py

@@ -0,0 +1,223 @@
+"""
+Proxy Handler Class
+"""
+import json
+from queue import Queue
+import time
+import urllib.parse
+import threading
+import requests
+
+class ThreadSafeDict(dict):
+    """
+    Thread safe dict
+    """
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.lock = threading.Lock()
+    def __getitem__(self, key):
+        with self.lock:
+            return super().__getitem__(key)
+    def __setitem__(self, key, value):
+        with self.lock:
+            return super().__setitem__(key, value)
+    def __delitem__(self, key):
+        with self.lock:
+            return super().__delitem__(key)
+    def __contains__(self, key):
+        with self.lock:
+            return super().__contains__(key)
+    def __len__(self):
+        with self.lock:
+            return super().__len__()
+    def __iter__(self):
+        with self.lock:
+            return super().__iter__()
+    def __repr__(self):
+        with self.lock:
+            return super().__repr__()
+    def __str__(self):
+        with self.lock:
+            return super().__str__()
+
+class ProxyHandler:
+    """
+    Sends request to http://{ip}:{port}/get_response_raw?url={url} with auth 
+    """
+    def __init__(self, proxy_list_file,proxy_auth="user:pass",port=80, wait_time=0.1,timeouts=10):
+        self.proxy_auth = proxy_auth
+        self.port = port
+        self.proxy_list = []
+        self.commit_time = ThreadSafeDict()
+        self.timeouts = timeouts
+        self.wait_time = wait_time
+        self.lock = threading.Lock()
+        self.last_logged_activities = Queue(maxsize=100)
+        with open(proxy_list_file, 'r', encoding='utf-8') as f:
+            for line in f:
+                self.proxy_list.append(line.strip())
+        for i, proxy in enumerate(self.proxy_list):
+            if not proxy.startswith("http"):
+                proxy = "http://" + proxy
+            if ":" not in proxy:
+                proxy += f":{self.port}"
+            if not proxy.endswith("/"):
+                proxy += "/"
+            self.proxy_list[i] = proxy
+        self.proxy_index = -1
+    def log_time(self):
+        """
+        Logs the time
+        """
+        self.last_logged_activities.put(time.time())
+        if self.last_logged_activities.full():
+            # empty oldest
+            self.last_logged_activities.get()
+    def get_average_time(self):
+        """
+        Returns the average time
+        """
+        # get oldest and newest to get the average time
+        if len(self.last_logged_activities.queue) > 1:
+            return (self.last_logged_activities.queue[-1] - self.last_logged_activities.queue[0]) / self.last_logged_activities.qsize()
+        return 0
+    def wait_until_commit(self, proxy_index=None):
+        """
+        Waits until the commit time
+        """
+        if proxy_index is None:
+            proxy_index = self.proxy_index
+        if proxy_index not in self.commit_time:
+            self.commit_time[proxy_index] = 0
+        while time.time() < self.commit_time[proxy_index] + self.wait_time:
+            time.sleep(0.01)
+        self.commit_time[proxy_index] = time.time()
+    def _update_proxy_index(self):
+        """
+        Updates the proxy index
+        """
+        with self.lock:
+            self.proxy_index = (self.proxy_index + 1) % len(self.proxy_list)
+            return self.proxy_index
+    def get_response(self, url):
+        """
+        Returns the response of the url
+        """
+        url = urllib.parse.quote(url, safe='')
+        try:
+            index = self._update_proxy_index()
+            self.wait_until_commit(index)
+            self.log_time()
+            response = requests.get(self.proxy_list[index] + f"get_response?url={url}", timeout=self.timeouts, auth=tuple(self.proxy_auth.split(":")))
+            if response.status_code == 200:
+                json_response = response.json()
+                if json_response["success"]:
+                    return json.loads(json_response["response"])
+                else:
+                    if "429" in json_response["response"]:
+                        self.commit_time[index] = time.time() + self.timeouts
+                        print(f"Error: {json_response['response']}, waiting {self.timeouts} seconds")
+                    print(f"Failed in proxy side: {json_response['response']}")
+                    return None
+            elif response.status_code == 429:
+                self.commit_time[index] = time.time() + self.timeouts
+                print(f"Error: {response.status_code}, waiting {self.timeouts} seconds")
+            else:
+                print(f"Failed in proxy side: {response.status_code}")
+                return None
+        except Exception as e:
+            print(f"Error while processing response from proxy: {e}")
+            return None
+    def get(self, url):
+        """
+        Returns the response of the url
+        """
+        url = urllib.parse.quote(url, safe='')
+        try:
+            index = self._update_proxy_index()
+            self.wait_until_commit(index)
+            response = requests.get(self.proxy_list[index] + f"get_response_raw?url={url}", timeout=self.timeouts, auth=tuple(self.proxy_auth.split(":")))
+            if response.status_code == 200:
+                return response
+            else:
+                print(f"Error: {response.status_code}")
+                return None
+        except Exception as e:
+            print(f"Exception: {e}")
+            return None
+    def filesize(self, url):
+        """
+        Returns the filesize of the url
+        """
+        url = urllib.parse.quote(url, safe='')
+        try:
+            index = self._update_proxy_index()
+            self.wait_until_commit(index)
+            response = requests.get(self.proxy_list[index] + f"file_size?url={url}", timeout=self.timeouts, auth=tuple(self.proxy_auth.split(":")))
+            if response.status_code == 200:
+                return int(response.text)
+            else:
+                print(f"Error: {response.status_code} when getting filesize from {url}")
+                return None
+        except Exception as e:
+            print(f"Exception: {e}")
+            return None
+    def get_filepart(self, url, start, end):
+        """
+        Returns the response of the url with range
+        """
+        url = urllib.parse.quote(url, safe='')
+        try:
+            index = self._update_proxy_index()
+            self.wait_until_commit(index)
+            response = requests.get(self.proxy_list[index] + f"filepart?url={url}&start={start}&end={end}", timeout=self.timeouts, auth=tuple(self.proxy_auth.split(":")))
+            if response.status_code == 200:
+                return response
+            else:
+                print(f"Error: {response.status_code}")
+                return None
+        except Exception as e:
+            print(f"Exception: {e}")
+            return None
+    def check(self,raise_exception=False):
+        """
+        Checks if the proxies are working
+        """
+        failed_proxies = []
+        for i, proxy in enumerate(self.proxy_list):
+            try:
+                response = requests.get(proxy, auth=tuple(self.proxy_auth.split(":")), timeout=2)
+                if response.status_code == 200:
+                    continue
+                else:
+                    print(f"Proxy {proxy} is not working")
+                    failed_proxies.append(i)
+            except Exception as e:
+                print(f"Proxy {proxy} is not working: {e}")
+                failed_proxies.append(i)
+        if len(failed_proxies) > 0:
+            if raise_exception:
+                raise Exception(f"Proxies {failed_proxies} are not working")
+            else:
+                print(f"Proxies {failed_proxies} are not working, total {len(failed_proxies)} proxies of {len(self.proxy_list)} are not working")
+                # remove failed proxies
+                for i in failed_proxies[::-1]:
+                    del self.proxy_list[i]
+                if len(self.proxy_list) == 0:
+                    raise Exception("No proxies available")
+        else:
+            print(f"All {len(self.proxy_list)} proxies are working")
+
+class SingleProxyHandler(ProxyHandler):
+    """
+    Sends request to http://{ip}:{port}/get_response_raw?url={url} with auth
+    """
+    def __init__(self, proxy_url, proxy_auth="user:pass",port=80, wait_time=0.1,timeouts=10):
+        self.proxy_auth = proxy_auth
+        self.port = port
+        self.proxy_list = [proxy_url]
+        self.proxy_index = -1
+        self.commit_time = ThreadSafeDict()
+        self.timeouts = timeouts
+        self.wait_time = wait_time
+        self.lock = threading.Lock()