Upload 14 files

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+data/autocomplete/__pycache__/artist_dictionary.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+data/autocomplete/__pycache__/danbooru_character.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text
+data/autocomplete/__pycache__/result_dupl.cpython-312.pyc filter=lfs diff=lfs merge=lfs -text

data/__init__.py

@@ -0,0 +1 @@
+# NAIA-WEB Data Package

data/autocomplete/__init__.py

@@ -0,0 +1 @@
+# Autocomplete data package

data/autocomplete/__pycache__/artist_dictionary.cpython-312.pyc

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5efe0ffa80b1cd2ddfa8b16e052fcf4997402fbfd6ef67b060f7e153d4060f4a
+size 3033064

data/autocomplete/__pycache__/danbooru_character.cpython-312.pyc

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

data/autocomplete/__pycache__/result_dupl.cpython-312.pyc

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

data/character_store.py

@@ -0,0 +1,146 @@
+"""
+Character Store for NAIA-WEB
+Provides character search functionality using danbooru_character data
+"""
+
+from typing import List, Tuple, Optional, Set
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class CharacterInfo:
+    """Character information"""
+    name: str
+    tags: str
+    count: int
+
+
+class CharacterStore:
+    """
+    Character data store for search functionality.
+    Loads data from danbooru_character.py on first access.
+    Filters tags using characteristic_list.txt.
+    """
+
+    _instance = None
+    _loaded = False
+    _characters: dict = {}
+    _counts: dict = {}
+    _characteristic_set: Set[str] = set()
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not CharacterStore._loaded:
+            self._load_data()
+
+    def _load_characteristic_list(self) -> Set[str]:
+        """Load characteristic list from file"""
+        characteristic_set = set()
+        try:
+            list_path = Path(__file__).parent / "characteristic_list.txt"
+            if list_path.exists():
+                with open(list_path, 'r', encoding='utf-8') as f:
+                    for line in f:
+                        tag = line.strip().lower()
+                        if tag:
+                            characteristic_set.add(tag)
+                print(f"NAIA-WEB: Loaded {len(characteristic_set)} characteristic tags")
+            else:
+                print(f"NAIA-WEB: characteristic_list.txt not found at {list_path}")
+        except Exception as e:
+            print(f"NAIA-WEB: Failed to load characteristic list: {e}")
+        return characteristic_set
+
+    def _filter_tags(self, tags_str: str) -> str:
+        """Filter tags to only include characteristic tags"""
+        if not CharacterStore._characteristic_set:
+            return tags_str
+
+        tags = [t.strip() for t in tags_str.split(',')]
+        filtered = [t for t in tags if t.lower() in CharacterStore._characteristic_set]
+        return ', '.join(filtered)
+
+    def _load_data(self):
+        """Load character data from danbooru_character.py"""
+        try:
+            # Load characteristic list first
+            CharacterStore._characteristic_set = self._load_characteristic_list()
+
+            from data.danbooru_character import character_dict, character_dict_count
+            CharacterStore._characters = character_dict
+            CharacterStore._counts = character_dict_count
+            CharacterStore._loaded = True
+            print(f"NAIA-WEB: Loaded {len(character_dict)} characters")
+        except ImportError as e:
+            print(f"NAIA-WEB: Failed to load character data: {e}")
+            CharacterStore._characters = {}
+            CharacterStore._counts = {}
+            CharacterStore._loaded = True
+
+    def search(self, query: str, min_count: int = 20, limit: int = 50) -> List[CharacterInfo]:
+        """
+        Search characters by name.
+
+        Args:
+            query: Search query (character name)
+            min_count: Minimum count threshold
+            limit: Maximum results to return
+
+        Returns:
+            List of CharacterInfo sorted by count (descending)
+        """
+        query = query.lower().strip()
+        results = []
+
+        for name, tags in CharacterStore._characters.items():
+            count = CharacterStore._counts.get(name, 0)
+
+            # Filter by minimum count
+            if count < min_count:
+                continue
+
+            # Filter by query
+            if query and query not in name.lower():
+                continue
+
+            results.append(CharacterInfo(
+                name=name,
+                tags=self._filter_tags(tags),
+                count=count
+            ))
+
+        # Sort by count descending
+        results.sort(key=lambda x: -x.count)
+
+        return results[:limit]
+
+    def get_character(self, name: str) -> Optional[CharacterInfo]:
+        """Get character info by exact name"""
+        name = name.lower()
+        if name in CharacterStore._characters:
+            return CharacterInfo(
+                name=name,
+                tags=self._filter_tags(CharacterStore._characters[name]),
+                count=CharacterStore._counts.get(name, 0)
+            )
+        return None
+
+    def get_popular_characters(self, limit: int = 50) -> List[CharacterInfo]:
+        """Get most popular characters"""
+        return self.search("", min_count=50, limit=limit)
+
+
+# Global instance
+_store = None
+
+def get_character_store() -> CharacterStore:
+    """Get the global CharacterStore instance"""
+    global _store
+    if _store is None:
+        _store = CharacterStore()
+    return _store

