Merge pull request #9 from bartikowskiw/ANSPB-423_update_to_python_3

Anspb 423 update to python 3

Author: tersmitten

.travis.yml

@@ -2,6 +2,7 @@ language: python
 
 python:
   - "2.7"
+  - "3.5"
 
 install: "make init"
 
@@ -16,6 +17,6 @@ script:
 
 notifications:
   email: false
-  hipchat:
+  slack:
     rooms:
-      secure: Fs2DhIDlqNM70oxVj9b5BpbZ/OtKvI09SVjWq4fWwFvX4cuD1fxJ4/xknyjWYONTPYQu1PMdomu3HvJ5auVcyM/fuH2dkVffEGlDsH300aId8HoRN/VcCcdLvckqgPgjpZIomOTF1G195SVolQ9Va7uc1LOzbNOb3k4lP1M+Xms=
+      secure: "Rse+KZpjFlG+ztNF2x0nb+mdckfG3ZMDt7/U7hoti6n3dG/5dGPuTWv53aU12zCC5uo5Owur3hmONqLAp+EOo+b8A5yxnTrjbDKo/GymCvtToXkcg6omlhEBZxcvKyKpGwjlRcx/ZXC6SRc5+NONLsgRnZQy/pDkxZ7WJhrj/yI="

Makefile

@@ -12,8 +12,8 @@ deb:
 	python setup.py --command-packages=stdeb.command bdist_deb
 
 check:
-	find . -name \*.py | xargs pep8 --first
-	find bin -type f | xargs pep8 --first
+	find . -name \*.py | xargs pycodestyle --first
+	find bin -type f | xargs pycodestyle --first
 
 test:
 	nosetests -v

bin/locale-decode-category

@@ -2,42 +2,48 @@
 
 # -*- coding: utf-8 -*-
 
+from __future__ import absolute_import
 import sys
 from glibc_locale_tools.glibc_locale_tools import *
 
 lines = []
 for line in sys.stdin:
-  lines.append(line)
-lines_joined = ''.join(lines).decode('utf-8')
+    lines.append(line)
+lines_joined = ''.join(lines)
+if sys.version_info < (3, 0):
+    lines_joined = lines_joined.decode('utf-8')
 
 unsafe_spans = get_unsafe_spans(lines, lines_joined)
 
 between_quotes_map = []
 for between_quotes in reversed(list(re.finditer(BETWEEN_QUOTES_PATTERN, lines_joined))):
-  between_quotes_match = between_quotes.group(1)
-  between_quotes_match_start = between_quotes.start(1)
-  between_quotes_match_end = between_quotes.end(1)
+    between_quotes_match = between_quotes.group(1)
+    between_quotes_match_start = between_quotes.start(1)
+    between_quotes_match_end = between_quotes.end(1)
 
-  if in_unsafe_spans(between_quotes_match_start, between_quotes_match_end, unsafe_spans):
-    continue
+    if in_unsafe_spans(between_quotes_match_start, between_quotes_match_end, unsafe_spans):
+        continue
 
-  replacement = between_quotes_match
-  for unicode_matches in reversed(list(re.finditer(UNICODE_PATTERN, between_quotes_match))):
-    replacement = replace_positional(replacement,
-                                     unicode_matches.start(1),
-                                     unicode_decode(unicode_matches.group(2)),
-                                     unicode_matches.end(1))
+    replacement = between_quotes_match
+    for unicode_matches in reversed(list(re.finditer(UNICODE_PATTERN, between_quotes_match))):
+        replacement = replace_positional(replacement,
+                                         unicode_matches.start(1),
+                                         unicode_decode(unicode_matches.group(2)),
+                                         unicode_matches.end(1))
 
-  between_quotes_map.append({'start': between_quotes_match_start,
-                             'end': between_quotes_match_end,
-                             'replacement': replacement})
+    between_quotes_map.append({'start': between_quotes_match_start,
+                               'end': between_quotes_match_end,
+                               'replacement': replacement})
 
 for between_quotes_map_items in between_quotes_map:
-  lines_joined = replace_positional(lines_joined,
-                                    between_quotes_map_items['start'],
-                                    between_quotes_map_items['replacement'],
-                                    between_quotes_map_items['end'])
+    lines_joined = replace_positional(lines_joined,
+                                      between_quotes_map_items['start'],
+                                      between_quotes_map_items['replacement'],
+                                      between_quotes_map_items['end'])
 
-sys.stdout.write(lines_joined.encode('utf-8'))
+if sys.version_info < (3, 0):
+    lines_joined = lines_joined.encode('utf-8')
+
+sys.stdout.write(lines_joined)
 
 sys.exit(0)

bin/locale-encode-category

@@ -2,42 +2,51 @@
 
 # -*- coding: utf-8 -*-
 
+from __future__ import absolute_import
 import sys
 from glibc_locale_tools.glibc_locale_tools import *
 
 lines = []
 for line in sys.stdin:
