99 lines
2.7 KiB
Python
99 lines
2.7 KiB
Python
# Copyright 2021 (c) Anna Schumaker.
|
|
from . import publisher
|
|
from . import tag
|
|
import threading
|
|
|
|
class TagStore:
|
|
def __init__(self):
|
|
self.store = dict()
|
|
self.lock = threading.Lock()
|
|
self.Added = publisher.Publisher()
|
|
self.Removed = publisher.Publisher()
|
|
|
|
def __add_tag__(self, name, sort, track):
|
|
t = self.__get_tag__(name, sort)
|
|
if track:
|
|
t.add_track(track)
|
|
return t
|
|
|
|
def __alloc_tag__(self, name, sort):
|
|
return tag.Tag(name, sort)
|
|
|
|
def __getitem__(self, name):
|
|
with self.lock:
|
|
return self.store.get(name)
|
|
|
|
def __getstate__(self):
|
|
with self.lock:
|
|
return { "store" : self.store }
|
|
|
|
def __get_tag__(self, name, sort):
|
|
with self.lock:
|
|
if (t := self.store.get(name)) != None:
|
|
return t
|
|
t = self.__alloc_tag__(name, sort)
|
|
self.store[name] = t
|
|
self.Added.publish(t)
|
|
return t
|
|
|
|
def __len__(self):
|
|
with self.lock:
|
|
return len(self.store)
|
|
|
|
def __pop_tag__(self, t):
|
|
self.store.pop(t.name)
|
|
|
|
def __setstate__(self, state):
|
|
self.store = state["store"]
|
|
self.lock = threading.Lock()
|
|
self.Added = publisher.Publisher()
|
|
self.Removed = publisher.Publisher()
|
|
|
|
def add(self, name, track=None, sort=None):
|
|
return self.__add_tag__(name.strip(), sort, track)
|
|
|
|
def init_track(self, name, track):
|
|
with self.lock:
|
|
if (t := self.store.get(name)) != None:
|
|
t.init_track(track)
|
|
return t
|
|
|
|
def remove(self, t, track=None):
|
|
if track:
|
|
t.remove_track(track)
|
|
if (track == None or len(t) == 0) and t in self.store.values():
|
|
with self.lock:
|
|
self.__pop_tag__(t)
|
|
self.Removed.publish(t)
|
|
|
|
def reset(self):
|
|
with self.lock:
|
|
self.store.clear()
|
|
self.Added.reset()
|
|
self.Removed.reset()
|
|
|
|
def tags(self):
|
|
with self.lock:
|
|
for (name, tag) in self.store.items():
|
|
yield tag
|
|
|
|
|
|
class TagSuperStore(TagStore):
|
|
def __alloc_tag__(self, key, sort):
|
|
return tag.SuperTag(key[0], key[1], sort)
|
|
|
|
def __pop_tag__(self, t):
|
|
self.store.pop((t.parent, t.name))
|
|
|
|
def add(self, parent, name, track, sort=None):
|
|
return super().__add_tag__((parent, name.strip()), sort, track)
|
|
|
|
def init_track(self, parent, name, track):
|
|
return super().init_track((parent, name), track)
|
|
|
|
def tags(self, parent=None):
|
|
with self.lock:
|
|
for (name, tag) in self.store.items():
|
|
if parent == None or tag.parent == parent:
|
|
yield tag
|