Remove Python 2 workarounds

Author: sebastinas

curtsies/events.py

@@ -7,16 +7,8 @@
 
 from typing import Text, Optional, List, Union
 
-PY3 = sys.version_info[0] >= 3
-
-if PY3:
-    raw_input = input
-    unicode = str
-    chr_byte = lambda i: chr(i).encode("latin-1")
-    chr_uni = chr
-else:
-    chr_byte = chr
-    chr_uni = lambda i: chr(i).decode("latin-1")
+chr_byte = lambda i: chr(i).encode("latin-1")
+chr_uni = chr
 
 
 CURTSIES_NAMES = {}
@@ -345,7 +337,7 @@ def ask_what_they_pressed(seq, Normal):
         print("Unidentified character sequence!")
         with Normal:
             while True:
-                r = raw_input("type 'ok' to prove you're not pounding keys ")
+                r = input("type 'ok' to prove you're not pounding keys ")
                 if r.lower().strip() == "ok":
                     break
         while True:
@@ -355,7 +347,7 @@ def ask_what_they_pressed(seq, Normal):
                 break
             print("nope, that wasn't it")
         with Normal:
-            name = raw_input("Describe in English what key you pressed: ")
+            name = input("Describe in English what key you pressed: ")
             f = open("keylog.txt", "a")
             f.write(f"{seq!r} is called {name}\n")
             f.close()

curtsies/formatstring.py

@@ -33,10 +33,6 @@
                                   RESET_ALL, RESET_BG, RESET_FG,
                                   seq)
 
