Get rid of python 2.7 traces

No manual magic with pseudo-repr for strings anymore

Author: penguinolog

logwrap/repr_utils.pxd

@@ -63,9 +63,6 @@ cdef:
 
         cpdef str process_element(self, src: typing.Any, unsigned long indent=?, bint no_indent_start=?)
 
-    class PrettyRepr(PrettyFormat):
-        cdef str _strings_repr(self, unsigned long indent, val: typing.Union[bytes, str])
-
     class PrettyStr(PrettyFormat):
         cdef str _strings_str(self, unsigned long indent, val: typing.Union[bytes, str])
 

logwrap/repr_utils.py

@@ -39,18 +39,6 @@ def _simple(item: typing.Any) -> bool:
     return not isinstance(item, (list, set, tuple, dict, frozenset))
 
 
-SPECIAL_SYMBOLS_ESCAPE: typing.Dict[str, str] = {
-    "\\": "\\\\",
-    "\n": "\\n",
-    "\r": "\\r",
-    "\f": "\\f",
-    "\v": "\\v",
-    "\b": "\\b",
-    "\t": "\\t",
-    "\a": "\\a",
-}
-
-
 class ReprParameter:
     """Parameter wrapper wor repr and str operations over signature."""
 
@@ -353,18 +341,6 @@ def _magic_method_name(self) -> str:
         """
         return "__pretty_repr__"
 
-    @staticmethod
-    def _strings_repr(indent: int, val: typing.Union[bytes, str]) -> str:
-        """Custom repr for strings and binary strings."""
-        if isinstance(val, bytes):
-            string: str = val.decode(encoding="utf-8", errors="backslashreplace")
-            prefix: str = "b"
-        else:
-            prefix = "u"
-            string = val
-        escaped: str = "".join(SPECIAL_SYMBOLS_ESCAPE.get(sym, sym) for sym in string)
-        return f"{'':<{indent}}{prefix}'''{escaped}'''"
-
     def _repr_simple(self, src: typing.Any, indent: int = 0, no_indent_start: bool = False) -> str:
         """Repr object without iteration.
 
@@ -380,8 +356,6 @@ def _repr_simple(self, src: typing.Any, indent: int = 0, no_indent_start: bool =
         indent = 0 if no_indent_start else indent
         if isinstance(src, set):
             return f"{'':<{indent}}set({' ,'.join(map(repr, src))})"
-        if isinstance(src, (bytes, str)):
-            return self._strings_repr(indent=indent, val=src)
         return f"{'':<{indent}}{src!r}"
 
     def _repr_dict_items(self, src: typing.Dict[typing.Any, typing.Any], indent: int = 0) -> typing.Iterator[str]:

logwrap/repr_utils.pyx

@@ -35,17 +35,6 @@ cdef:
         """Check for nested iterations: True, if not."""
         return not isinstance(item, (list, set, tuple, dict, frozenset))
 
-    dict SPECIAL_SYMBOLS_ESCAPE = {
-        "\\": "\\\\",
-        "\n": "\\n",
-        "\r": "\\r",
-        "\f": "\\f",
-        "\v": "\\v",
-        "\b": "\\b",
-        "\t": "\\t",
-        "\a": "\\a"
-    }
-
 
     class ReprParameter:
         """Parameter wrapper wor repr and str operations over signature."""
@@ -333,26 +322,6 @@ cdef class PrettyRepr(PrettyFormat):
         self._magic_method_name = "__pretty_repr__"
 
     cdef:
-        str _strings_repr(
-            self,
-            unsigned long indent,
-            val: typing.Union[bytes, str]
-        ):
-            """Custom repr for strings and binary strings."""
-            cdef:
-                str prefix
-                str string
-                str escaped
-
-            if isinstance(val, bytes):
-                string = val.decode(encoding="utf-8", errors="backslashreplace")
-                prefix = "b"
-            else:
-                prefix = "u"
-                string = val
-            escaped = "".join(SPECIAL_SYMBOLS_ESCAPE.get(sym, sym) for sym in string)
-            return f"{'':<{indent}}{prefix}'''{escaped}'''"
-
         str _repr_simple(
             self,
             src: typing.Any,
@@ -373,8 +342,6 @@ cdef class PrettyRepr(PrettyFormat):
             cdef unsigned long real_indent = 0 if no_indent_start else indent
             if isinstance(src, set):
                 return f"{'':<{real_indent}}set({' ,'.join(map(repr, src))})"
-            if isinstance(src, (bytes, str)):
-                return self._strings_repr(indent=real_indent, val=src)
             return f"{'':<{real_indent}}{src!r}"
 
         str _repr_callable(

test/test_log_wrap.py

@@ -767,16 +767,16 @@ def func(arg, arg_secret, arg2='public', secret_arg=('key')):
                     msg="Calling: \n"
                         "'func'(\n"
                         "    # POSITIONAL_OR_KEYWORD:\n"
-                        "    'arg'=u'''data''',\n"
+                        "    'arg'='data',\n"
                         "    'arg_secret'=None,\n"
-                        "    'arg2'=u'''public''',\n"
+                        "    'arg2'='public',\n"
                         "    'secret_arg'=None,\n"
                         ")"),
                 mock.call.log(level=logging.DEBUG, msg="Done: 'func'")
             ]
         )
 
-    def test_003_override_change_repr(self):
+    def test_004_override_change_repr(self):
         class ChangeRepr(logwrap.LogWrap):
             def post_process_param(
                 self,
@@ -804,9 +804,9 @@ def func(arg, arg_secret, arg2='public', secret_arg=('key')):
                     msg="Calling: \n"
                         "'func'(\n"
                         "    # POSITIONAL_OR_KEYWORD:\n"
-                        "    'arg'=u'''data''',\n"
+                        "    'arg'='data',\n"
                         "    'arg_secret'=<*hidden*>,\n"
-                        "    'arg2'=u'''public''',\n"
+                        "    'arg2'='public',\n"
                         "    'secret_arg'=<*hidden*>,\n"
                         ")"),
                 mock.call.log(level=logging.DEBUG, msg="Done: 'func'")

