Modularize custom symbols to tqdm_custom

lrq3000 · lrq3000 · commit a433ef4ddebc · 2016-08-26T20:49:50.000+02:00
Signed-off-by: Stephen L. &lt;lrq3000@gmail.com&gt;
diff --git a/tqdm/__init__.py b/tqdm/__init__.py
@@ -2,13 +2,15 @@
 from ._tqdm import trange
 from ._tqdm_gui import tqdm_gui
 from ._tqdm_gui import tgrange
+from ._tqdm_custom import tqdm_custom
+from ._tqdm_custom import tcrange
 from ._tqdm_pandas import tqdm_pandas
 from ._main import main
 from ._version import __version__  # NOQA
 from ._tqdm import TqdmTypeError, TqdmKeyError, TqdmDeprecationWarning
 
 __all__ = ['tqdm', 'tqdm_gui', 'trange', 'tgrange', 'tqdm_pandas',
-           'tqdm_notebook', 'tnrange', 'main',
+           'tqdm_notebook', 'tnrange', 'tqdm_custom', 'tcrange', 'main',
            'TqdmTypeError', 'TqdmKeyError', 'TqdmDeprecationWarning',
            '__version__']
 
diff --git a/tqdm/_tqdm.py b/tqdm/_tqdm.py
@@ -121,7 +121,7 @@ def print_status(s):
     @staticmethod
     def format_meter(n, total, elapsed, ncols=None, prefix='',
                      ascii=False, unit='it', unit_scale=False, rate=None,
-                     bar_format=None, custom_symbols=None):
+                     bar_format=None):
         """
         Return a string-based progress bar given some parameters
 
@@ -251,47 +251,15 @@ def format_meter(n, total, elapsed, ncols=None, prefix='',
             N_BARS = max(1, ncols - len(l_bar) - len(r_bar)) if ncols \
                 else 10
 
-            # custom symbols format
-            # need to provide both ascii and unicode versions of custom symbols
-            if custom_symbols:
-                # get ascii or unicode template
-                if ascii:
-                    c_symb = custom_symbols[1]
-                else:
-                    c_symb = custom_symbols[2]
-                # looping symbols: just update the symbol animation at each iteration
-                if custom_symbols[0] == 'loop':
-                    # increment one step in the animation at each step
-                    bar = c_symb[divmod(n, len(c_symb))[1]]
-                    frac_bar = ''
-
-                    bar_length = N_BARS  # avoid the filling
-                    frac_bar_length = len(frac_bar)
-                # normal progress symbols
-                else:
-                    nb_symb = len(c_symb)
-                    len_filler = len(c_symb[-1])
-                    bar_length, frac_bar_length = divmod(
-                        int((frac/len_filler) * N_BARS * nb_symb), nb_symb)
-
-                    bar = c_symb[-1] * bar_length  # last symbol is always the filler
-                    frac_bar = c_symb[frac_bar_length] if frac_bar_length \
-                        else ' '
-                    # update real bar length (if symbols > 1 char) for correct filler
-                    bar_length = bar_length * len_filler
-
-            # ascii format
-            elif ascii:
-                # get the remainder of the division of current fraction with number of symbols
-                # this will tell us which symbol we should pick
+            # format bar depending on availability of unicode/ascii chars
+            if ascii:
                 bar_length, frac_bar_length = divmod(
                     int(frac * N_BARS * 10), 10)
 
                 bar = '#' * bar_length
                 frac_bar = chr(48 + frac_bar_length) if frac_bar_length \
                     else ' '
 
-            # unicode format (if available)
             else:
                 bar_length, frac_bar_length = divmod(int(frac * N_BARS * 8), 8)
 
@@ -302,7 +270,7 @@ def format_meter(n, total, elapsed, ncols=None, prefix='',
             # whitespace padding
             if bar_length < N_BARS:
                 full_bar = bar + frac_bar + \
-                    ' ' * max(N_BARS - bar_length - len(frac_bar), 0)
+                    ' ' * max(N_BARS - bar_length - 1, 0)
             else:
                 full_bar = bar + \
                     ' ' * max(N_BARS - bar_length, 0)
@@ -610,46 +578,6 @@ def __init__(self, iterable=None, desc=None, total=None, leave=True,
         if ascii is None:
             ascii = not _supports_unicode(file)
 
-
-        # Custom symbols extraction
-        custom_symbols = None
-        if bar_format:
-            looping = None
-            c_symbols_ascii = None
-            c_symbols_unicode = None
-            found_tag = False
-            for tag in ['bar_symbols', 'bar_symbols_ascii', 'bar_symbols_loop', 'bar_symbols_loop_ascii']:
-                start_tag = '{' + tag + '}'
-                end_tag = '{/' + tag + '}'
-                # Check if tag is found in the template
-                if start_tag in bar_format and end_tag in bar_format:
-                    found_tag = True
-                    # Extract custom symbols enclosed by tags, with the first character being the separator.
-                    # Eg, extract_symbols('before{start},1,2,3,4,#{end}after', '{start}', '{end}')
-                    start = bar_format.find(start_tag)
-                    start_content = start+len(start_tag)
-                    end_content = bar_format.find(end_tag)
-                    end = end_content+len(end_tag)
-                    sep = bar_format[start_content:start_content+1]
-                    c_symbols = bar_format[start_content+1:end_content].split(sep)
-                    # Cleanup all weird tags from bar_format else .format() crash
-                    bar_format = bar_format[:start] + bar_format[end:]
-
-                    if 'ascii' in tag:
-                        c_symbols_ascii = c_symbols
-                    else:
-                        c_symbols_unicode = c_symbols
-
-                    # Looping symbol?
-                    if 'loop' in tag:
-                        looping = True
-                    else:
-                        looping = False
-
-            # Compile the ascii/unicode bars in a nice argument for format_meter
-            if found_tag:
-                custom_symbols = ['loop' if looping else 'bar', c_symbols_ascii, c_symbols_unicode]
-
         if bar_format and not ascii:
             # Convert bar format into unicode since terminal uses unicode
             bar_format = _unicode(bar_format)
@@ -678,7 +606,6 @@ def __init__(self, iterable=None, desc=None, total=None, leave=True,
         self.avg_time = None
         self._time = time
         self.bar_format = bar_format
-        self.custom_symbols = custom_symbols
 
         # Init the iterations counters
         self.last_print_n = initial
@@ -695,8 +622,7 @@ def __init__(self, iterable=None, desc=None, total=None, leave=True,
                 self.moveto(self.pos)
             self.sp(self.format_meter(self.n, total, 0,
                     (dynamic_ncols(file) if dynamic_ncols else ncols),
-                    self.desc, ascii, unit, unit_scale, None,
-                    bar_format, custom_symbols))
+                    self.desc, ascii, unit, unit_scale, None, bar_format))
             if self.pos:
                 self.moveto(-self.pos)
 
@@ -723,8 +649,7 @@ def __repr__(self):
                                  time() - self.last_print_t,
                                  self.ncols, self.desc, self.ascii, self.unit,
                                  self.unit_scale, 1 / self.avg_time
-                                 if self.avg_time else None,
-                                 self.bar_format, self.custom_symbols)
+                                 if self.avg_time else None, self.bar_format)
 
     def __lt__(self, other):
         # try:
@@ -781,7 +706,6 @@ def __iter__(self):
             smoothing = self.smoothing
             avg_time = self.avg_time
             bar_format = self.bar_format
-            custom_symbols = self.custom_symbols
             _time = self._time
             format_meter = self.format_meter
 
@@ -820,8 +744,7 @@ def __iter__(self):
                             (dynamic_ncols(self.fp) if dynamic_ncols
                              else ncols),
                             self.desc, ascii, unit, unit_scale,
-                            1 / avg_time if avg_time else None,
-                            bar_format, custom_symbols))
+                            1 / avg_time if avg_time else None, bar_format))
 
                         if self.pos:
                             self.moveto(-self.pos)
@@ -907,7 +830,7 @@ def update(self, n=1):
                      else self.ncols),
                     self.desc, self.ascii, self.unit, self.unit_scale,
                     1 / self.avg_time if self.avg_time else None,
-                    self.bar_format, self.custom_symbols))
+                    self.bar_format))
 
                 if self.pos:
                     self.moveto(-self.pos)
@@ -974,7 +897,7 @@ def fp_write(s):
                     (self.dynamic_ncols(self.fp) if self.dynamic_ncols
                      else self.ncols),
                     self.desc, self.ascii, self.unit, self.unit_scale, None,
-                    self.bar_format, self.custom_symbols))
+                    self.bar_format))
             if pos:
                 self.moveto(-pos)
             else:
diff --git a/tqdm/_tqdm_custom.py b/tqdm/_tqdm_custom.py
