add text and stack utils, method binding - bump 0.0.6

Author: beasteers

setup.py

@@ -5,7 +5,7 @@
 
 setuptools.setup(
     name=NAME,
-    version='0.0.5',
+    version='0.0.6',
     description='',
     long_description=open('README.md').read().strip(),
     long_description_content_type='text/markdown',

tests/test_objects.py

@@ -100,10 +100,19 @@ class B:
         x = 5
         y = 6
 
+        def getx(self):
+            return self.x
+
+        @property
+        def xx(self):
+            return self.x
+
     a = B()
     x = wp.Mask(a, x=10)
     # test that mask is applied
     assert a.x == 5 and x.x == 10
+    assert x.getx() == 10
+    # assert x.xx == 10
     # test partial mask - mask change
     x.y = 8
     assert a.y == 8 and x.y == 8

tests/test_text.py

@@ -0,0 +1,79 @@
+import wrappingpaper as wp
+
+
+def test_text():
+    prep = lambda t: wp.text.strip_trailing_whitespace(wp.text.striplines(t)).rstrip().replace('\t', ' '*4)
+    inspect = lambda *xs: print(wp.text.block_text(*xs, *(repr(x) for x in xs), div='----'))
+
+    original = prep('''
+asdf
+
+asdfsadf
+    asdf
+    ''')
+    indented = prep('''
+    asdf
+
+    asdfsadf
+        asdf
+    ''')
+    # inspect(original, indented)
+    # test indent
+    assert wp.text.strip_trailing_whitespace(wp.text.indent(original)) == indented
+    assert wp.text.trim_indent(indented) == original
+    assert wp.text.strip_trailing_whitespace(wp.text.tabindent(original.replace(' '*4, '\t'))) == indented.replace(' '*4, '\t')
+
+    assert wp.text.striplines('\n'*3 + indented + '\n'*3) == indented
+
+    # test commenting
+    commented = prep('''
+# asdf
+#
+# asdfsadf
+#     asdf
+    ''')
+
+    assert wp.text.strip_trailing_whitespace(wp.text.comment(original)) == commented
+    assert wp.text.strip_trailing_whitespace(wp.text.comment(original, ch='//')) == commented.replace('#', '//')
+
+    # test block text
+    block_text = prep('''
+********************
+* asdf
+*
+* asdfsadf
+*     asdf
+*
+* hello
+********************
+    ''')
+    assert wp.text.strip_trailing_whitespace(wp.text.block_text(original, '', 'hello')) == block_text
+
+    # test line and block
+    assert wp.text.l_('asdf', 5, 5) == 'asdf 5 5'
+    assert wp.text.b_('asdf', (5, 6, 7, 8), 5) == '''
+asdf
+5 6 7 8
+5
+    '''.strip()
+
+    # text fixed width format
+    assert wp.text.fw_('asdf', w=10) == 'asdf      '
+
+    # test table
+    assert wp.text.strip_trailing_whitespace(wp.text.tbl(
+        ('asdf', 6, 7, 'asdf'),
+        (5, 6, 7, 8),
+        (5, 'asdf', 7, 'asdf'))) == '''
+asdf  6     7  asdf
+5     6     7  8
+5     asdf  7  asdf
+    '''.strip()
+
+    # test colors
+    assert wp.text.red('a b c') == '\033[91ma b c\033[0m'
+    assert wp.text.blue('a b c') == '\033[94ma b c\033[0m'
+    assert wp.text.green('a b c') == '\033[92ma b c\033[0m'
+    assert wp.text.yellow('a b c') == '\033[93ma b c\033[0m'
+    assert wp.text.bold('a b c') == '\033[1ma b c\033[0m'
+    assert wp.text.underline('a b c') == '\033[4ma b c\033[0m'

wrappingpaper/__init__.py

@@ -12,6 +12,7 @@ def __bool__(self):
 from .context import *
 from .logs import *
 from .props import *
+from . import text
 from .stack import *
 from .objects import *
 from .schedule import *

wrappingpaper/importmechanics.py

@@ -152,9 +152,7 @@ def find_spec(self, fullname, path=None, target=None):
         parts = _as_parts(fullname)
 
         # e.g. from presets import librosa  <<<<
-        explicit_import = (
-            self.module_name[:len(parts)] ==
-            parts[:len(self.module_name)])
+        explicit_import = self.module_name[:len(parts)] == parts[:len(self.module_name)]
 
         if explicit_import:
             parts = parts[len(self.module_name):] # cut off prefix

wrappingpaper/objects.py

@@ -58,7 +58,13 @@ def __init__(self, base, d=None, full=False, **kw):
     def __getattribute__(self, name):
         if name not in {'__dict__', '__initialized__'}:
             if self.__initialized__ and name not in self.__dict__:
-                return getattr(self.__masked__, name)
+                value = getattr(self.__masked__, name)
+                if hasattr(value, '__self__'):
+                    try:
+                        return value.__func__.__get__(self)
+                    except AttributeError:
+                        pass
+                return value
         return super().__getattribute__(name)
 
     def __setattr__(self, name, value):

wrappingpaper/stack.py

@@ -1,6 +1,8 @@
+import os
 import hashlib
 import inspect
-from .exceptions import CircularReference
+from . import text
+# from .exceptions import CircularReference
 
 
 def uid(x, digits=None):
@@ -24,3 +26,30 @@ def get_stack_id(x=None, frames=1, digits=16):
 #     yield
 #     del circular.__stack_refs__[xid]
 # circular.__stack_refs__ = {}
+
+
+def stack_summary(message=None, fn=None, offset=0):
+    stack = inspect.stack()
+    f = stack[offset+1]
+    return text.block_text(
+        message,
+        text.blue(text.l_(f.function, f.lineno, f.filename)), '',
+        text.tbl(*(
+            (f.function, f.lineno, f.filename, f'>>> {f.code_context[0].strip()}')
+            for f in stack[offset+2:]
+            if not fn or fn in f.filename
+        )), ch=text.yellow('*')
+    )
+
+def print_stack(message=None, *a, offset=0, **kw):
+    print(stack_summary(message, *a, offset=offset + 1, **kw))
+
+
+def short_stack_summary(match=None, file=False, sep=' << ', n=None):
+    '''Print out a compressed view of the stack.'''
+    return sep.join(
+        (f'{f.function} ({os.path.basename(f.filename)}:{f.lineno})'
+         if file else f.function)
+        for f in inspect.stack()[1:][:n]
+        if not match or match in f.filename
+    )

wrappingpaper/text.py

@@ -1,4 +1,109 @@
 
+# Text formatting
+
+class C:
+    HEADER = '\033[95m'
+    OKBLUE = '\033[94m'
+    OKGREEN = '\033[92m'
+    WARNING = '\033[93m'
+    FAIL = '\033[91m'
+    ENDC = '\033[0m'
+    BOLD = '\033[1m'
+    UNDERLINE = '\033[4m'
+
+def _text_wrapper(start, end=C.ENDC):
+    return f'{start}{{}}{end}'.format
+
+red = _text_wrapper(C.FAIL)
+blue = _text_wrapper(C.OKBLUE)
+green = _text_wrapper(C.OKGREEN)
+yellow = _text_wrapper(C.WARNING)
+bold = _text_wrapper(C.BOLD)
+underline = _text_wrapper(C.UNDERLINE)
+
+t4 = ' '*4
+t2 = ' '*2
+
+# block text helpers
+
+def indent(x, n=1, w=4, ch=' '):
+    '''Indent text using spaces.'''
+    return ''.join(ch * w * n + l for l in str(x).splitlines(keepends=True))
+
+def tabindent(x, n=1, w=4):
+    '''Indent text using tabs.'''
+    return indent(space2tab(x, w=w), w=1, n=n, ch='\t')
+
+
+def tab2space(text, w=4):
+    return text.replace('\t', ' '*w)
+
+def space2tab(text, w=4):
+    return text.replace(' '*w, '\t')
+
+
+def trim_indent(text, tw=2):
+    '''Remove any common indent from text.
+
+    Arguments:
+        text (str): the text to re-indent.
+        tw (int): the number of spaces per tab character.
+    '''
+    # normalize tabs to spaces
+    lines = text.replace('\t', ' '*tw).splitlines()
+    # get the min indent to norm to
+    m = min([len(l) - len(l.lstrip()) for l in lines if l.strip()], default=0)
+    # rejoin the text with the proper indent
+    return '\n'.join([l[m:] for l in lines])
+
+
+def striplines(text):
+    '''Like text.strip() but it only removes lines with purely whitespace and
+    leaves text indentation.'''
+    lines = text.splitlines()
+    i, j = 0, len(lines)
+    while not lines[i].strip():
+        i += 1
+    while not lines[j-1].strip():
+        j -= 1
+    return '\n'.join(lines[i:j])
+
+def strip_trailing_whitespace(txt):
+    '''remove whitespace from the end of each line.'''
+    return '\n'.join(l.rstrip() for l in txt.splitlines())
+
+def comment(txt, ch='#', n=1, spaces=1):
+    '''Apply prefix to each line. Defaults to python comments.'''
+    ch, spaces = ch*n, " "*spaces
+    return '\n'.join(f'{ch}{spaces}{l}' for l in txt.splitlines())
+
+
+def block_text(*txts, n=20, ch='*', div=''):
+    '''Create a block of text with a character border.'''
+    return ch * n + f'\n{comment(b_(*txts, div=div), ch=ch)}\n' + ch * n
+
+def b_(*lines, div=''):
+    '''Convert arguments to lines. Lines can be tuples (will be joined by a space.)'''
+    div = f'\n{div}\n' if div else '\n'
+    return div.join(
+        l_(*l) if isinstance(l, (list, tuple)) else str(l)
+        for l in lines if l is not None)
+
+def l_(*line, div=' '):
+    '''Convert arguments to a space separated string'''
+    return div.join(map(str, line))
+
+
+def fw_(*line, w=20, right=False):
+    '''As a fixed width string'''
+    return f"{l_(*line):{'>' if right else '<'}{w}}"
+
+def tbl(*rows, buffer=2):
+    '''Format as a table. Calculates column widths.'''
+    rows = [[str(c) for c in cs] for cs in rows]
+    widths = [max((len(c) for c in cs), default=0) for cs in zip(*rows)]
+    return b_(*([fw_(c, w=w + buffer-1) for c, w in zip(cs, widths)] for cs in rows))
+
 
 
 def redent(text, n=0, tw=2, stripline=True, keep_leading=False):
@@ -29,3 +134,26 @@ def redent(text, n=0, tw=2, stripline=True, keep_leading=False):
         default=0))
     # rejoin the text with the proper indent
     return '\n'.join([n * tw * ' ' + l[m:] for l in lines])
+
+
+if __name__ == '__main__':
+    print(red('this should be red'))
+    print(blue('this should be blue'))
+    print(green('this should be green'))
+    print(yellow('this should be yellow'))
+    print(underline('this should be underline'))
+
+    print()
+    print(b_(
+        ('hi', blue('im blue'), 56),
+        'okay',
+        '',
+        red('bloop'),
+    ))
+
+    print()
+    print(block_text(
+        l_('hiiii', red('okay')),
+        bold('well'),
+        green('alright'),
+    ))