acmecer: Accept "pending" challenge status after submission.

[utils.git] / ann.py

import os, hashlib, urllib.request, time, re, weakref
from urllib.parse import urljoin, urlencode
import bs4
soup = lambda cont: bs4.BeautifulSoup(cont, "html.parser")

__all__ = ["anime", "getlist",
           "error", "incompatible"]

base = "http://www.animenewsnetwork.com/encyclopedia/"

class error(Exception):
    pass

class incompatible(error):
    def __init__(self):
        super().__init__("ANN HTML has changed")

try:
    cachedir = os.path.join(os.getenv("HOME"), ".ann", "cache")
    if not os.path.isdir(cachedir):
        os.makedirs(cachedir)
except:
    cachedir = None

def cachename(url):
    if not cachedir:
        return None
    d = hashlib.md5()
    d.update(url.encode("ascii"))
    return os.path.join(cachedir, d.hexdigest())

def get(url):
    data = None
    cachefile = cachename(url)
    if cachefile and os.path.exists(cachefile):
        if time.time() - os.stat(cachefile).st_mtime < 86400:
            with open(cachefile, "rb") as fp:
                data = fp.read()
    if data is None:
        with urllib.request.urlopen(url) as fp:
            data = fp.read()
        if cachefile:
            co = open(cachefile, "wb")
            try:
                co.write(data)
            finally:
                co.close()
    return soup(data)

def s(s, rx, rep):
    m = re.search(rx, s, re.I)
    if m:
        return s[:m.start()] + rep + s[m.end():]
    else:
        return s

def afind(soup, *args, **kwargs):
    ret = soup.find(*args, **kwargs)
    if ret is None:
        raise incompatible()
    return ret

def cstr(soup):
    if isinstance(soup, bs4.Tag) or isinstance(soup, list):
        ret = ""
        for el in soup:
            ret += cstr(el)
        return ret
    elif isinstance(soup, str):
        return soup
    elif soup is None:
        return None
    else:
        return soup.string

class cproperty(object):
    _default = object()

    def __init__(self, bk):
        self.bk = bk
        self.cache = weakref.WeakKeyDictionary()

    def __get__(self, ins, cls):
        if ins is None: return self
        ret = self.cache.get(ins, self._default)
        if ret is self._default:
            ret = self.bk(ins)
            self.cache[ins] = ret
        return ret

    def __set__(self, ins, val):
        self.cache[ins] = val

    def __delete__(self, ins):
        if ins in self.cache:
            del self.cache[ins]

class anime(object):
    def __init__(self, id):
        self.id = id
        self.url = urljoin(base, "anime.php?id=%i" % self.id)

    @cproperty
    def _page(self):
        return get(self.url)

    @cproperty
    def _main(self):
        return afind(self._page, "div", id="maincontent")

    def _info(self, nm):
        for t in afind(self._main, "div", id="content-zone")("div", "encyc-info-type"):
            if t.strong and t.strong.text.lower().strip()[:-1] == nm:
                return t.contents[t.contents.index(t.strong) + 1:]

    @cproperty
    def rawname(self):
        return afind(self._main, "h1", id="page_header").text
    _nre = re.compile(r"^(.*\S)\s+\(([^\)]+)\)$")
    @cproperty
    def _sname(self):
        m = self._nre.search(self.rawname)
        if not m:
            return (self.rawname, None)
        return m.groups()[0:2]
    @property
    def name(self): return self._sname[0]
    @property
    def type(self): return self._sname[1]

    @cproperty
    def names(self):
        ret = []
        for el in self._info("alternative title"):
            if isinstance(el, bs4.Tag) and el.name == "div" and "tab" in el.get("class", []):
                m = self._nre.search(el.text)
                if m:
                    ret.append((m.groups()[0], m.groups()[1]))
                else:
                    ret.append((el.text, None))
        if (self.name, None) in ret:
            ret.remove((self.name, None))
        ret.insert(0, (self.name, None))
        return ret

    @cproperty
    def eps(self):
        ret = cstr(self._info("number of episodes"))
        if ret is None:
            return ret
        return int(ret)

    @cproperty
    def vintage(self):
        return cstr(self._info("vintage")).strip()

    @cproperty
    def genres(self):
        return [cstr(el) for x in (self._info("genres") or []) if isinstance(x, bs4.Tag) for el in x.findAll("a")]

    @cproperty
    def themes(self):
        return [cstr(el) for x in (self._info("themes") or []) if isinstance(x, bs4.Tag) for el in x.findAll("a")]

    def __repr__(self):
        return "<ann.anime: %r (%i)>" % (self.name, self.id)

    def __str__(self):
        return self.name

    @classmethod
    def byid(cls, id):
        return cls(id)

linkpat = re.compile("^/encyclopedia/anime\\.php\\?id=(\d+)$")
def getlist(name):
    name = s(name, "^(the|a)\s+", "")
    if len(name) < 1:
        raise error("list() needs a prefix of at least one character")
    fc = name[0]
    if 'a' <= fc <= 'z' or 'A' <= fc <= 'Z':
        fc = fc.upper()
    else:
        fc = '9'
    d = get(urljoin(base, "anime.php?" + urlencode({"list": fc})))
    ret = []
    ldiv = afind(afind(d, "div", id="maincontent"), "div", "lst")
    for link in ldiv("a", "HOVERLINE"):
        rawname = ""
        for el in link.font:
            if isinstance(el, str):
                rawname += el.strip()
        mn = rawname.lower()
        mn = s(mn, "^a\s+", "")
        mn = mn.replace("\u014d", "ou")
        mn = mn.replace("\u016b", "uu")
        if mn.lower().startswith(name.lower()):
            m = linkpat.match(link["href"])
            if not m:
                raise incompatible()
            found = anime.byid(int(m.groups()[0]))
            found.rawname = rawname
            ret.append(found)
    return ret