-  lines.append(line)
-lines_joined = ''.join(lines).decode('utf-8')
+    lines.append(line)
+lines_joined = ''.join(lines)
+
+# Handle Python 2.x
+if sys.version_info < (3, 0):
+    lines_joined = lines_joined.decode('utf-8')
 
 unsafe_spans = get_unsafe_spans(lines, lines_joined)
 
 between_quotes_map = []
 for between_quotes in reverse_iter(re.finditer(BETWEEN_QUOTES_PATTERN, lines_joined)):
-  between_quotes_match = between_quotes.group(1)
-  between_quotes_match_start = between_quotes.start(1)
-  between_quotes_match_end = between_quotes.end(1)
+    between_quotes_match = between_quotes.group(1)
+    between_quotes_match_start = between_quotes.start(1)
+    between_quotes_match_end = between_quotes.end(1)
 
-  if in_unsafe_spans(between_quotes_match_start, between_quotes_match_end, unsafe_spans):
-    continue
+    if in_unsafe_spans(between_quotes_match_start, between_quotes_match_end, unsafe_spans):
+        continue
 
-  replacement = between_quotes_match
-  for to_decode_matches in reversed(list(re.finditer(TO_DECODE_PATTERN, between_quotes_match))):
-    replacement = replace_positional(replacement,
-                                     to_decode_matches.start(0),
-                                     unicode_encode(to_decode_matches.group(0)),
-                                     to_decode_matches.end(0))
+    replacement = between_quotes_match
+    for to_decode_matches in reversed(list(re.finditer(TO_DECODE_PATTERN, between_quotes_match))):
+        replacement = replace_positional(replacement,
+                                         to_decode_matches.start(0),
+                                         unicode_encode(to_decode_matches.group(0)),
+                                         to_decode_matches.end(0))
 
-  between_quotes_map.append({'start': between_quotes_match_start,
-                             'end': between_quotes_match_end,
-                             'replacement': replacement})
+    between_quotes_map.append({'start': between_quotes_match_start,
+                               'end': between_quotes_match_end,
+                               'replacement': replacement})
 
 for between_quotes_map_items in between_quotes_map:
-  lines_joined = replace_positional(lines_joined,
-                                    between_quotes_map_items['start'],
-                                    between_quotes_map_items['replacement'],
-                                    between_quotes_map_items['end'])
+    lines_joined = replace_positional(lines_joined,
+                                      between_quotes_map_items['start'],
+                                      between_quotes_map_items['replacement'],
+                                      between_quotes_map_items['end'])
+
+# Handle Python 2.x
+if sys.version_info < (3, 0):
+    lines_joined = lines_joined.encode('utf-8')
 
-sys.stdout.write(lines_joined.encode('utf-8'))
+sys.stdout.write(lines_joined)
 
 sys.exit(0)

bin/locale-extract-category

@@ -2,35 +2,36 @@
 
 # -*- coding: utf-8 -*-
 
+from __future__ import absolute_import
 import sys
 import re
 from glibc_locale_tools.glibc_locale_tools import *
 
 if len(sys.argv) != 2:
-  sys.stderr.write('%s [LC section name (e.g. LC_TIME)]\n' % sys.argv[0])
-  sys.exit(1)
+    sys.stderr.write('%s [LC section name (e.g. LC_TIME)]\n' % sys.argv[0])
+    sys.exit(1)
 
 lc_section = sys.argv[1]
 
 if lc_section not in POSSIBLE_LC_SECTIONS:
-  sys.stderr.write('Non existing LC section %s\n' % lc_section)
-  sys.exit(1)
+    sys.stderr.write('Non existing LC section %s\n' % lc_section)
+    sys.exit(1)
 
 lc_section_pattern = LC_SECTION_PATTERN.format(lc_section)
 
 lines = ''
 for line in sys.stdin:
-  lines += line
+    lines += line
 
 match_comment_char = re.search(COMMENT_CHAR_PATTERN, lines, re.MULTILINE)
 match_escape_char = re.search(ESCAPE_CHAR_PATTERN, lines, re.MULTILINE)
 match_category = re.search(lc_section_pattern, lines, re.DOTALL)
 
 if match_comment_char:
-  sys.stdout.write(match_comment_char.group(1) + '\n')
+    sys.stdout.write(match_comment_char.group(1) + '\n')
 if match_escape_char:
-  sys.stdout.write(match_escape_char.group(1) + '\n')
+    sys.stdout.write(match_escape_char.group(1) + '\n')
 if match_category:
-  sys.stdout.write(match_category.group(1).lstrip('\n'))
+    sys.stdout.write(match_category.group(1).lstrip('\n'))
 
 sys.exit(0)

glibc_locale_tools/glibc_locale_tools.py

@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 
 import re
+import sys
 
 
 BETWEEN_QUOTES_PATTERN = r'"([^"]*)"'
@@ -46,101 +47,104 @@
 
 
 def unicode_decode(unicode_char):
-  """
-  Decodes an unicode char (e.g. 20AC to €).
+    """
+    Decodes an unicode char (e.g. 20AC to €).
 
