i dont know what you mean by scope so i'll leave that to you

#!/usr/bin/python3
import re
import time
import logging
import html.parser
import urllib.request
import mysql.connector
from urllib.error import HTTPError
from multiprocessing.dummy import Pool
from MultiDict import OrderedMultiDict
from functools import reduce

config_mysql = {
    'user'      : 'ed',
    'host'      : '127.0.0.1',
    'database'  : 'ed'
}

ch = 1
idd = -1
idm = -1
oldd = ''
oldm = ''
dbg = ' #'
lastpush = 0;

def passed(s):
    s = time.time() - s;
    while (s > 1700):
        s -= 3600
    while (s < -1700):
        s += 3600
    return s

if __name__ == '__main__':
    mc = mysql.connector.connect(**config_mysql)
    while True:
        while lastpush > 0 and passed(lastpush) < 30:
            time.sleep(0.25)
        lastpush = time.time()
        exec_update(mc)

def exec_update(mc):
    doit = False
    st = get_status()
    n = AsyncListeners()
    n.relay_list = [
        ('http://stream1.r-a-d.io:1130/','/radio.ogg'),
        ('http://stream2.r-a-d.io:1130/','/relay.mp3'),
        ('http://stream3.r-a-d.io:1130/','/relay.mp3')
    ]
    relayclients = n.async_get_all_listener_count()
    meta = fixmeta(st['/main.mp3']['Current Song'])
    listeners = st['/main.mp3']['Current Listeners']
    q = (
        "select di, ti,                             "
        "   timestampdiff(second, t2, now()) sec    "
        "from np                                    "
        "where ch = '%s'                            "
        "order by id desc                           "
        "limit 1                                    ")
    with mc.cursor() as cur:
        cur.execute(q, (ch,))
        for (di, ti, sec) in cur:
            idd, idm = di, ti
            doit = sec > 300 or sec < 50
    doit = doit or idd < 0
    if not doit:
        print("stacking_queue")
        return
    if idd >= 0:
        q = (
            "select v from npd                      "
            "where i = '%s' limit 1                 ")
        with mc.cursor() as cur:
            cur.execute(q, (idd,))
            for (v,) in cur:
                oldd = v
    if idm >= 0:
        q = (
            "select v from npm                      "
            "where i = '%s' limit 1                 ")
        with mc.cursor() as cur:
            cur.execute(q, (idm,))
            for (v,) in cur:
                oldm = v
    if re.match('^[0-9]*$', listeners):
        q = (
            "insert into npl values                 "
            "   ('', now(), '%s', '%s')             ")
        with mc.cursor() as cur:
            cur.execute(q, (listeners, relayclients))
    else:
        print("assert_listeners_numeric")
        return
    if meta.lower() == oldm.lower():
        q = (
            "update np                              "
            "set t2=now()                           "
            "where ch = '%s'                        "
            "order by id desc                       "
            "limit 1                                ")
        with mc.cursor() as cur:
            cur.execute(q, (ch,))
        print("meta_unchanged/{}:{}".format
            (listeners, relayclients))
        return
    else:
        print("-- ({})".format(oldm))
        print("-- ({})".format(meta))

    idm = -1
    q = (
        "select i from npm                          "
        "where v = '%s' limit 1                     ")
    with mc.cursor() as cur:
        cur.execute(q, (meta,))
        for (i) in cur:
            idm = i
    if idm < 0:
        q = (
            "insert into npm values                 "
            "   ('', '%s')                          ")
        with mc.cursor() as cur:
            cur.execute(q, (meta,))
            idm = cur.lastrowid

    idd = -1
    q = (
        "select i from npd                          "
        "where v = '%s' limit 1                     ")
    with mc.cursor() as cur:
        cur.execute(q, (dj,))
        for (i) in cur:
            idd = i
    if idd < 0:
        q = (
            "insert into npd values                 "
            "   ('', '%s')                          ")
        with mc.cursor() as cur:
            cur.execute(q, (dj,))
            idd = cur.lastrowid

    if idm < 0:
        print("assert_idm_gt_0")
        return
    if idd < 0:
        print("assert_idd_gt_0")
        return
    q = (
        "insert into np values                      "
        "   ('', now(), now(), '%s', '%s', '%s')    ")
    penis = -1
    with mc.cursor() as cur:
        cur.execute(q, (ch, idm, idd))
        penis = cur.lastrowid
    print("np_dj{}_meta{}_{}/{}:{}".format
        (idd, idm, penis, listeners, relayclients))