test/test_repr_utils.py

@@ -28,20 +28,22 @@
 
 # noinspection PyUnusedLocal,PyMissingOrEmptyDocstring
 class TestPrettyRepr(unittest.TestCase):
-    def test_simple(self):
+    def test_001_simple(self):
         self.assertEqual(
             logwrap.pretty_repr(True), repr(True)
         )
 
-    def test_text(self):
+    def test_002_text(self):
+        txt = 'Unicode text'
+        b_txt = b'bytes text\x01'
         self.assertEqual(
-            logwrap.pretty_repr('Unicode text'), "u'''Unicode text'''"
+            repr(txt), logwrap.pretty_repr(txt)
         )
         self.assertEqual(
-            logwrap.pretty_repr(b'bytes text\x01'), "b'''bytes text\x01'''"
+            repr(b_txt), logwrap.pretty_repr(b_txt)
         )
 
-    def test_iterable(self):
+    def test_003_iterable(self):
         self.assertEqual(
             'list([{nl:<5}1,{nl:<5}2,{nl:<5}3,\n'
             '])'.format(nl='\n'),
@@ -61,7 +63,7 @@ def test_iterable(self):
             res.startswith('frozenset({') and res.endswith('\n})')
         )
 
-    def test_dict(self):
+    def test_004_dict(self):
         self.assertEqual(
             'dict({\n'
             '    1 : 1,\n'
@@ -71,7 +73,7 @@ def test_dict(self):
             logwrap.pretty_repr({1: 1, 2: 2, 33: 33}),
         )
 
-    def test_nested_obj(self):
+    def test_005_nested_obj(self):
         test_obj = [
             {1: 2},
             {3: {4}},
@@ -111,7 +113,7 @@ def test_nested_obj(self):
         )
         self.assertEqual(exp_repr, logwrap.pretty_repr(test_obj))
 
-    def test_callable(self):
+    def test_006_callable(self):
         fmt = "\n{spc:<{indent}}<{obj!r} with interface ({args})>".format
 
         def empty_func():
@@ -218,7 +220,7 @@ def tst_classmethod(cls, arg, darg=1, *positional, **named):
             )
         )
 
-    def test_indent(self):
+    def test_007_indent(self):
         obj = [[[[[[[[[[123]]]]]]]]]]
         self.assertEqual(
             "list([\n"
@@ -255,7 +257,7 @@ def test_indent(self):
             logwrap.pretty_repr(obj, max_indent=10),
         )
 
-    def test_magic_override(self):
+    def test_008_magic_override(self):
         # noinspection PyMissingOrEmptyDocstring
         class Tst(object):
             def __repr__(self):
@@ -268,7 +270,7 @@ def __pretty_repr__(
                 no_indent_start
             ):
                 return parser.process_element(
-                    "<Test Class at 0x{:X}>".format(id(self.__class__)),
+                    f"<Test Class at 0x{id(self.__class__):X}>",
                     indent=indent,
                     no_indent_start=no_indent_start
                 )
@@ -280,13 +282,9 @@ def __pretty_repr__(
         )
         self.assertEqual(
             result,
-            "u'''<Test Class at 0x{:X}>'''".format(id(Tst))
+            f"'<Test Class at 0x{id(Tst):X}>'"
         )
 
-    def test_string_escape(self):
-        src = "n\n b\b r\r f\f v\v t\t \\ a\a"
-        self.assertEqual("u'''n\\n b\\b r\\r f\\f v\\v t\\t \\\\ a\\a'''", logwrap.pretty_repr(src))
-
 
 # noinspection PyUnusedLocal,PyMissingOrEmptyDocstring
 class TestAnnotated(unittest.TestCase):

test/test_repr_utils_special.py

@@ -29,14 +29,14 @@
 
 # noinspection PyUnusedLocal,PyMissingOrEmptyDocstring
 class TestPrettyRepr(unittest.TestCase):
-    def test_dict_subclass(self):
+    def test_001_dict_subclass(self):
         class MyDict(dict):
             """Dict subclass."""
 
         val = MyDict(key='value')
         self.assertEqual(
             "MyDict({\n"
-            "    'key': u'''value''',\n"
+            "    'key': 'value',\n"
             "})",
             logwrap.pretty_repr(val)
         )
@@ -48,14 +48,14 @@ class MyDict(dict):
             logwrap.pretty_str(val)
         )
 
-    def test_typing_specific_dict(self):
+    def test_002_typing_specific_dict(self):
         class MyDict(typing.Dict[str, str]):
             """Dict subclass."""
 
         val = MyDict(key='value')
         self.assertEqual(
             "MyDict({\n"
-            "    'key': u'''value''',\n"
+            "    'key': 'value',\n"
             "})",
             logwrap.pretty_repr(val)
         )
@@ -68,14 +68,14 @@ class MyDict(typing.Dict[str, str]):
         )
 
     @unittest.skipIf(sys.version_info[:2] < (3, 8), 'pep-0589 is implemented in python 3.8')
-    def test_typed_dict(self):
+    def test_003_typed_dict(self):
         class MyDict(typing.TypedDict):
             key: str
 
         val = MyDict(key='value')
         self.assertEqual(
             "dict({\n"
-            "    'key': u'''value''',\n"
+            "    'key': 'value',\n"
             "})",
             logwrap.pretty_repr(val)
         )