def system_info():
    viewer_log_file = "/tmp/screenly_viewer.log"
    if path.exists(viewer_log_file):
        viewlog = check_output(["tail", "-n", "20", viewer_log_file]).split("\n")
    else:
        viewlog = ["(no viewer log present -- is only the screenly server running?)\n"]

    # Get load average from last 15 minutes and round to two digits.
    loadavg = round(getloadavg()[2], 2)

    try:
        run_tvservice = check_output(["tvservice", "-s"])
        display_info = re_split("\||,", run_tvservice.strip("state:"))
    except:
        display_info = False

    # Calculate disk space
    slash = statvfs("/")
    free_space = size(slash.f_bavail * slash.f_frsize)

    # Get uptime
    uptime_in_seconds = uptime()
    system_uptime = timedelta(seconds=uptime_in_seconds)

    return template(
        "system_info",
        viewlog=viewlog,
        loadavg=loadavg,
        free_space=free_space,
        uptime=system_uptime,
        display_info=display_info,
    )

def system_info():
    viewer_log_file = '/tmp/sync_viewer.log'
    if path.exists(viewer_log_file):
        viewlog = check_output(['tail', '-n', '20', viewer_log_file]).split('\n')
    else:
        viewlog = ["(no viewer log present -- is only the sync server running?)\n"]

    # Get load average from last 15 minutes and round to two digits.
    loadavg = round(getloadavg()[2], 2)

    try:
        run_tvservice = check_output(['tvservice', '-s'])
        display_info = re_split('\||,', run_tvservice.strip('state:'))
    except:
        display_info = False

    # Calculate disk space
    slash = statvfs("/")
    free_space = size(slash.f_bavail * slash.f_frsize)

    # Get uptime
    uptime_in_seconds = uptime()
    system_uptime = timedelta(seconds=uptime_in_seconds)

    return template('system_info', viewlog=viewlog, loadavg=loadavg, free_space=free_space, uptime=system_uptime, display_info=display_info)

def google_tts(text, tl='en', ip_addr=None):
    """
    this function is adapted from https://github.com/hungtruong/Google-Translate-TTS, thanks @hungtruong.
    """
	#process text into chunks
    text = text.replace('\n','')
    text_list = re_split('(\,|\.)', text)
    combined_text = []
    for idx, val in enumerate(text_list):
        if idx % 2 == 0:
            combined_text.append(val)
        else:
            joined_text = ''.join((combined_text.pop(),val))
            if len(joined_text) < 100:
                combined_text.append(joined_text)
            else:
                subparts = re_split('( )', joined_text)
                temp_string = ""
                temp_array = []
                for part in subparts:
                    temp_string = temp_string + part
                    if len(temp_string) > 80:
                        temp_array.append(temp_string)
                        temp_string = ""
                #append final part
                temp_array.append(temp_string)
                combined_text.extend(temp_array)
    #download chunks and write them to the output file
    f = NamedTemporaryFile(delete=False)
    host = ip_addr if ip_addr else "translate.google.com"
    headers = {"Host":"translate.google.com",
      "Referer":"http://www.gstatic.com/translate/sound_player2.swf",
      "User-Agent":"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/37.0.2062.94 Safari/537.36"}
    for idx, val in enumerate(combined_text):
        mp3url = "http://%s/translate_tts?tl=%s&q=%s&total=%s&idx=%s" % (host, tl, quote(val), len(combined_text), idx)
        req = Request(mp3url, headers=headers)
        if len(val) > 0:
            try:
                response = urlopen(req)
                f.write(response.read())
            except HTTPError as e:
                pass
    f.close()
    system('afplay {0}'.format(f.name))
    unlink(f.name)

 def archive(self):
     factoids = re_split(r'( or |\|)', self.info)[::2]
     formatted_info = "\n\n{} recorded on {} that {} is:\n* ".format(self.controller.config.get('server', 'nick'), datetime.today().date(), self.waiting) + "\n* ".join(factoids)
     try:
         page_url = self.append_page(formatted_info)
         self.controller.client.reply(self.requester[1], self.requester[0], "Done! {} -- I didn't delete the bot entry, just to be safe; please make sure I copied everything right, then do so.".format(page_url))
     except ResourceNotFoundError:
         self.controller.client.reply(self.requester[1], self.requester[0], "Sorry, that wiki page doesn't exist yet.")
     self.clear()

    def findWords(self, string):
        from re import compile as re_compile, split as re_split

        pattern = re_compile("\b?\w+\b")
        matches = re_split(pattern, string)
        if matches:
            return matches[0].split(" ")
        else:
            raise ValueError("%s did not have any recognizable single words" + " in the filename" % string)

 def get_features(self, source):
     """
     Feature extraction from text. The point where you can customize features.
     source - opened file
     return feature set, iterable object
     """
     words = []
     for line in source:
         if self.kind_of_partition == 'word':
             words.extend([word
                           for word in re_split('[\s,.:;!?<>+="()%\-0-9d]', line.decode("utf-8").lower().encode("utf-8"))
                           if word and (not self.est_words or word in self.est_words)
                           and word not in self.stopwords])
                           # not is_bad(word.decode("utf-8"))])
         elif self.kind_of_partition == 'ngram':
             for word in re_split('[\s,.:;!?<>+="()%\-]', line.decode("utf-8").lower().encode("utf-8")):
                 if word and word not in self.stopwords and word not in self.stopwords:
                     words.extend(re_findall('.{1,%d}' % self.ngram, word))
     return words