-PY3 = sys.version_info[0] >= 3
-
-if PY3:
-    unicode = str
 
 one_arg_xforms = {
     'bold' :      lambda s: seq(STYLES['bold'])     +s+seq(RESET_ALL),
@@ -97,7 +93,7 @@ def __init__(self, string, atts=None):
         # type: (Text, Mapping[str, Union[int, bool]]) -> None
         if atts is None:
             atts = {}
-        if not isinstance(string, unicode):
+        if not isinstance(string, str):
             raise ValueError("unicode string required, got %r" % string)
         self._s = string  # type: Text
         self._atts = FrozenDict(atts)
@@ -144,11 +140,11 @@ def color_str(self):
                 s = two_arg_xforms[k](s, v)
         return s
 
-    def __unicode__(self):
+    def __str__(self):
         # type: () -> Text
         value = self.color_str
         if isinstance(value, bytes):
-            return value.decode('utf8', 'replace')
+            return value.decode("utf8", "replace")
         return value
 
     def __eq__(self, other):
@@ -161,12 +157,6 @@ def __hash__(self):
         # type: () -> int
         return hash(self.s, self.atts)
 
-    if PY3:
-        __str__ = __unicode__
-    else:
-        def __str__(self):
-            return unicode(self).encode('utf8')
-
     def __repr__(self):
         # type: () -> str
         return 'Chunk({s}{sep}{atts})'.format(
@@ -268,7 +258,6 @@ def __init__(self, *components):
         self.chunks = list(components)
 
         # caching these leads to a significant speedup
-        self._str = None
         self._unicode = None  # type: Optional[Text]
         self._len = None  # type: Optional[int]
         self._s = None  # type: Optional[Text]
@@ -300,7 +289,7 @@ def from_str(cls, s):
                 for x in tokens_and_strings:
                     if isinstance(x, dict):
                         cur_fmt.update(x)
-                    elif isinstance(x, unicode):
+                    elif isinstance(x, str):
                         atts = parse_args((), {k: v
                                           for k, v in cur_fmt.items()
                                           if v is not None})
@@ -407,6 +396,8 @@ def join(self, iterable):
             before = self.chunks
             if isinstance(s, FmtStr):
                 chunks.extend(s.chunks)
+            elif isinstance(s, (bytes, str)):
+                chunks.extend(fmtstr(s).chunks)  # TODO just make a chunk directly
             elif isinstance(s, (bytes, unicode)):
                 chunks.extend(fmtstr(s).chunks) #TODO just make a chunk directly
             else:
@@ -474,22 +465,13 @@ def rjust(self, width, fillchar=None):
             uniform = self.new_with_atts_removed('bg')
             return fmtstr(to_add, **self.shared_atts) + uniform if to_add else uniform
 
-    def __unicode__(self):
+    def __str__(self):
         # type: () -> Text
         if self._unicode is not None:
             return self._unicode
-        self._unicode = ''.join(unicode(fs) for fs in self.chunks)
+        self._unicode = "".join(str(fs) for fs in self.chunks)
         return self._unicode
 
-    if PY3:
-        __str__ = __unicode__
-    else:
-        def __str__(self):
-            if self._str is not None:
-                return self._str
-            self._str = ''.join(str(fs) for fs in self.chunks)
-            return self._str
-
     def __len__(self):
         # type: () -> int
         if self._len is not None:
@@ -523,7 +505,7 @@ def __repr__(self):
 
     def __eq__(self, other):
         # type: (Any) -> bool
-        if isinstance(other, (unicode, bytes, FmtStr)):
+        if isinstance(other, (str, bytes, FmtStr)):
             return str(self) == str(other)
         return False
 
@@ -535,7 +517,7 @@ def __add__(self, other):
         # type: (Union[FmtStr, Text]) -> FmtStr
         if isinstance(other, FmtStr):
             return FmtStr(*(self.chunks + other.chunks))
-        elif isinstance(other, (bytes, unicode)):
+        elif isinstance(other, (bytes, str)):
             return FmtStr(*(self.chunks + [Chunk(other)]))
         else:
             raise TypeError(f'Can\'t add {self!r} and {other!r}')
@@ -544,7 +526,7 @@ def __radd__(self, other):
         # type: (Union[FmtStr, Text]) -> FmtStr
         if isinstance(other, FmtStr):
             return FmtStr(*(x for x in (other.chunks + self.chunks)))
-        elif isinstance(other, (bytes, unicode)):
+        elif isinstance(other, (bytes, str)):
             return FmtStr(*(x for x in ([Chunk(other)] + self.chunks)))
         else:
             raise TypeError('Can\'t add those')
@@ -581,15 +563,17 @@ def __getattr__(self, att):
         # thanks to @aerenchyma/@jczett
         if not hasattr(self.s, att):
             raise AttributeError(f"No attribute {att!r}")
+
         @no_type_check
         def func_help(*args, **kwargs):
             result = getattr(self.s, att)(*args, **kwargs)
-            if isinstance(result, (bytes, unicode)):
+            if isinstance(result, (bytes, str)):
                 return fmtstr(result, **self.shared_atts)
             elif isinstance(result, list):
                 return [fmtstr(x, **self.shared_atts) for x in result]
             else:
-                 return result
+                return result
+
         return func_help
 
     @property
@@ -806,15 +790,14 @@ def normalize_slice(length, index):
     return index
 
 def parse_args(args, kwargs):
-    # type: (Tuple[Union[bytes, unicode], ...], MutableMapping[str, Union[int, bool, str]]) -> Mapping[str, Union[int, bool]]
+    # type: (Tuple[Union[bytes, str], ...], MutableMapping[str, Union[int, bool, str]]) -> Mapping[str, Union[int, bool]]
     """Returns a kwargs dictionary by turning args into kwargs"""
     if 'style' in kwargs:
         args += (cast(str, kwargs['style']),)
         del kwargs['style']
     for arg in args:
-        if PY3:
-            arg = cast(str, arg)
-        if not isinstance(arg, (bytes, unicode)):
+        arg = cast(str, arg)
+        if not isinstance(arg, (bytes, str)):
             raise ValueError("args must be strings:" + repr(args))
         if arg.lower() in FG_COLORS:
             if 'fg' in kwargs: raise ValueError("fg specified twice")
@@ -854,7 +837,7 @@ def fmtstr(string, *args, **kwargs):
     atts = parse_args(args, kwargs)
     if isinstance(string, FmtStr):
         pass
-    elif isinstance(string, (bytes, unicode)):
+    elif isinstance(string, (bytes, str)):
         string = FmtStr.from_str(string)
     else:
         raise ValueError("Bad Args: {!r} (of type {}), {!r}, {!r}".format(string, type(string), args, kwargs))

curtsies/formatstringarray.py

@@ -41,13 +41,7 @@
     no_type_check,
 )
 
-PY3 = sys.version_info[0] >= 3
-
-if PY3:
-    unicode = str
-
-actualize = str if PY3 else unicode
-
+actualize = str
 logger = logging.getLogger(__name__)
 
 # TODO check that strings used in arrays don't have tabs or spaces in them!
@@ -165,7 +159,7 @@ def __setitem__(self, slicetuple, value):
         logger.debug("slice: %r", slicetuple)
         if isinstance(slicetuple, slice):
             rowslice, colslice = slicetuple, slice(None)
-            if isinstance(value, (bytes, unicode)):
+            if isinstance(value, (bytes, str)):
                 raise ValueError(
                     "if slice is 2D, value must be 2D as in of list type []"
                 )

curtsies/input.py

@@ -19,8 +19,6 @@
 from typing import Callable, Type, TextIO, Optional, List, Union, Text, cast, Tuple, Any
 from types import TracebackType, FrameType
 
-PY3 = sys.version_info[0] >= 3
-
 READ_SIZE = 1024
 assert READ_SIZE >= events.MAX_KEYPRESS_SIZE
 # if a keypress could require more bytes than we read to be identified,
@@ -137,12 +135,10 @@ def __iter__(self):
         # type: () -> Input
         return self
 
-    def next(self):
+    def __next__(self):
         # type: () -> Union[None, Text, events.Event]
         return self.send(None)
 
-    __next__ = next
-
     def unget_bytes(self, string):
         # type: (bytes) -> None
         """Adds bytes to be internal buffer to be read
@@ -291,26 +287,15 @@ def _nonblocking_read(self):
         # type: () -> int
         """Returns the number of characters read and adds them to self.unprocessed_bytes"""
         with Nonblocking(self.in_stream):
-            if PY3:
-                try:
-                    data = os.read(self.in_stream.fileno(), READ_SIZE)
-                except BlockingIOError:
-                    return 0
-                if data:
-                    self.unprocessed_bytes.extend(
-                        data[i : i + 1] for i in range(len(data))
-                    )
-                    return len(data)
-                else:
-                    return 0
+            try:
+                data = os.read(self.in_stream.fileno(), READ_SIZE)
+            except BlockingIOError:
+                return 0
+            if data:
+                self.unprocessed_bytes.extend(data[i : i + 1] for i in range(len(data)))
+                return len(data)
             else:
-                try:
-                    data = os.read(self.in_stream.fileno(), READ_SIZE)
-                except OSError:
-                    return 0
-                else:
-                    self.unprocessed_bytes.extend(data)
-                    return len(data)
+                return 0
 
     def event_trigger(self, event_type):
         # type: (Type[events.Event]) -> Callable

tests/test_fmtstr.py

@@ -22,16 +22,7 @@
 from curtsies.termformatconstants import FG_COLORS
 from curtsies.formatstringarray import fsarray, FSArray, FormatStringTest
 
-try:
-    from unittest import skip
-except ImportError:
-
-    def skip(f):
-        return lambda self: None
-
-
-PY2 = sys.version_info[0] == 2
-
+from unittest import skip
 
 
 def repr_without_leading_u(s):
@@ -514,10 +505,7 @@ def test_char_width_aware_slice(self):
 class TestChunk(unittest.TestCase):
     def test_repr(self):
         c = Chunk("a", {"fg": 32})
-        if PY2:
-            self.assertEqual(repr(c), """Chunk(u'a', {'fg': 32})""")
-        else:
-            self.assertEqual(repr(c), """Chunk('a', {'fg': 32})""")
+        self.assertEqual(repr(c), """Chunk('a', {'fg': 32})""")
 
 
 class TestChunkSplitter(unittest.TestCase):

tests/test_input.py

@@ -5,20 +5,7 @@
 import time
 import unittest
 from unittest.mock import Mock
-
-try:
-    from unittest import skip, skipUnless
-except ImportError:
-
-    def skip(f):
-        return lambda self: None
-
-    def skipUnless(condition, reason):
-        if condition:
-            return lambda x: x
-        else:
-            return lambda x: None
-
+from unittest import skip, skipUnless
 
 from curtsies import events
 from curtsies.input import Input