remove commented-out format code

Author: jepler

jepler_udecimal/__init__.py

@@ -5402,246 +5402,6 @@ def _int(x):
 _exact_half = re.compile("50*$").match
 del re
 
-### ##### PEP3101 support functions ##############################################
-### # The functions in this section have little to do with the Decimal
-### # class, and could potentially be reused or adapted for other pure
-### # Python numeric classes that want to implement __format__
-### #
-### # A format specifier for Decimal looks like:
-### #
-### #   [[fill]align][sign][#][0][minimumwidth][,][.precision][type]
-###
-### _parse_format_specifier_regex = re.compile(r"""\A
-### (?:
-###    (?P<fill>.)?
-###    (?P<align>[<>=^])
-### )?
-### (?P<sign>[-+ ])?
-### (?P<alt>\#)?
-### (?P<zeropad>0)?
-### (?P<minimumwidth>(?!0)\d+)?
-### (?P<thousands_sep>,)?
-### (?:\.(?P<precision>0|(?!0)\d+))?
-### (?P<type>[eEfFgGn%])?
-### \Z
-### """, re.VERBOSE|re.DOTALL)
-
-
-### def _parse_format_specifier(format_spec, _localeconv=None):
-###     """Parse and validate a format specifier.
-###
-###     Turns a standard numeric format specifier into a dict, with the
-###     following entries:
-###
-###       fill: fill character to pad field to minimum width
-###       align: alignment type, either '<', '>', '=' or '^'
-###       sign: either '+', '-' or ' '
-###       minimumwidth: nonnegative integer giving minimum width
-###       zeropad: boolean, indicating whether to pad with zeros
-###       thousands_sep: string to use as thousands separator, or ''
-###       grouping: grouping for thousands separators, in format
-###         used by localeconv
-###       decimal_point: string to use for decimal point
-###       precision: nonnegative integer giving precision, or None
-###       type: one of the characters 'eEfFgG%', or None
-###
-###     """
-###     m = _parse_format_specifier_regex.match(format_spec)
-###     if m is None:
-###         raise ValueError("Invalid format specifier: " + format_spec)
-###
-###     # get the dictionary
-###     format_dict = m.groupdict()
-###
-###     # zeropad; defaults for fill and alignment.  If zero padding
-###     # is requested, the fill and align fields should be absent.
-###     fill = format_dict['fill']
-###     align = format_dict['align']
-###     format_dict['zeropad'] = (format_dict['zeropad'] is not None)
-###     if format_dict['zeropad']:
-###         if fill is not None:
-###             raise ValueError("Fill character conflicts with '0'"
-###                              " in format specifier: " + format_spec)
-###         if align is not None:
-###             raise ValueError("Alignment conflicts with '0' in "
-###                              "format specifier: " + format_spec)
-###     format_dict['fill'] = fill or ' '
-###     # PEP 3101 originally specified that the default alignment should
-###     # be left;  it was later agreed that right-aligned makes more sense
-###     # for numeric types.  See http://bugs.python.org/issue6857.
-###     format_dict['align'] = align or '>'
-###
-###     # default sign handling: '-' for negative, '' for positive
-###     if format_dict['sign'] is None:
-###         format_dict['sign'] = '-'
-###
-###     # minimumwidth defaults to 0; precision remains None if not given
-###     format_dict['minimumwidth'] = int(format_dict['minimumwidth'] or '0')
-###     if format_dict['precision'] is not None:
-###         format_dict['precision'] = int(format_dict['precision'])
-###
-###     # if format type is 'g' or 'G' then a precision of 0 makes little
-###     # sense; convert it to 1.  Same if format type is unspecified.
-###     if format_dict['precision'] == 0:
-###         if format_dict['type'] is None or format_dict['type'] in 'gGn':
-###             format_dict['precision'] = 1
-###
-###     # determine thousands separator, grouping, and decimal separator, and
-###     # add appropriate entries to format_dict
-###     if format_dict['type'] == 'n':
-###         # apart from separators, 'n' behaves just like 'g'
-###         format_dict['type'] = 'g'
-###         if _localeconv is None:
-###             _localeconv = _locale.localeconv()
-###         if format_dict['thousands_sep'] is not None:
-###             raise ValueError("Explicit thousands separator conflicts with "
-###                              "'n' type in format specifier: " + format_spec)
-###         format_dict['thousands_sep'] = _localeconv['thousands_sep']
-###         format_dict['grouping'] = _localeconv['grouping']
-###         format_dict['decimal_point'] = _localeconv['decimal_point']
-###     else:
-###         if format_dict['thousands_sep'] is None:
-###             format_dict['thousands_sep'] = ''
-###         format_dict['grouping'] = [3, 0]
-###         format_dict['decimal_point'] = '.'
-###
-###     return format_dict
-###
-### def _format_align(sign, body, spec):
-###     """Given an unpadded, non-aligned numeric string 'body' and sign
-###     string 'sign', add padding and alignment conforming to the given
-###     format specifier dictionary 'spec' (as produced by
-###     parse_format_specifier).
-###
-###     """
-###     # how much extra space do we have to play with?
-###     minimumwidth = spec['minimumwidth']
-###     fill = spec['fill']
-###     padding = fill*(minimumwidth - len(sign) - len(body))
-###
-###     align = spec['align']
-###     if align == '<':
-###         result = sign + body + padding
-###     elif align == '>':
-###         result = padding + sign + body
-###     elif align == '=':
-###         result = sign + padding + body
-###     elif align == '^':
-###         half = len(padding)//2
-###         result = padding[:half] + sign + body + padding[half:]
-###     else:
-###         raise ValueError('Unrecognised alignment field')
-###
-###     return result
-###
-### def _group_lengths(grouping):
-###     """Convert a localeconv-style grouping into a (possibly infinite)
-###     iterable of integers representing group lengths.
-###
-###     """
-###     # The result from localeconv()['grouping'], and the input to this
-###     # function, should be a list of integers in one of the
-###     # following three forms:
-###     #
-###     #   (1) an empty list, or
-###     #   (2) nonempty list of positive integers + [0]
-###     #   (3) list of positive integers + [locale.CHAR_MAX], or
-###
-###     from itertools import chain, repeat
-###     if not grouping:
-###         return []
-###     elif grouping[-1] == 0 and len(grouping) >= 2:
-###         return chain(grouping[:-1], repeat(grouping[-2]))
-###     elif grouping[-1] == _locale.CHAR_MAX:
-###         return grouping[:-1]
-###     else:
-###         raise ValueError('unrecognised format for grouping')
-###
-### def _insert_thousands_sep(digits, spec, min_width=1):
-###     """Insert thousands separators into a digit string.
-###
-###     spec is a dictionary whose keys should include 'thousands_sep' and
-###     'grouping'; typically it's the result of parsing the format
-###     specifier using _parse_format_specifier.
-###
-###     The min_width keyword argument gives the minimum length of the
-###     result, which will be padded on the left with zeros if necessary.
-###
-###     If necessary, the zero padding adds an extra '0' on the left to
-###     avoid a leading thousands separator.  For example, inserting
-###     commas every three digits in '123456', with min_width=8, gives
-###     '0,123,456', even though that has length 9.
-###
-###     """
-###
-###     sep = spec['thousands_sep']
-###     grouping = spec['grouping']
-###
-###     groups = []
-###     for l in _group_lengths(grouping):
-###         if l <= 0:
-###             raise ValueError("group length should be positive")
-###         # max(..., 1) forces at least 1 digit to the left of a separator
-###         l = min(max(len(digits), min_width, 1), l)
-###         groups.append('0'*(l - len(digits)) + digits[-l:])
-###         digits = digits[:-l]
-###         min_width -= l
-###         if not digits and min_width <= 0:
-###             break
-###         min_width -= len(sep)
-###     else:
-###         l = max(len(digits), min_width, 1)
-###         groups.append('0'*(l - len(digits)) + digits[-l:])
-###     return sep.join(reversed(groups))
-###
-### def _format_sign(is_negative, spec):
-###     """Determine sign character."""
-###
-###     if is_negative:
-###         return '-'
-###     elif spec['sign'] in ' +':
-###         return spec['sign']
-###     else:
-###         return ''
-###
-### def _format_number(is_negative, intpart, fracpart, exp, spec):
-###     """Format a number, given the following data:
-###
-###     is_negative: true if the number is negative, else false
-###     intpart: string of digits that must appear before the decimal point
-###     fracpart: string of digits that must come after the point
-###     exp: exponent, as an integer
-###     spec: dictionary resulting from parsing the format specifier
-###
-###     This function uses the information in spec to:
-###       insert separators (decimal separator and thousands separators)
-###       format the sign
-###       format the exponent
-###       add trailing '%' for the '%' type
-###       zero-pad if necessary
-###       fill and align if necessary
-###     """
-###
-###     sign = _format_sign(is_negative, spec)
-###
-###     if fracpart or spec['alt']:
-###         fracpart = spec['decimal_point'] + fracpart
-###
-###     if exp != 0 or spec['type'] in 'eE':
-###         echar = {'E': 'E', 'e': 'e', 'G': 'E', 'g': 'e'}[spec['type']]
-###         fracpart += "{0}{1:+}".format(echar, exp)
-###     if spec['type'] == '%':
-###         fracpart += '%'
-###
-###     if spec['zeropad']:
-###         min_width = spec['minimumwidth'] - len(fracpart) - len(sign)
-###     else:
-###         min_width = 0
-###     intpart = _insert_thousands_sep(intpart, spec, min_width)
-###
-###     return _format_align(sign, intpart+fracpart, spec)
-###
-###
 ##### Useful Constants (internal use only) ################################
 
 # Reusable defaults