-  :param unicode_char: An unicode char
-  :return: A (decoded) unicode char
-  """
-
-  return unichr(int(unicode_char, 16))
+    :param unicode_char: An unicode char
+    :return: A (decoded) unicode char
+    """
+    if sys.version_info >= (3, 0):
+        return chr(int(unicode_char, 16))
+    else:
+        # Keep this for Python 2.x
+        return unichr(int(unicode_char, 16))
 
 
 def unicode_encode(char):
-  """
-  Encodes an char (e.g. € to <U20AC>).
+    """
+    Encodes an char (e.g. € to <U20AC>).
 
-  :param char: A char
-  :return: An (encoded) char
-  """
+    :param char: A char
+    :return: An (encoded) char
+    """
 
-  return '<U%04X>' % (ord(char))
+    return '<U%04X>' % (ord(char))
 
 
 def replace_positional(original, start, replacement, end):
-  """
-  Replaces a substring in a string between a start and end position.
+    """
+    Replaces a substring in a string between a start and end position.
 
-  :param original: An original string
-  :param start: A start position
-  :param replacement: A replacement string
-  :param end: An end position
-  :return: A (replaced) string
-  """
+    :param original: An original string
+    :param start: A start position
+    :param replacement: A replacement string
+    :param end: An end position
+    :return: A (replaced) string
+    """
 
-  return original[:start] + replacement + original[end:]
+    return original[:start] + replacement + original[end:]
 
 
 def reverse_iter(iterator):
-  """
-  Reverses an iterator.
+    """
+    Reverses an iterator.
 
-  :param iterator: An iterator
-  :return: A reversed iterator
-  """
+    :param iterator: An iterator
+    :return: A reversed iterator
+    """
 
-  return reversed(list(iterator))
+    return reversed(list(iterator))
 
 
 def between_range(range1, range2):
-  """
-  Checks whether or not range 2 is between range 1.
+    """
+    Checks whether or not range 2 is between range 1.
 
-  :param range1: A range
-  :param range2: A range
-  :return: Whether or not range 2 is between range 1
-  """
+    :param range1: A range
+    :param range2: A range
+    :return: Whether or not range 2 is between range 1
+    """
 
-  return range1['start'] <= range2['start'] <= range1['end'] and range1['start'] <= range2['end'] <= range1['end']
+    return range1['start'] <= range2['start'] <= range1['end'] and range1['start'] <= range2['end'] <= range1['end']
 
 
 def in_unsafe_spans(match_start, match_end, unsafe_spans):
-  """
-  Checks whether not a range (match start and end) is in unsafe ranges.
+    """
+    Checks whether not a range (match start and end) is in unsafe ranges.
 
-  :param match_start: A match start position
-  :param match_end: A match end position
-  :param unsafe_spans: A list of unsafe spans
-  :return: Whether not a range is in unsafe ranges
-  """
+    :param match_start: A match start position
+    :param match_end: A match end position
+    :param unsafe_spans: A list of unsafe spans
+    :return: Whether not a range is in unsafe ranges
+    """
 
-  for unsafe_span in unsafe_spans:
-    if between_range(unsafe_span, {'start': match_start, 'end': match_end}):
-      return True
+    for unsafe_span in unsafe_spans:
+        if between_range(unsafe_span, {'start': match_start, 'end': match_end}):
+            return True
 
-  return False
+    return False
 
 
 def get_unsafe_spans(lines, lines_joined):
-  """
-  Generates a list of unsafe spans.
+    """
+    Generates a list of unsafe spans.
 
-  Unsafe span are comment lines that contain double quotes (that should not be (en|de)coded).
+    Unsafe span are comment lines that contain double quotes (that should not be (en|de)coded).
 
-  :param lines: A list of lines
-  :param lines_joined: A string of lines
-  :return: A list of unsafe spans
-  """
+    :param lines: A list of lines
+    :param lines_joined: A string of lines
+    :return: A list of unsafe spans
+    """
 
-  unsafe_lines = []
-  for line in lines:
-    if re.search(COMMENT_LINE_WITH_QUOTES_PATTERN, line):
-      unsafe_lines.append(line)
+    unsafe_lines = []
+    for line in lines:
+        if re.search(COMMENT_LINE_WITH_QUOTES_PATTERN, line):
+            unsafe_lines.append(line)
 
-  unsafe_lines_pattern = '({0})'.format('|'.join(map(re.escape, unsafe_lines)))
+    unsafe_lines_pattern = '({0})'.format('|'.join(map(re.escape, unsafe_lines)))
 
-  unsafe_spans = []
-  for unsafe_line in re.finditer(unsafe_lines_pattern, lines_joined):
-    unsafe_spans.append({'start': unsafe_line.start(0), 'end': unsafe_line.end(0)})
+    unsafe_spans = []
+    for unsafe_line in re.finditer(unsafe_lines_pattern, lines_joined):
+        unsafe_spans.append({'start': unsafe_line.start(0), 'end': unsafe_line.end(0)})
 
-  return unsafe_spans
+    return unsafe_spans