manga/profile.py

   1 import os
   2 pj = os.path.join
   3
   4 home = os.getenv("HOME")
   5 if home is None or not os.path.isdir(home):
   6     raise Exception("Could not find home directory for profile keeping")
   7 confdir = pj(home, ".manga")
   8 basedir = pj(confdir, "profiles")
   9
  10 class txfile(object):
  11     def __init__(self, name, mode):
  12         self.realname = name
  13         self.tempname = name + ".new"
  14         self.bk = open(self.tempname, mode)
  15
  16     def close(self, abort=False):
  17         self.bk.close()
  18         if abort:
  19             os.unlink(self.tempname)
  20         else:
  21             os.rename(self.tempname, self.realname)
  22
  23     def read(self, sz=-1):
  24         return self.bk.read(sz)
  25
  26     def write(self, data):
  27         return self.bk.write(data)
  28
  29     def __enter__(self):
  30         return self
  31
  32     def __exit__(self, *exc_info):
  33         if exc_info[0] is not None:
  34             self.close(True)
  35         else:
  36             self.close(False)
  37
  38 def openwdir(nm, mode="r"):
  39     ft = open
  40     if mode == "W":
  41         mode = "w"
  42         ft = txfile
  43     if os.path.exists(nm):
  44         return ft(nm, mode)
  45     if mode != "r":
  46         d = os.path.dirname(nm)
  47         if not os.path.isdir(d):
  48             os.makedirs(d)
  49     return ft(nm, mode)
  50
  51 def splitline(line):
  52     def bsq(c):
  53         if c == "\\": return "\\"
  54         elif c == '"': return '"'
  55         elif c == " ": return " "
  56         elif c == "n": return "\n"
  57         else: return ""
  58     ret = []
  59     p = 0
  60     buf = ""
  61     a = False
  62     while p < len(line):
  63         c = line[p]
  64         if c.isspace():
  65             p += 1
  66         else:
  67             while p < len(line):
  68                 c = line[p]
  69                 p += 1
  70                 if c == '"':
  71                     a = True
  72                     while p < len(line):
  73                         c = line[p]
  74                         p += 1
  75                         if c == '"':
  76                             break
  77                         elif c == "\\" and p < len(line):
  78                             buf += bsq(line[p])
  79                             p += 1
  80                         else:
  81                             buf += c
  82                 elif c.isspace():
  83                     ret.append(buf)
  84                     buf = ""
  85                     a = False
  86                     break
  87                 elif c == "\\" and p < len(line):
  88                     buf += bsq(line[p])
  89                     p += 1
  90                 else:
  91                     buf += c
  92     if a or buf != "":
  93         ret.append(buf)
  94     return ret
  95
  96 def splitlines(fp):
  97     for line in fp:
  98         cur = splitline(line)
  99         if len(cur) < 1:
 100             continue
 101         yield cur
 102
 103 def consline(*words):
 104     buf = ""
 105     for w in words:
 106         if any((c == "\\" or c == '"' or c == "\n" for c in w)):
 107             wb = ""
 108             for c in w:
 109                 if c == "\\": wb += "\\\\"
 110                 elif c == '"': wb += '\\"'
 111                 elif c == "\n": wb += "\\n"
 112                 else: wb += c
 113             w = wb
 114         if w == "" or any((c.isspace() for c in w)):
 115             w = '"' + w + '"'
 116         if buf != "":
 117             buf += " "
 118         buf += w
 119     return buf
 120
 121 class manga(object):
 122     def __init__(self, profile, libnm, id):
 123         self.profile = profile
 124         self.libnm = libnm
 125         self.id = id
 126         self.props = self.loadprops()
 127
 128     def open(self):
 129         from . import lib
 130         return lib.findlib(self.libnm).byid(self.id)
 131
 132     def save(self):
 133         pass
 134
 135 class memmanga(manga):
 136     def __init__(self, profile, libnm, id):
 137         super(memmanga, self).__init__(profile, libnm, id)
 138
 139     def loadprops(self):
 140         return {}
 141
 142 class tagview(object):
 143     def __init__(self, manga):
 144         self.manga = manga
 145         self.profile = manga.profile
 146
 147     def add(self, *tags):
 148         mt = self.getall(self.profile)
 149         ctags = mt.setdefault((self.manga.libnm, self.manga.id), set())
 150         ctags |= set(tags)
 151         self.save(self.profile, mt)
 152
 153     def remove(self, *tags):
 154         mt = self.getall(self.profile)
 155         ctags = mt.get((self.manga.libnm, self.manga.id), set())
 156         ctags -= set(tags)
 157         if len(ctags) < 1:
 158             try:
 159                 del mt[self.manga.libnm, self.manga.id]
 160             except KeyError:
 161                 pass
 162         self.save(self.profile, mt)
 163
 164     def __iter__(self):
 165         return iter(self.getall(self.profile).get((self.manga.libnm, self.manga.id), set()))
 166
 167     @staticmethod
 168     def getall(profile):
 169         ret = {}
 170         try:
 171             with profile.file("tags") as fp:
 172                 for words in splitlines(fp):
 173                     libnm, id = words[0:2]
 174                     tags = set(words[2:])
 175                     ret[libnm, id] = tags
 176         except IOError:
 177             pass
 178         return ret
 179
 180     @staticmethod
 181     def save(profile, m):
 182         with profile.file("tags", "W") as fp:
 183             for (libnm, id), tags in m.items():
 184                 fp.write(consline(libnm, id, *tags) + "\n")
 185
 186     @staticmethod
 187     def bytag(profile, tag):
 188         try:
 189             with profile.file("tags") as fp:
 190                 for words in splitlines(fp):
 191                     libnm, id = words[0:2]
 192                     tags = words[2:]
 193                     if tag in tags:
 194                         yield profile.getmanga(libnm, id)
 195         except IOError:
 196             pass
 197
 198 class filemanga(manga):
 199     def __init__(self, profile, libnm, id, path):
 200         self.path = path
 201         super(filemanga, self).__init__(profile, libnm, id)
 202         self.tags = tagview(self)
 203
 204     def loadprops(self):
 205         ret = {}
 206         with openwdir(self.path) as f:
 207             for words in splitlines(f):
 208                 if words[0] == "set" and len(words) > 2:
 209                     ret[words[1]] = words[2]
 210                 elif words[0] == "lset" and len(words) > 1:
 211                     ret[words[1]] = words[2:]
 212         return ret
 213
 214     def save(self):
 215         with openwdir(self.path, "W") as f:
 216             for key, val in self.props.items():
 217                 if isinstance(val, str):
 218                     f.write(consline("set", key, val) + "\n")
 219                 else:
 220                     f.write(consline("lset", key, *val) + "\n")
 221
 222 class profile(object):
 223     def __init__(self, dir):
 224         self.dir = dir
 225         self.name = None
 226
 227     def getmapping(self):
 228         seq = 0
 229         ret = {}
 230         if os.path.exists(pj(self.dir, "map")):
 231             with openwdir(pj(self.dir, "map")) as f:
 232                 for words in splitlines(f):
 233                     if words[0] == "seq" and len(words) > 1:
 234                         try:
 235                             seq = int(words[1])
 236                         except ValueError:
 237                             pass
 238                     elif words[0] == "manga" and len(words) > 3:
 239                         try:
 240                             ret[words[1], words[2]] = int(words[3])
 241                         except ValueError:
 242                             pass
 243         return seq, ret
 244
 245     def savemapping(self, seq, m):
 246         with openwdir(pj(self.dir, "map"), "W") as f:
 247             f.write(consline("seq", str(seq)) + "\n")
 248             for (libnm, id), num in m.items():
 249                 f.write(consline("manga", libnm, id, str(num)) + "\n")
 250
 251     def getmanga(self, libnm, id, creat=False):
 252         seq, m = self.getmapping()
 253         if (libnm, id) in m:
 254             return filemanga(self, libnm, id, pj(self.dir, "%i.manga" % m[(libnm, id)]))
 255         if not creat:
 256             raise KeyError("no such manga: (%s, %s)" % (libnm, id))
 257         while True:
 258             try:
 259                 fp = openwdir(pj(self.dir, "%i.manga" % seq), "x")
 260             except IOError:
 261                 seq += 1
 262             else:
 263                 break
 264         fp.close()
 265         m[(libnm, id)] = seq
 266         self.savemapping(seq, m)
 267         return filemanga(self, libnm, id, pj(self.dir, "%i.manga" % seq))
 268
 269     def setlast(self):
 270         if self.name is None:
 271             raise ValueError("profile at " + self.dir + " has no name")
 272         with openwdir(pj(basedir, "last"), "W") as f:
 273             f.write(self.name + "\n")
 274
 275     def getaliases(self):
 276         ret = {}
 277         if os.path.exists(pj(self.dir, "alias")):
 278             with openwdir(pj(self.dir, "alias")) as f:
 279                 for ln in f:
 280                     ln = splitline(ln)
 281                     if len(ln) < 1: continue
 282                     if ln[0] == "alias" and len(ln) > 3:
 283                         ret[ln[1]] = ln[2], ln[3]
 284         return ret
 285
 286     def savealiases(self, map):
 287         with openwdir(pj(self.dir, "alias"), "W") as f:
 288             for nm, (libnm, id) in map.items():
 289                 f.write(consline("alias", nm, libnm, id) + "\n")
 290
 291     def file(self, name, mode="r"):
 292         return openwdir(pj(self.dir, name), mode)
 293
 294     def getalias(self, nm):
 295         return self.getaliases()[nm]
 296
 297     def setalias(self, nm, libnm, id):
 298         aliases = self.getaliases()
 299         aliases[nm] = libnm, id
 300         self.savealiases(aliases)
 301
 302     def bytag(self, tag):
 303         return tagview.bytag(self, tag)
 304
 305     @classmethod
 306     def byname(cls, name):
 307         if not name or name == "last" or name[0] == '.':
 308             raise KeyError("invalid profile name: " + name)
 309         ret = cls(pj(basedir, name))
 310         ret.name = name
 311         return ret
 312
 313     @classmethod
 314     def last(cls):
 315         if not os.path.exists(pj(basedir, "last")):
 316             raise KeyError("there is no last used profile")
 317         with open(pj(basedir, "last")) as f:
 318             return cls.byname(f.readline().strip())