def get_listener_count(
      server = 'http://stream0.r-a-d.io:1130',
       mount = "/main.mp3",
     timeout = None
    ):
    try:
        request = urllib.request.Request(server, headers = {'User-Agent' : 'Mozilla'})
        result = urllib.request.urlopen(request, timeout = timeout)
    except:
        logging.debug('HTTP access fault: ' + server_name);
        #raise
    else:
        incoming = result.read().decode('utf8').split('\n')
        parser = StatusParser()
        for line in incoming:
            parser.feed(line)
        parser.close()
        result = parser.result
        if mount in result:
            if 'Current Listeners' in result[mount]:
                listeners = int(result[mount]['Current Listeners'])
                return listeners
        else:
            logging.debug('Server does not have listener count: ' + server_name)
            return -1
    logging.debug('Failed to fetch  ' + server_name)
    return -1


class AsyncListeners(object):
    relay_list = []
    timeout = 10.0
    def __init__(self, threads = 5):
        super(AsyncListeners, self).__init__()
        self.pool = Pool(threads)
    def async_get_all_listener_count(self, timeout = 10.0):
        result_list = []
        counts, timer = 0, 0.0
        for relay, mount in self.relay_list:
            result_list.append(self.pool.apply_async(
                get_listener_count,
                kwds = {
                    'server'  : relay,
                    'timeout' : timeout,
                    'mount'   : mount
                }))
            #print(result_list)
        while True:
            if len(result_list) == 0:
                break
            for result in result_list[:]:
                if result.ready():
                    if result.successful():
                        counts += result.get()
                        result_list.remove(result)
                        #print("LOL " + result)
                    else:
                        print("oh shit")
                #else:
                    # nothing yet
                    #print(result)
            timer += 0.5
            if timer > self.timeout:
                break
            time.sleep(0.5)
        return counts


def get_status(icecast_server = 'http://stream0.r-a-d.io:1130/'):
    try:
        request = urllib.request.Request(icecast_server,
            headers = { 'User-Agent' : 'Mozilla' })
        result = urllib.request.urlopen(request)
    except HTTPError as e:
        if e.code == 403: #full server
            logging.warning("Listener limit reached? " + icecast_server)
            f = OrderedMultiDict()
            f['Stream Title'] = 'r/a/dio'
            f['Current Listeners'] = '500'
            f['Current Song'] = 'py'
            return { '/main.mp3' : f }
        else:
            logging.exception("HTTPError " + e.code + " in status fetch")
    except:
        logging.exception("Connection to status page failed")
    else:
        incoming = result.read().decode('utf8').split('\n')
        parser = StatusParser()
        for line in incoming:
            parser.feed(line)
        parser.close()
        result = parser.result
#       if '/main.mp3' in result:
#           all_listeners = get_all_listener_count()
#           total_count = reduce(lambda x,y:
#               x+y if x > 0 and y > 0 else x,
#               list(all_listeners.values()))
#           result[config.icecast_mount]['Current Listeners'] = str(total_count)
        return parser.result or {}
    return {}


class StatusParser(html.parser.HTMLParser):
    def __init__(self):
        html.parser.HTMLParser.__init__(self)
        self._current_mount = None
        self.result = {}
        self._td = False
        self._mount = False
        self._enter = False
    def handle_starttag(self, tag, attrs):
        attrs = OrderedMultiDict(attrs)
        if (tag == "td"):
            self._td = Tag(attrs)
            self._td['class'] = None
        elif (tag == "h3") and (self._td):
            self._mount = Tag(attrs)
    def handle_endtag(self, tag):
        if (tag == "td"):
            self._td = None
        elif (tag == "h3") and (self._td):
            self._mount = None
        elif (tag == "table") and (self._current_mount):
            if (self._enter):
                self._enter = False
            else:
                self._enter = True
    def handle_data(self, data):
        if (self._mount) and (self._td):
            self._current_mount = data.split(" ")[2]
            self.result[self._current_mount] = OrderedMultiDict()
        elif (self._enter) and (self._td) and (self._current_mount):
            if ("streamdata" in self._td.getall("class")):
                self.result[self._current_mount][self._type] = data
            else:
                self._type = data[:-1]


class Tag(object):
    attr = OrderedMultiDict()
    def __init__(self, attrs):
        self.attr = attrs
    def __getattr__(self, name):
        return getattr(self.attr, name)
    def __setitem__(self, name, value):
        self.attr[name] = value

def fixmeta(meta):
    meta = meta.encode('iso_8859-1')
    try:
        try:
            meta = meta.decode('utf-8', 'strict')
        except (UnicodeDecodeError):
            meta = meta.decode('sjis', 'xmlcharrefreplace')
    except (TypeError):
        meta = meta.strip()
    return meta

# http://dev.mysql.com/doc/connector-python/en/myconnpy_example_connecting.html