def convertHHMMtoSec(hhmm):
    vals = re_split(":", hhmm)
    if len(vals) == 2:
        h, m = vals[0], vals[1]
        s = 0
    elif len(vals) == 3:
        h, m, s = vals[0], vals[1], vals[2]
    else:
        raise Exception("not well formatted time string")
    return float(timedelta(hours=int(h), minutes=int(m), seconds=int(s)).total_seconds())

def linebreaksbrpre(str):
  # pre부분만 빼고...전부 바꿔주자.
  splited = re_split('</pre>',str)
  # 맨 마지막꺼 빼고 앞부분은 전부 <pre가 있는거렷다.
  lastStr = splited.pop()
  ret = []
  for splited_str in splited:
    # 여기서 앞부분것들만 pre에 적용을 안 받는 녀석들이다.
    pre_splited = re_split('<pre',splited_str)
    ret.append(linebreaksbr(pre_splited[0]))
    ret.append("<pre")
    if (len(pre_splited) > 1):
      split_content = pre_splited[1].split('>', 1)
    ret.append(split_content[0])  # <pre ~~~> 뒷부분
    ret.append('>')
    if (len(split_content) > 1):
      ret.append(split_content[1].replace("<", "&lt;").replace('>', '&gt;'))  # <pre>~~~</pre> 내용
    ret.append("</pre>")
  ret.append(linebreaksbr(lastStr))
  return "".join(ret)

    def deserialize(cls, string):
        result = {}
        for line in string.split("\n"):
            if line == '':
                continue

            _, key, value, _ = re_split("(?<=[^\\\])/", line)
            key = cls._escape_filename(key.strip(), True)
            value = cls._escape_filename(value.strip(), True)
            result[key] = value
        return result

 def parse_line(cls, line, create=True, **kwargs):
     tags = []
     for possible_tag in re_split('[,\s]+', line):
         tag = cls.get_by_name(
             possible_tag.lower(),
             create=create,
             **kwargs
         )
         if tag:
             tags.append(tag)
     return tags

def _format(storage, string, pattern, padding):
    # Split content by lines and leading indentation
    linedata = iter(re_split(pattern, string))
    # Add first line to content
    storage.append(_LONG*' ' + next(linedata))
    # For each padding and content of line
    for space, data in zip(linedata, linedata):
        # Normalise leading padding if necessary
        indent = len(space) - padding
        storage.append((_LONG + (indent if indent > 0 else 0))*' ' + data)
    # If last line of comment has no new line at the end, append one
    if not storage[-1].endswith('\n'):
        storage[-1] += '\n'

 def read(self, delay=0):
     """
     read one command from SNAP system
     """
     sleep(delay)
     stderr.write("___________READ___________\n")
     line = self.process.stdout.readline()
     read = line
     while read != "X\n":
         stderr.write("INFO:" + read)
         line = read
         read = self.process.stdout.readline()
     # stderr.write("HERE:" + str(re_split(r"[\n ]+",line)[0]) + "/end")
     return re_split(r"[\n ]+", line)[0]

