Merge pull request #1 from samuelcolvin/prettier-print

prettier print and colorizing

Author: samuelcolvin

.gitignore

@@ -13,3 +13,4 @@ htmlcov/
 benchmarks/*.json
 docs/_build/
 old-version/
+*.swp

devtools/__init__.py

@@ -1,3 +1,5 @@
 # flake8: noqa
+from .ansi import *
 from .debug import *
+from .prettier import *
 from .version import VERSION

devtools/ansi.py

@@ -0,0 +1,147 @@
+import re
+import sys
+from enum import IntEnum
+from typing import Any
+
+_ansi_template = '\033[{}m'
+_ansi_re = re.compile('\033\[((?:\d|;)*)([a-zA-Z])')
+
+__all__ = ['sformat', 'sprint']
+
+
+def isatty(stream=None):
+    stream = stream or sys.stdout
+    try:
+        return stream.isatty()
+    except Exception:
+        return False
+
+
+def strip_ansi(value):
+    return _ansi_re.sub('', value)
+
+
+class Style(IntEnum):
+    reset = 0
+
+    bold = 1
+    not_bold = 22
+
+    dim = 2
+    not_dim = 22
+
+    italic = 3
+    not_italic = 23
+
+    underline = 4
+    not_underline = 24
+
+    blink = 5
+    not_blink = 25
+
+    reverse = 7
+    not_reverse = 27
+
+    strike_through = 9
+    not_strike_through = 29
+
+    # foreground colours
+    black = 30
+    red = 31
+    green = 32
+    yellow = 33
+    blue = 34
+    magenta = 35
+    cyan = 36
+    white = 37
+
+    # background colours
+    bg_black = 40
+    bg_red = 41
+    bg_green = 42
+    bg_yellow = 43
+    bg_blue = 44
+    bg_magenta = 45
+    bg_cyan = 46
+    bg_white = 47
+
+    # this is a meta value used for the "Style" instance which is the "style" function
+    function = -1
+
+    def __call__(self, input: Any, *styles, reset: bool=True, apply: bool=True):
+        """
+        Styles text with ANSI styles and returns the new string.
+
+        By default the styling is cleared at the end of the string, this can be prevented with``reset=False``.
+
+        Examples::
+
+            print(sformat('Hello World!', sformat.green))
+            print(sformat('ATTENTION!', sformat.bg_magenta))
+            print(sformat('Some things', sformat.reverse, sformat.bold))
+
+        :param input: the object to style with ansi codes.
+        :param *styles: zero or more styles to apply to the text, should be either style instances or strings
+                        matching style names.
+        :param reset: if False the ansi reset code is not appended to the end of the string
+        :param: apply: if False no ansi codes are applied
+        """
+        text = str(input)
+        if not apply:
+            return text
+        codes = []
+        for s in styles:
+            # raw ints are allowed
+            if not isinstance(s, self.__class__) and not isinstance(s, int):
+                try:
+                    s = self.styles[s]
+                except KeyError:
+                    raise ValueError('invalid style "{}"'.format(s))
+            codes.append(str(s.value))
+
+        if codes:
+            r = _ansi_template.format(';'.join(codes)) + text
+        else:
+            r = text
+
+        if reset:
+            r += _ansi_template.format(self.reset)
+        return r
+
+    @property
+    def styles(self):
+        return self.__class__.__members__
+
+    def __repr__(self):
+        if self == self.function:
+            return '<pseudo function sformat(text, *styles)>'
+        else:
+            return super().__repr__()
+
+    def __str__(self):
+        if self == self.function:
+            return repr(self)
+        else:
+            return super().__str__()
+
+
+sformat = Style(-1)
+
+
+class StylePrint:
+    """
+    Annoyingly enums do not allow inheritance, this is a lazy design mistake, this is an ugly work around
+    for that mistake.
+    """
+    def __call__(self, input, *styles, reset=True, flush=True, file=None, **print_kwargs):
+        text = sformat(input, *styles, reset=reset, apply=isatty(file))
+        print(text, flush=flush, file=file, **print_kwargs)
+
+    def __getattr__(self, item):
+        return getattr(sformat, item)
+
+    def __repr__(self):
+        return '<pseudo function sprint(text, *styles)>'
+
+
+sprint = StylePrint()

devtools/debug.py

@@ -7,8 +7,12 @@
 from textwrap import dedent
 from typing import Generator, List, Optional, Tuple
 
+from .ansi import isatty, sformat
+from .prettier import PrettyFormat
+
 __all__ = ['Debug', 'debug']
 CWD = Path('.').resolve()
+pformat = PrettyFormat()
 
 
 def env_true(var_name, alt='FALSE'):
@@ -26,20 +30,21 @@ def __init__(self, value, *, name=None, **extra):
             self.extra.append(('len', len(value)))
         self.extra += [(k, v) for k, v in extra.items() if v is not None]
 
-    def value_str(self):
-        if isinstance(self.value, str):
-            return '"{}"'.format(self.value)
-        return str(self.value)
+    def str(self, colours=False) -> str:
+        s = ''
+        if self.name:
+            s = sformat(self.name, sformat.blue, apply=colours) + ': '
+        s += pformat(self.value, indent=2)
+        suffix = (
+            ' ({0.value.__class__.__name__}) {1}'
+            .format(self, ' '.join('{}={}'.format(k, v) for k, v in self.extra))
+            .rstrip(' ')  # trailing space if extra is empty
+        )
+        s += sformat(suffix, sformat.dim, apply=colours)
+        return s
 
     def __str__(self) -> str:
-        template = '{value} ({self.value.__class__.__name__}) {extra}'
-        if self.name:
-            template = '{self.name} = ' + template
-        return template.format(
-            self=self,
-            value=self.value_str(),
-            extra=' '.join('{}={}'.format(k, v) for k, v in self.extra)
-        ).rstrip(' ')  # trailing space if extra is empty
+        return self.str()
 
 
 class DebugOutput:
@@ -55,13 +60,19 @@ def __init__(self, *, filename: str, lineno: int, frame: str, arguments: List[De
         self.frame = frame
         self.arguments = arguments
 
+    def str(self, colours=False) -> str:
+        if colours:
+            prefix = '{}:{} {}\n  '.format(
+                sformat(self.filename, sformat.magenta),
+                sformat(self.lineno, sformat.green),
+                sformat(self.frame, sformat.green, sformat.italic)
+            )
+        else:
+            prefix = '{0.filename}:{0.lineno} {0.frame}\n  '.format(self)
+        return prefix + '\n  '.join(a.str(colours) for a in self.arguments)
+
     def __str__(self) -> str:
-        template = '{s.filename}:{s.lineno} {s.frame}'
-        # turns out single line output is ugly
-        # if len(self.arguments) == 1:
-        #     return (template + ': {a}').format(s=self, a=self.arguments[0])
-        # else:
-        return (template + '\n  {a}').format(s=self, a='\n  '.join(str(a) for a in self.arguments))
+        return self.str()
 
     def __repr__(self) -> str:
         arguments = ' '.join(str(a) for a in self.arguments)
@@ -78,21 +89,30 @@ class Debug:
 
     def __init__(self, *,
                  warnings: Optional[bool]=None,
+                 colours: Optional[bool]=None,
                  frame_context_length: int=50):
-        if warnings is None:
-            self._warnings = env_true('PY_DEVTOOLS_WARNINGS', 'TRUE')
-        else:
-            self._warnings = warnings
+        self._warnings = self._env_bool(warnings, 'PY_DEVTOOLS_WARNINGS')
+        self._colours = self._env_bool(colours, 'PY_DEVTOOLS_COLOURS')
         # 50 lines should be enough to make sure we always get the entire function definition
         self._frame_context_length = frame_context_length
 
-    def __call__(self, *args, **kwargs):
-        print(self._process(args, kwargs, r'debug *\('), flush=True)
+    @classmethod
+    def _env_bool(cls, value, env_name, env_default='TRUE'):
+        if value is None:
+            return env_true(env_name, env_default)
+        else:
+            return value
+
+    def __call__(self, *args, file_=None, flush_=True, **kwargs) -> None:
+        d_out = self._process(args, kwargs, r'debug *\(')
+        colours_possible = isatty(file_)
+        s = d_out.str(self._colours and colours_possible)
+        print(s, file=file_, flush=flush_)
 
-    def format(self, *args, **kwargs):
+    def format(self, *args, **kwargs) -> DebugOutput:
         return self._process(args, kwargs, r'debug.format *\(')
 
-    def _process(self, args, kwargs, func_regex):
+    def _process(self, args, kwargs, func_regex) -> DebugOutput:
         curframe = inspect.currentframe()
         frames = inspect.getouterframes(curframe, context=self._frame_context_length)
         # BEWARE: this must be call by a method which in turn is called "directly" for the frame to be correct