Coverage for deluge/ui/console/modes/format_utils : 0%

# -*- coding: utf-8 -*- 

# 

# Copyright (C) 2011 Nick Lanham <nick@afternight.org> 

# 

# This file is part of Deluge and is licensed under GNU General Public License 3.0, or later, with 

# the additional special exception to link portions of this program with the OpenSSL library. 

# See LICENSE for more details. 

# 

import re 

from collections import deque 

from unicodedata import normalize as ud_normalize 

from unicodedata import east_asian_width 

import deluge.common 

def format_speed(speed): 

    if (speed > 0): 

        return deluge.common.fspeed(speed) 

    else: 

        return "-" 

def format_time(time): 

    if (time > 0): 

        return deluge.common.ftime(time) 

    else: 

        return "-" 

def format_date(time): 

    if (time > 0): 

        return deluge.common.fdate(time) 

    else: 

        return "" 

def format_date_never(time): 

    if (time > 0): 

        return deluge.common.fdate(time) 

    else: 

        return "Never" 

def format_float(x): 

    if x < 0: 

        return "-" 

    else: 

        return "%.3f" % x 

def format_seeds_peers(num, total): 

    return "%d (%d)" % (num, total) 

def format_progress(perc): 

    if perc < 100: 

        return "%.2f%%" % perc 

    else: 

        return "100%" 

def format_pieces(num, size): 

    return "%d (%s)" % (num, deluge.common.fsize(size)) 

def format_priority(prio): 

    if prio == - 2: 

        return "[Mixed]" 

    if prio < 0: 

        return "-" 

    pstring = deluge.common.FILE_PRIORITY[prio] 

    if prio > 0: 

        return pstring[:pstring.index("Priority") - 1] 

    else: 

        return pstring 

def trim_string(string, w, have_dbls): 

    if w <= 0: 

        return "" 

    elif w == 1: 

        return u" " 

    elif have_dbls: 

        # have to do this the slow way 

        chrs = [] 

        width = 4 

        idx = 0 

        while width < w: 

            chrs.append(string[idx]) 

            if east_asian_width(string[idx]) in ["W", "F"]: 

                width += 2 

            else: 

                width += 1 

            idx += 1 

        if width != w: 

            chrs.pop() 

            chrs.append(".") 

        return u"%s " % ("".join(chrs)) 

    else: 

        return u"%s " % (string[0:w - 1]) 

def format_column(col, lim): 

    dbls = 0 

    # Chosen over isinstance(col, unicode) and col.__class__ == unicode 

    # for speed - it's ~3 times faster for non-unicode strings and ~1.5 

    # for unicode strings. 

    if col.__class__ is unicode: 

        # might have some double width chars 

        col = ud_normalize("NFC", col) 

        dbls = sum(east_asian_width(c) in "WF" for c in col) 

    size = len(col) + dbls 

    if (size >= lim - 1): 

        return trim_string(col, lim, dbls > 0) 

    else: 

        return "%s%s" % (col, " " * (lim - size)) 

def format_row(row, column_widths): 

    return "".join([format_column(row[i], column_widths[i]) for i in range(0, len(row))]) 

_strip_re = re.compile("\{!.*?!\}") 

def remove_formatting(string): 

    return re.sub(_strip_re, "", string) 

def wrap_string(string, width, min_lines=0, strip_colors=True): 

    """ 

    Wrap a string to fit in a particular width.  Returns a list of output lines. 

    :param string: str, the string to wrap 

    :param width: int, the maximum width of a line of text 

    :param min_lines: int, extra lines will be added so the output tuple contains at least min_lines lines 

    :param strip_colors: boolean, if True, text in {!!} blocks will not be considered as adding to the 

                              width of the line.  They will still be present in the output. 

    """ 

    ret = [] 

    s1 = string.split("\n") 

    def insert_clr(s, offset, mtchs, clrs): 

        end_pos = offset + len(s) 

        while mtchs and (mtchs[0] <= end_pos) and (mtchs[0] >= offset): 

            mtc = mtchs.popleft() - offset 

            clr = clrs.popleft() 

            end_pos += len(clr) 

            s = "%s%s%s" % (s[:mtc], clr, s[mtc:]) 

        return s 

    for s in s1: 

        offset = 0 

        if strip_colors: 

            mtchs = deque() 

            clrs = deque() 

            for m in _strip_re.finditer(s): 

                mtchs.append(m.start()) 

                clrs.append(m.group()) 

            cstr = _strip_re.sub("", s) 

        else: 

            cstr = s 

        while len(cstr) > width: 

            sidx = cstr.rfind(" ", 0, width - 1) 

            sidx += 1 

            if sidx > 0: 

                if strip_colors: 

                    to_app = cstr[0:sidx] 

                    to_app = insert_clr(to_app, offset, mtchs, clrs) 

                    ret.append(to_app) 

                    offset += len(to_app) 

                else: 

                    ret.append(cstr[0:sidx]) 

                cstr = cstr[sidx:] 

                if not cstr: 

                    cstr = None 

                    break 

            else: 

                # can't find a reasonable split, just split at width 

                if strip_colors: 

                    to_app = cstr[0:width] 

                    to_app = insert_clr(to_app, offset, mtchs, clrs) 

                    ret.append(to_app) 

                    offset += len(to_app) 

                else: 

                    ret.append(cstr[0:width]) 

                cstr = cstr[width:] 

                if not cstr: 

                    cstr = None 

                    break 

        if cstr is not None: 

            if strip_colors: 

                ret.append(insert_clr(cstr, offset, mtchs, clrs)) 

            else: 

                ret.append(cstr) 

    if min_lines > 0: 

        for i in range(len(ret), min_lines): 

            ret.append(" ") 

    # Carry colors over to the next line 

    last_color_string = "" 

    for i, line in enumerate(ret): 

        if i != 0: 

            ret[i] = "%s%s" % (last_color_string, ret[i]) 

        colors = re.findall("\\{![^!]+!\\}", line) 

        if colors: 

            last_color_string = colors[-1] 

    return ret 

def strwidth(string): 

    """ 

    Measure width of a string considering asian double width characters 

    """ 

    if not isinstance(string, unicode): 

        string = unicode(string, "utf-8") 

    return sum([1 + (east_asian_width(char) in ["W", "F"]) for char in string]) 

def pad_string(string, length, character=" ", side="right"): 

    """ 

    Pad string with specified character to desired length, considering double width characters. 

    """ 

    w = strwidth(string) 

    diff = length - w 

    if side == "left": 

        return "%s%s" % (character * diff, string) 

    elif side == "right": 

        return "%s%s" % (string, character * diff)