data/characteristic_list.txt

@@ -0,0 +1,881 @@
+flat chest
+small breasts
+medium breasts
+large breasts
+huge breasts
+aqua eyes
+black eyes
+blue eyes
+brown eyes
+green eyes
+grey eyes
+orange eyes
+purple eyes
+pink eyes
+red eyes
+white eyes
+yellow eyes
+amber eyes
+heterochromia
+multicolored eyes
+aqua pupils
+blue pupils
+brown pupils
+green pupils
+grey pupils
+orange pupils
+pink pupils
+purple pupils
+red pupils
+white pupils
+yellow pupils
+pointy ears
+long pointy ears
+aqua hair
+black hair
+blonde hair
+blue hair
+light blue hair
+dark blue hair
+brown hair
+light brown hair
+green hair
+dark green hair
+light green hair
+grey hair
+orange hair
+pink hair
+purple hair
+light purple hair
+red hair
+white hair
+multicolored hair
+colored inner hair
+colored tips
+roots (hair)
+gradient hair
+print hair
+rainbow hair
+split-color hair
+spotted hair
+streaked hair
+two-tone hair
+very short hair
+short hair
+medium hair
+long hair
+very long hair
+absurdly long hair
+big hair
+bald
+bald girl
+bob cut
+inverted bob
+bowl cut
+buzz cut
+chonmage
+crew cut
+flattop
+okappa
+pixie cut
+undercut
+flipped hair
+wolf cut
+cornrows
+dreadlocks
+hime cut
+mullet
+bow-shaped hair
+braid
+braided bangs
+front braid
+side braid
+french braid
+crown braid
+single braid
+multiple braids
+twin braids
+low twin braids
+tri braids
+quad braids
+flower-shaped hair
+hair bun
+braided bun
+single hair bun
+double bun
+cone hair bun
+doughnut hair bun
+heart hair bun
+triple bun
+hair rings
+single hair ring
+half updo
+one side up
+two side up
+low-braided long hair
+low-tied long hair
+mizura
+multi-tied hair
+nihongami
+ponytail
+folded ponytail
+front ponytail
+high ponytail
+short ponytail
+side ponytail
+split ponytail
+star-shaped hair
+topknot
+twintails
+low twintails
+short twintails
+uneven twintails
+tri tails
+quad tails
+quin tails
+twisted hair
+afro
+huge afro
+beehive hairdo
+crested hair
+pompadour
+quiff
+shouten pegasus mix mori
+curly hair
+drill hair
+twin drills
+tri drills
+hair flaps
+messy hair
+pointy hair
+ringlets
+spiked hair
+straight hair
+wavy hair
+bangs
+arched bangs
+asymmetrical bangs
+bangs pinned back
+blunt bangs
+crossed bangs
+diagonal bangs
+dyed bangs
+fanged bangs
+hair over eyes
+hair over one eye
+long bangs
+parted bangs
+curtained hair
+ribbon bangs
+short bangs
+swept bangs
+hair between eyes
+hair intakes
+single hair intake
+sidelocks
+asymmetrical sidelocks
+drill sidelocks
+low-tied sidelocks
+sidelocks tied back
+single sidelock
+ahoge
+heart ahoge
+huge ahoge
+antenna hair
+heart antenna hair
+comb over
+hair pulled back
+hair slicked back
+mohawk
+oseledets
+lone nape hair
+hair bikini
+hair censor
+hair in own mouth
+hair over breasts
+hair over one breast
+hair over crotch
+hair over shoulder
+hair scarf
+alternate hairstyle
+hair down
+hair up
+asymmetrical hair
+sidecut
+blunt ends
+dark skin
+dark-skinned female
+pale skin
+sun tatoo
+black skin
+blue skin
+green skin
+grey skin
+orange skin
+pink skin
+purple skin
+red skin
+white skin
+yellow skin
+colored skin
+multiple tails
+demon tail
+dragon tail
+ghost tail
+pikachu tail
+snake head tail
+fiery tail
+bear tail
+rabbit tail
+cat tail
+cow tail
+deer tail
+dog tail
+ermine tail
+fox tail
+horse tail
+leopard tail
+lion tail
+monkey tail
+mouse tail
+pig tail
+sheep tail
+squirrel tail
+tiger tail
+wolf tail
+crocodilian tail
+fish tail
+scorpion tail
+snake tail
+tadpole tail
+animal ears
+bat ears
+bear ears
+rabbit ears
+cat ears
+cow ears
+deer ears
+dog ears
+ferret ears
+fox ears
+goat ears
+horse ears
+kemonomimi mode
+lion ears
+monkey ears
+mouse ears
+panda ears
+pikachu ears
+pig ears
+raccoon ears
+sheep ears
+squirrel ears
+tiger ears
+wolf ears
+fake animal ears
+animal ear headphones
+bear ear headphones
+cat ear headphones
+rabbit ear headphones
+hair ears
+robot ears
+extra ears
+ear piercing
+ear protection
+object behind ear
+roots
+alternate hair color
+translucent hair
+widow's peak
+neckbeard
+stroking beard
+two-tone beard
+braided beard
+long beard
+tied beard
+very long beard
+goatee
+mustache
+stubble
+alternate facial hair
+bearded girl
+fake mustache
+beard
+toothbrush mustache
+mustached girl
+head fins
+single head wing
+wings
+alternate wings
+multiple wings
+no wings
+single wing
+large wings
+mini wings
+angel wings
+demon wings
+dragon wings
+fairy wings
+insect wings
+butterfly wings
+dragonfly wings
+ladybug wings
+moth wings
+bat wings
+crystal wings
+energy wings
+fiery wings
+ice wings
+light hawk wings
+liquid wings
+artificial wings
+fake wings
+hair wings
+mechanical wings
+metal wings
+plant wings
+feathered wings
+black wings
+gradient wings
+red wings
+white wings
+blue wings
+green wings
+brown wings
+transparent wings
+yellow wings
+pink wings
+rainbow wings
+grey wings
+ankle wings
+detached wings
+head wings
+low wings
+leg wings
+wrist wings
+wing ears
+winged arms
+winged bag
+winged hat
+winged helmet
+winged footwear
+asymmetrical wings
+bloody wings
+bowed wings
+flapping
+glowing wings
+heart wings
+torn wings
+wing censor
+grabbing another's wing
+wing hug
+wing umbrella
+wingjob
+wing ribbon
+constricted pupils
+dilated pupils
+extra pupils
+horizontal pupils
+no pupils
+slit pupils
+symbol-shaped pupils
+diamond-shaped pupils
+flower-shaped pupils
+heart-shaped pupils
+star-shaped pupils
+cross-shaped pupils
+x-shaped pupils
+mismatched pupils
+blue sclera
+black sclera
+blank eyes
+bloodshot eyes
+green sclera
+mismatched sclera
+no sclera
+orange sclera
+red sclera
+yellow sclera
+bags under eyes
+aegyo sal
+bruised eye
+flaming eyes
+glowing eyes
+glowing eye
+missing eye
+one-eyed
+third eye
+extra eyes
+no eyes
+covering own eyes
+bandage over one eye
+eyelashes
+colored eyelashes
+fake eyelashes
+eyes visible through hair
+makeup
+eyeliner
+eyeshadow
+mascara
+forehead mark
+forehead
+aqua lips
+black lips
+blue lips
+grey lips
+green lips
+orange lips
+pink lips
+purple lips
+red lips
+shiny lips
+yellow lips
+tail
+tail bell
+tail bow
+tail ornament
+tail piercing
+tail ribbon
+tail ring
+fake tail
+heart tail
+heart tail duo
+holding another's tail
+holding own tail
+holding with tail
+intertwined tails
+panties around tail
+prehensile tail
+spiked tail
+stiff tail
+tail between legs
+tail biting
+tail censor
+tail grab
+tail fondling
+tail pull
+tail raised
+tail stand
+tail wagging
+tail wrap
+dark-skinned male
+dark-skinned other
+matching hairstyle
+official alternate hairstyle
+single side bun
+side up bun
+dog human
+gorilla human
+cat human
+bear human
+raccoon human
+werewolf
+squirrel human
+pig human
+horse human
+bat human
+deer human
+lion human
+cow human
+sheep human
+fox human
+goat human
+monkey human
+ferret human
+mouse human
+rabbit human
+panda human
+tiger human
+dog furry
+gorilla furry
+cat furry
+bear furry
+raccoon furry
+wolf furry
+squirrel furry
+pig furry
+horse furry
+bat furry
+deer furry
+lion furry
+cow furry
+sheep furry
+fox furry
+goat furry
+monkey furry
+ferret furry
+mouse furry
+rabbit furry
+panda furry
+tiger furry
+furry
+yellow hair
+sky blue hair
+ombre
+sombre
+absurdly short hair
+gray hair streak
+white hair streak
+brown hair streak
+red hair streak
+pink hair streak
+orange hair streak
+yellow hair streak
+blonde hair streak
+light green hair streak
+green hair streak
+sky blue hair streak
+blue hair streak
+purple hair streak
+black hair streak
+rainbow hair streak
+short eyes
+long eyes
+short eyebrow
+long eyebrow
+slender eyebrow
+heavy eyebrow
+short eyelashes
+long eyelashes
+slender eyelashes
+heavy eyelashes
+gray eyes
+golden eyes
+light green eyes
+sky blue eyes
+odd eye
+multicolored eye
+spade-shaped pupils
+clover-shaped pupils
+blanked eyes
+empty eyes
+bloodshot pupils
+flaming pupils
+glowing pupils
+halo
+horns
+horn bow
+horn ornament
+horn ribbon
+horn ring
+horned headwear
+horned helmet
+horned hood
+horned mask
+black horns
+blue horns
+brown horns
+purple horns
+red horns
+white horns
+single horn
+multiple horns
+asymmetrical horns
+mismatched horns
+uneven horns
+broken horns
+broken horn
+cone horns
+cow horns
+curled horns
+demon horns
+dragon horns
+fake horns
+fiery horns
+glowing horns
+giraffe horns
+goat horns
+gradient horns
+hair horns
+huge horns
+low horns
+mechanical horns
+sheep horns
+tree horns
+skin-covered horns
+broken halo
+compass rose halo
+crescent halo
+cruciform halo
+dark halo
+double halo
+drawn halo
+faded halo
+flaming halo
+fake halo
+liquid halo
+mechanical halo
+melting halo
+star halo
+square halo
+winged halo
+animal ear fluff
+fangs
+horse girl
+fang
+abs
+cat girl
+sharp teeth
+demon girl
+robot
+elf
+monster girl
+goblin
+slime
+dark elf
+high elf
+orc
+monster
+fairy
+dragon
+ghost
+spirit
+angel
+devil
+vampire
+dog
+gorilla
+cat
+bear
+raccoon
+wolf
+squirrel
+pig
+horse
+bat
+deer
+lion
+cow
+sheep
+fox
+goat
+ferret
+mouse
+rabbit
+panda
+tiger
+short hair with long locks
+oni horns
+bird wings
+two tails
+shark tail
+raccoon tail
+bird tail
+striped tail
+black tail
+thorns
+multicolored wings
+purple wings
+large tail
+spread wings
+flame-tipped tail
+small horns
+mechanical tail
+striped horns
+grey horns
+horns through headwear
+white tail
+purple tail
+lizard tail
+multicolored horns
+tapir tail
+cetacean tail
+brown tail
+stuffed winged unicorn
+glowing hair
+jaguar tail
+green tail
+pink tail
+orange tail
+yellow tail
+glowing tattoo
+grey tail
+blue tail
+eevee tail
+zebra tail
+no horns
+skunk tail
+trimmed tail
+elephant tail
+leaf wings
+aqua horns
+very long tail
+glowing feather
+tamandua tail
+party horn
+extra tails
+spiked horns
+drawn tail
+meerkat tail
+airplane wing
+panther tail
+glowing hands
+winged unicorn
+tail insertion
+skeletal wings
+fur-tipped tail
+antelope horns
+glowing skin
+cheetah tail
+tasmanian devil tail
+french horn
+moose tail
+hyena tail
+panda tail
+gold horns
+giraffe tail
+implied tail plug
+horn flower
+hugging another's tail
+electric plug tail
+chameleon tail
+anteater tail
+large horns
+aqua wings
+aardwolf tail
+cattail
+mismatched wings
+beaver tail
+tailjob
+chipmunk tail
+jackal tail
+dinosaur tail
+fuse tail
+drawn wings
+red panda tail
+two-tone wings
+yellow horns
+no tail
+red tail
+hair on horn
+otter tail
+hugging tail
+cable tail
+green horns
+multicolored tail
+hedgehog tail
+lifted by tail
+pink horns
+penguin tail
+alpaca tail
+orange horns
+pegasus wings
+long horns
+weasel tail
+pokemon tail
+hugging own tail
+orange wings
+ox horns
+goat tail
+expressive tail
+forked tail
+hair behind ear
+notched ear
+hand on own ear
+hand on another's ear
+grabbing another's ear
+blowing in ear
+bandaid on ear
+fox girl
+magical girl
+dragon girl
+rabbit girl
+wolf girl
+dog girl
+minigirl
+cow girl
+shark girl
+mouse girl
+tiger girl
+arthropod girl
+raccoon girl
+lion girl
+sheep girl
+bird girl
+slime girl
+squirrel girl
+fish girl
+bear girl
+spider girl
+goat girl
+plant girl
+bat girl
+robot girl
+deer girl
+leopard girl
+frog girl
+reptile girl
+moth girl
+monkey girl
+owl girl
+penguin girl
+weasel girl
+chipmunk girl
+dolphin girl
+orca girl
+bee girl
+hedgehog girl
+panda girl
+pig girl
+jaguar girl
+dinosaur girl
+hyena girl
+ox girl
+reindeer girl
+alpaca girl
+prairie dog girl
+red panda girl
+otter girl
+mantis girl
+hamster girl
+unicorn girl
+mushroom girl
+ferret girl
+cheetah girl
+whale girl
+cockroach girl
+zebra girl
+slug girl
+snake girl
+ghost girl
+capybara girl
+donkey girl
+scorpion girl
+monster boy
+cat boy
+tomboy
+demon boy
+dog boy
+fox boy
+wolf boy
+tiger boy
+miniboy
+dragon boy
+cow boy
+rabbit boy
+lion boy
+fish boy
+bear boy
+arthropod boy
+game boy
+bird boy
+monkey boy
+leopard boy
+magical boy
+goat boy
+horse boy
+jackal boy
+girly boy
+cowboy
+reptile boy
+jaguar boy
+shark boy
+octopus boy
+boar boy
+slime boy
+harpy boy
+mouse boy
+cuntboy
+sheep boy
+deer boy
+raccoon boy