def checksum(sentence):
    """ Calculate the checksum for a sentence (e.g. NMEA string). """

    result = {'checksum':None}
    # Remove any newlines
    if re_search("\n$", sentence):
        sentence = sentence[:-1]

    nmeadata,cksum = re_split('\*', sentence)

    calc_cksum = 0
    for s in nmeadata:
        calc_cksum ^= ord(s)

    # Return the nmeadata, the checksum from sentence, and the calculated checksum
    result['checksum'] = hex(calc_cksum)[2:].upper()
    return result

 def handle(self):
     self._logger.debug('handle')
     request = self.request.recv(MAX_REQUEST_SIZE)        
     if request:
         self._logger.debug('request of size %d (%s)'%(len(request), b2a.hexlify(request[:8])))
         args = re_split(self.string_separator, request[1:]) #TODO-3 ??? figure out way to use self.string_separator(should work now)
         command = unpack('>b', request[0])[0]
         method = self.server._command_set.get(command)
         if method:
             response = self.server._command_set[command](*args)
         else:
             self._logger.error('no such command word %d!'%command)
             response = pack('>b', -1)
     else:
         self._logger.error('null packet received!')
         response = pack('>b', -2)
     self.request.send(response)

    def readHitsTBL(self):
        """Look for the next hit in tblout format, package and return"""
        """
We expect line to look like:
NODE_110054_length_1926_cov_24.692627_41_3 -          Ribosomal_S9         PF00380.14   5.9e-48  158.7   0.0   6.7e-48  158.5   0.0   1.0   1   0   0   1   1   1   1 # 1370 # 1756 # 1 # ID=41_3;partial=00;start_type=ATG;rbs_motif=None;rbs_spacer=None
        """
        while (1):
            line = self.handle.readline().rstrip()
            try:
                if line[0] != '#' and len(line) != 0:
                    dMatch = re_split( r'\s+', line.rstrip() )
                    if len(dMatch) < 19:
                        raise FormatError( "Something is wrong with this line:\n%s" % (line) )
                    refined_match = dMatch[0:18] + [" ".join([str(i) for i in dMatch[18:]])]
                    return HmmerHitTBL(refined_match)
            except IndexError:
                return {}

    def readHitsDOM(self):
        """Look for the next hit in domtblout format, package and return"""
        """
We expect the line to look like:
NODE_925902_length_6780_cov_18.428171_754_2 -            399 PGK                  PF00162.14   384  2.2e-164  543.7   0.1   1   1  1.3e-167  2.5e-164  543.5   0.1     1   384     9   386     9   386 1.00 # 1767 # 2963 # -1 # ID=754_2;partial=00;start_type=ATG;rbs_motif=AGGA;rbs_spacer=5-10bp
        """
        while (1):
            line = self.handle.readline().rstrip()
            try:
                if line[0] != '#' and len(line) != 0:
                    dMatch = re_split( r'\s+', line.rstrip() )
                    if len(dMatch) < 23:
                        raise FormatError( "Something is wrong with this line:\n%s" % (line) )
                    refined_match = dMatch[0:22] + [" ".join([str(i) for i in dMatch[22:]])]
                    return HmmerHitDOM(refined_match)
            except IndexError:
                return {}

 def post(self):
     origin_json = jsonLoads(self.request.body)
     sql_table = 'id, username'
     sql_key = origin_json.keys()[0] or 'username'
     sql_keyword = '%' + origin_json.values()[0] + '%'
     print sql_keyword
     sql_dict = dict(tables = sql_table, 
                     key = sql_key, 
                     keyword = sql_keyword)
     sql = self.forms['radcheck']['select_user']
     sql_context = sql % sql_dict
     origin_data = yield Task(self.db.select, sql_context)
     table_name = re_split(', ', sql_table)
     user_list = map(lambda x: dict(map(lambda z,d: (d,z), 
                              x,table_name)), origin_data)
     the_data = { "userlist": user_list,
                  "tables_name": table_name}
     self.write(convJson(the_data))

    def parse_line(cls, line, create=True, **kwargs):
        tags = []
        seen = set()
        for possible_tag in re_split('[,\s]+', line):
            possible_tag = possible_tag.lower()

            if possible_tag in seen:
                continue
            else:
                seen.add(possible_tag)

            tag = cls.get_by_name(
                possible_tag,
                create=create,
                **kwargs
            )
            if tag:
                tags.append(tag)
        return tags

 def episode_parser(value):
     values = re_split('[a-zA-Z]', value)
     values = [x for x in values if x]
     ret = []
     for letters_elt in values:
         dashed_values = letters_elt.split('-')
         dashed_values = [x for x in dashed_values if x]
         if len(dashed_values) > 1:
             for _ in range(0, len(dashed_values) - 1):
                 start_dash_ep = parse_numeral(dashed_values[0])
                 end_dash_ep = parse_numeral(dashed_values[1])
                 for dash_ep in range(start_dash_ep, end_dash_ep + 1):
                     ret.append(dash_ep)
         else:
             ret.append(parse_numeral(letters_elt))
     if len(ret) > 1:
         return {None: ret[0], 'episodeList': ret}  # TODO: Should support seasonList also
     elif len(ret) > 0:
         return ret[0]
     else:
         return None

def _get_pubs_per_year_dictionary(pubyearslist):
    '''
    Returns a dict consisting of: year -> number of publications in that year (given a personID).
    @param person_id: int personid
    @return [{'year':no_of_publications}, bool]
    '''
    yearsdict = {}
    for _, years in pubyearslist:
        year_list = []
        for date in years['year_fields']:
            try:
                year_list.append(int(re_split(year_pattern, date[0])[1]))
            except IndexError:
                continue

        if year_list:
            min_year = min(year_list)
            try:
                yearsdict[min_year] += 1
            except KeyError:
                yearsdict[min_year] = 1

    return yearsdict