data/partition_loader.py

@@ -0,0 +1,281 @@
+"""
+NAIA-WEB Partition Loader
+TGP file loading for Quick Search functionality
+
+Reference: NAIA2.0/ui/remote/quick_search_tab.py (145-255)
+"""
+
+import struct
+import lzma
+import pickle
+from pathlib import Path
+from typing import Dict, List, Set, Optional
+from collections import Counter
+
+try:
+    import numpy as np
+    HAS_NUMPY = True
+except ImportError:
+    HAS_NUMPY = False
+    np = None
+
+
+# Data directory
+DATA_DIR = Path(__file__).parent / "quick_search"
+
+
+class SinglePartitionStore:
+    """
+    Single partition storage (inverted index based) - Quick Search lightweight version
+
+    Reference: NAIA2.0/ui/remote/quick_search_tab.py SinglePartitionStore class
+    """
+
+    MAGIC = b'TGP1'
+    VERSION = 1
+
+    def __init__(self):
+        self.num_events: int = 0
+        self._event_tag_indices = None
+        self._event_tag_indptr = None
+        self._event_counts = None
+        self._tag_to_events: Dict[int, object] = {}
+        self._loaded: bool = False
+
+    @classmethod
+    def load(cls, input_path: str) -> 'SinglePartitionStore':
+        """Load partition file"""
+        if not HAS_NUMPY:
+            raise RuntimeError("NumPy is required")
+
+        store = cls()
+
+        with open(input_path, 'rb') as f:
+            magic = f.read(4)
+            if magic != cls.MAGIC:
+                raise ValueError(f"Invalid format: {magic}")
+
+            _ = struct.unpack('<H', f.read(2))[0]  # version
+            compressed_len = struct.unpack('<I', f.read(4))[0]
+            compressed = f.read(compressed_len)
+
+        serialized = lzma.decompress(compressed)
+        data = pickle.loads(serialized)
+
+        store.num_events = data['num_events']
+        store._event_tag_indices = np.frombuffer(data['event_tag_indices'], dtype=np.uint16).copy()
+        store._event_tag_indptr = np.frombuffer(data['event_tag_indptr'], dtype=np.int32).copy()
+        store._event_counts = np.frombuffer(data['event_counts'], dtype=np.int32).copy()
+
+        store._tag_to_events = {
+            int(k): np.frombuffer(v, dtype=np.int32).copy()
+            for k, v in data['tag_to_events'].items()
+        }
+
+        store._loaded = True
+        return store
+
+    def filter_events(
+        self,
+        required_tags: Optional[List[str]] = None,
+        excluded_tags: Optional[List[str]] = None,
+        tag_to_id: Optional[Dict[str, int]] = None
+    ):
+        """Return event indices matching conditions"""
+        if not self._loaded or not HAS_NUMPY:
+            return np.array([], dtype=np.int32) if HAS_NUMPY else []
+
+        # Start with all events
+        candidates = set(range(self.num_events))
+
+        # Required tags
+        if required_tags and tag_to_id:
+            for tag in required_tags:
+                if tag in tag_to_id:
+                    tag_id = tag_to_id[tag]
+                    if tag_id in self._tag_to_events:
+                        candidates &= set(self._tag_to_events[tag_id])
+                    else:
+                        return np.array([], dtype=np.int32)
+                else:
+                    return np.array([], dtype=np.int32)
+
+        # Excluded tags
+        if excluded_tags and tag_to_id:
+            for tag in excluded_tags:
+                if tag in tag_to_id:
+                    tag_id = tag_to_id[tag]
+                    if tag_id in self._tag_to_events:
+                        candidates -= set(self._tag_to_events[tag_id])
+
+        return np.array(sorted(candidates), dtype=np.int32)
+
+    def get_tag_counts(
+        self,
+        event_indices=None,
+        id_to_tag: Optional[Dict[int, str]] = None
+    ) -> Counter:
+        """Count events per tag"""
+        if not HAS_NUMPY or id_to_tag is None:
+            return Counter()
+
+        if event_indices is None or len(event_indices) == 0:
+            # Total tag counts
+            return Counter({
+                id_to_tag[tag_id]: len(events)
+                for tag_id, events in self._tag_to_events.items()
+                if tag_id in id_to_tag
+            })
+
+        event_set = set(event_indices)
+        return Counter({
+            id_to_tag[tag_id]: len(set(events) & event_set)
+            for tag_id, events in self._tag_to_events.items()
+            if tag_id in id_to_tag
+        })
+
+    def get_event_tags(
+        self,
+        event_idx: int,
+        id_to_tag: Optional[Dict[int, str]] = None
+    ) -> Set[str]:
+        """Return tags for an event"""
+        if not self._loaded or id_to_tag is None:
+            return set()
+
+        if event_idx < 0 or event_idx >= self.num_events:
+            return set()
+
+        start = self._event_tag_indptr[event_idx]
+        end = self._event_tag_indptr[event_idx + 1]
+        tag_ids = self._event_tag_indices[start:end]
+
+        return {id_to_tag[int(tid)] for tid in tag_ids if int(tid) in id_to_tag}
+
+
+class PartitionMetadata:
+    """
+    Metadata for partition files
+
+    Reference: NAIA2.0/ui/remote/quick_search_tab.py metadata loading
+    """
+
+    MAGIC = b'TGPS'
+
+    def __init__(self):
+        self.tag_to_id: Dict[str, int] = {}
+        self.id_to_tag: Dict[int, str] = {}
+        self.tag_freq: Dict[str, int] = {}
+        self.partitions: Dict[str, Dict] = {}
+        self._loaded: bool = False
+
+    @classmethod
+    def load(cls, input_path: str) -> 'PartitionMetadata':
+        """Load metadata file"""
+        meta = cls()
+
+        with open(input_path, 'rb') as f:
+            magic = f.read(4)
+            if magic != cls.MAGIC:
+                raise ValueError(f"Invalid metadata format: {magic}")
+
+            _ = struct.unpack('<H', f.read(2))[0]  # version
+            compressed_len = struct.unpack('<I', f.read(4))[0]
+            compressed = f.read(compressed_len)
+
+        serialized = lzma.decompress(compressed)
+        data = pickle.loads(serialized)
+
+        meta.tag_to_id = data.get('tag_to_id', {})
+        meta.id_to_tag = data.get('id_to_tag', {})
+        meta.tag_freq = data.get('tag_freq', {})
+        meta.partitions = data.get('partitions', {})
+        meta._loaded = True
+
+        return meta
+
+    @property
+    def is_loaded(self) -> bool:
+        return self._loaded
+
+    def get_partition_names(self) -> List[str]:
+        """Return list of available partition names"""
+        return list(self.partitions.keys())
+
+
+class PartitionManager:
+    """
+    Manages partition loading and caching
+    """
+
+    def __init__(self):
+        self._metadata: Optional[PartitionMetadata] = None
+        self._loaded_partitions: Dict[str, SinglePartitionStore] = {}
+        self._data_dir = DATA_DIR
+
+    def is_data_available(self) -> bool:
+        """Check if partition data files are available"""
+        metadata_path = self._data_dir / "metadata.tgpm"
+        return metadata_path.exists()
+
+    def load_metadata(self) -> Optional[PartitionMetadata]:
+        """Load partition metadata"""
+        if self._metadata is not None:
+            return self._metadata
+
+        metadata_path = self._data_dir / "metadata.tgpm"
+        if not metadata_path.exists():
+            return None
+
+        try:
+            self._metadata = PartitionMetadata.load(str(metadata_path))
+            return self._metadata
+        except Exception as e:
+            print(f"Error loading metadata: {e}")
+            return None
+
+    def get_metadata(self) -> Optional[PartitionMetadata]:
+        """Get loaded metadata (load if needed)"""
+        if self._metadata is None:
+            self.load_metadata()
+        return self._metadata
+
+    def load_partition(self, partition_name: str) -> Optional[SinglePartitionStore]:
+        """Load a specific partition"""
+        if partition_name in self._loaded_partitions:
+            return self._loaded_partitions[partition_name]
+
+        partition_path = self._data_dir / f"{partition_name}.tgp"
+        if not partition_path.exists():
+            print(f"Partition file not found: {partition_path}")
+            return None
+
+        try:
+            store = SinglePartitionStore.load(str(partition_path))
+            self._loaded_partitions[partition_name] = store
+            return store
+        except Exception as e:
+            print(f"Error loading partition {partition_name}: {e}")
+            return None
+
+    def unload_partition(self, partition_name: str):
+        """Unload a partition to free memory"""
+        if partition_name in self._loaded_partitions:
+            del self._loaded_partitions[partition_name]
+
+    def unload_all(self):
+        """Unload all partitions"""
+        self._loaded_partitions.clear()
+
+    def get_partition_filename(self, rating: str, person: str) -> str:
+        """
+        Get partition filename from rating and person category
+
+        Args:
+            rating: 'g', 's', 'q', or 'e'
+            person: person category like '1girl_solo'
+
+        Returns:
+            Partition name like 'g_1girl_solo'
+        """
+        return f"{rating}_{person}"

data/tag_store.py

@@ -0,0 +1,319 @@
+"""
+NAIA-WEB Tag Store
+High-level interface for tag search and Quick Search functionality
+
+Reference: NAIA2.0/ui/remote/quick_search_tab.py
+"""
+
+import random
+from typing import List, Optional, Set, Tuple
+from dataclasses import dataclass
+from collections import Counter
+
+from .partition_loader import PartitionManager, SinglePartitionStore, PartitionMetadata
+from utils.constants import PERSON_AUTO_TAGS
+
+
+@dataclass
+class TagInfo:
+    """Information about a single tag"""
+    tag: str
+    count: int
+
+
+@dataclass
+class QuickSearchResult:
+    """Result of a quick search operation"""
+    success: bool
+    prompt: str = ""
+    tags: List[str] = None
+    event_count: int = 0
+    error_message: str = ""
+
+    def __post_init__(self):
+        if self.tags is None:
+            self.tags = []
+
+
+class TagStore:
+    """
+    High-level interface for Quick Search functionality.
+
+    Provides:
+    - Partition loading and management
+    - Tag filtering by rating and person category
+    - Include/Exclude tag filtering
+    - Random event sampling for prompt generation
+    - Tag frequency information
+    """
+
+    def __init__(self):
+        self._manager = PartitionManager()
+        self._current_partition: Optional[SinglePartitionStore] = None
+        self._current_partition_name: str = ""
+
+    def is_available(self) -> bool:
+        """Check if tag data is available"""
+        return self._manager.is_data_available()
+
+    def get_available_partitions(self) -> List[str]:
+        """Get list of available partition names"""
+        metadata = self._manager.get_metadata()
+        if metadata is None:
+            return []
+        return metadata.get_partition_names()
+
+    def load_partition(self, rating: str, person: str) -> bool:
+        """
+        Load partition for given rating and person category.
+
+        Args:
+            rating: 'g', 's', 'q', or 'e'
+            person: Person category like '1girl_solo'
+
+        Returns:
+            True if loaded successfully
+        """
+        partition_name = self._manager.get_partition_filename(rating, person)
+
+        if partition_name == self._current_partition_name and self._current_partition is not None:
+            return True  # Already loaded
+
+        # Unload previous partition to save memory
+        if self._current_partition_name:
+            self._manager.unload_partition(self._current_partition_name)
+
+        partition = self._manager.load_partition(partition_name)
+        if partition is None:
+            self._current_partition = None
+            self._current_partition_name = ""
+            return False
+
+        self._current_partition = partition
+        self._current_partition_name = partition_name
+        return True
+
+    def get_event_count(self) -> int:
+        """Get number of events in current partition"""
+        if self._current_partition is None:
+            return 0
+        return self._current_partition.num_events
+
+    def get_filtered_event_count(
+        self,
+        include_tags: Optional[List[str]] = None,
+        exclude_tags: Optional[List[str]] = None
+    ) -> int:
+        """Get number of events matching filter criteria"""
+        if self._current_partition is None:
+            return 0
+
+        metadata = self._manager.get_metadata()
+        if metadata is None:
+            return 0
+
+        filtered = self._current_partition.filter_events(
+            required_tags=include_tags,
+            excluded_tags=exclude_tags,
+            tag_to_id=metadata.tag_to_id
+        )
+
+        return len(filtered)
+
+    def get_top_tags(
+        self,
+        include_tags: Optional[List[str]] = None,
+        exclude_tags: Optional[List[str]] = None,
+        limit: int = 50,
+        offset: int = 0
+    ) -> List[TagInfo]:
+        """
+        Get most frequent tags in current partition with filters applied.
+
+        Returns tags sorted by frequency (descending).
+        """
+        if self._current_partition is None:
+            return []
+
+        metadata = self._manager.get_metadata()
+        if metadata is None:
+            return []
+
+        # Filter events
+        filtered_indices = self._current_partition.filter_events(
+            required_tags=include_tags,
+            excluded_tags=exclude_tags,
+            tag_to_id=metadata.tag_to_id
+        )
+
+        if len(filtered_indices) == 0:
+            return []
+
+        # Count tags in filtered events
+        tag_counts = self._current_partition.get_tag_counts(
+            event_indices=filtered_indices,
+            id_to_tag=metadata.id_to_tag
+        )
+
+        # Exclude already included/excluded tags from results
+        excluded_set = set(include_tags or []) | set(exclude_tags or [])
+
+        # Sort by count and return with pagination
+        sorted_tags = sorted(
+            [(tag, count) for tag, count in tag_counts.items() if tag not in excluded_set],
+            key=lambda x: x[1],
+            reverse=True
+        )[offset:offset + limit]
+
+        return [TagInfo(tag=tag, count=count) for tag, count in sorted_tags]
+
+    def get_total_tag_count(
+        self,
+        include_tags: Optional[List[str]] = None,
+        exclude_tags: Optional[List[str]] = None
+    ) -> int:
+        """Get total number of unique tags matching filter criteria"""
+        if self._current_partition is None:
+            return 0
+
+        metadata = self._manager.get_metadata()
+        if metadata is None:
+            return 0
+
+        # Filter events
+        filtered_indices = self._current_partition.filter_events(
+            required_tags=include_tags,
+            excluded_tags=exclude_tags,
+            tag_to_id=metadata.tag_to_id
+        )
+
+        if len(filtered_indices) == 0:
+            return 0
+
+        # Count tags in filtered events
+        tag_counts = self._current_partition.get_tag_counts(
+            event_indices=filtered_indices,
+            id_to_tag=metadata.id_to_tag
+        )
+
+        # Exclude already included/excluded tags
+        excluded_set = set(include_tags or []) | set(exclude_tags or [])
+        return len([tag for tag in tag_counts.keys() if tag not in excluded_set])
+
+    def generate_random_prompt(
+        self,
+        rating: str,
+        person: str,
+        include_tags: Optional[List[str]] = None,
+        exclude_tags: Optional[List[str]] = None
+    ) -> QuickSearchResult:
+        """
+        Generate a random prompt from the partition.
+
+        Args:
+            rating: Rating code ('g', 's', 'q', 'e')
+            person: Person category
+            include_tags: Tags that must be present
+            exclude_tags: Tags that must not be present
+
+        Returns:
+            QuickSearchResult with generated prompt
+        """
+        # Load partition
+        if not self.load_partition(rating, person):
+            return QuickSearchResult(
+                success=False,
+                error_message=f"Failed to load partition: {rating}_{person}"
+            )
+
+        metadata = self._manager.get_metadata()
+        if metadata is None:
+            return QuickSearchResult(
+                success=False,
+                error_message="Metadata not available"
+            )
+
+        # Get auto-tags for person category
+        auto_tags = PERSON_AUTO_TAGS.get(person, [])
+
+        # Combine include tags with auto tags
+        all_include = list(set((include_tags or []) + auto_tags))
+
+        # Filter events
+        filtered_indices = self._current_partition.filter_events(
+            required_tags=all_include if all_include else None,
+            excluded_tags=exclude_tags,
+            tag_to_id=metadata.tag_to_id
+        )
+
+        if len(filtered_indices) == 0:
+            return QuickSearchResult(
+                success=False,
+                error_message="No events match the filter criteria",
+                event_count=0
+            )
+
+        # Select random event
+        random_idx = random.choice(filtered_indices)
+
+        # Get tags for this event
+        event_tags = self._current_partition.get_event_tags(
+            event_idx=int(random_idx),
+            id_to_tag=metadata.id_to_tag
+        )
+
+        if not event_tags:
+            return QuickSearchResult(
+                success=False,
+                error_message="Failed to get tags for selected event"
+            )
+
+        # Convert to list and create prompt
+        tags_list = sorted(list(event_tags))
+        prompt = ", ".join(tags_list)
+
+        return QuickSearchResult(
+            success=True,
+            prompt=prompt,
+            tags=tags_list,
+            event_count=len(filtered_indices)
+        )
+
+    def search_tags(
+        self,
+        query: str,
+        limit: int = 20
+    ) -> List[TagInfo]:
+        """
+        Search for tags matching query string.
+
+        Args:
+            query: Search query (partial match)
+            limit: Maximum results
+
+        Returns:
+            List of matching tags with frequencies
+        """
+        metadata = self._manager.get_metadata()
+        if metadata is None or not query:
+            return []
+
+        query_lower = query.lower()
+
+        # Find matching tags
+        matches = []
+        for tag, freq in metadata.tag_freq.items():
+            if query_lower in tag.lower():
+                matches.append(TagInfo(tag=tag, count=freq))
+
+        # Sort by frequency and return top N
+        matches.sort(key=lambda x: x.count, reverse=True)
+        return matches[:limit]
+
+    def get_partition_info(self) -> dict:
+        """Get information about current partition"""
+        return {
+            "partition_name": self._current_partition_name,
+            "event_count": self.get_event_count(),
+            "is_loaded": self._current_partition is not None
+        }