neoprint 0.1.0__py3-none-any.whl

neoprint/__init__.py

@@ -0,0 +1,33 @@
+from . import text_object
+from .config import config
+from .console import bprint
+from .console import console
+from .control import setup
+from .debugger import debugger
+from .format import format
+from .format import format_list
+from .frame_info import FrameInfo
+from .progress import Progress
+from .progress import ProgressItem
+from .progress import Spinner
+from .progress import progress
+from .progress import spinner
+from .scope import scope
+from .show import debug
+from .show import divider
+from .show import error
+from .show import exception
+from .show import expand
+from .show import expand2
+from .show import index
+from .show import info
+from .show import show
+from .show import show as print
+from .show import success
+from .show import vshow
+from .show import warning
+from .text_object import Markdown
+from .text_object import RichObject
+from .text_object import Text
+
+__version__ = '0.1.0'

neoprint/config.py

@@ -0,0 +1,135 @@
+import os
+import sys
+import typing as tp
+from sys import excepthook as _default_excepthook
+
+from rich.traceback import Traceback
+
+from .console import console
+from .console import rich_console
+from .debugger import debugger
+
+
+class _Config:
+    clear_unfinished_stream: bool
+    console_width: int
+    debug_output: bool
+    disable_varnames: bool
+    #   if source code is obfuscated, disable parsing varnames.
+    #   this is usually used with `pyportable-crypto` library.
+    legacy_windows: bool
+    #   if true, decrease console color effect.
+    multiline_indent: int
+    path_style: tp.Literal['filename', 'relpath'] = 'filename'
+    #   'relpath' (default): show relative path.
+    #       for external libraries, will show `[lib_name]/relpath:lineno`
+    #   'filename': show only filename.
+    #       for external libraries, will show `[lib_name]/filename:lineno`
+    rich_traceback: bool
+    show_funcname: bool
+    show_source: bool
+    #   attach source file path and line number info prefixed to the log -
+    #   messages.
+    #   True example:
+    #       'main.py:10  >>  hello world'
+    #   False example:
+    #       'hello world'
+    show_traceback_locals: bool
+    show_varnames: bool
+    #   show both variable names and values. (magic reflection)
+    #   example:
+    #       a, b = 1, 2
+    #       logger.log(a, b, a + b)
+    #       # enabled: 'main.py:11  >>  a = 1; b = 2; a + b = 3'
+    #       # disabled: 'main.py:11  >>  1, 2, 3'
+    show_verbosity_tag: bool
+    #   example: print(':v8', 'some error happens')
+    #   enabled: (red text) '[ERROR] some error happens'
+    #   disabled: (red text) 'some error happens'
+    sourcemap_alignment: tp.Literal['left', 'right'] = 'left'
+    subthreaded: bool
+    #   run lk logger in separate thread.
+
+    _preset_conf: tp.Dict[str, tp.Union[bool, int, str]] = {
+        'clear_unfinished_stream': False,
+        'console_width': console.width,
+        'debug_output': False,
+        'disable_varnames': os.getenv('NEOPRINT_DISABLE_VARNAMES') == '1',
+        'legacy_windows': os.getenv('NEOPRINT_LEGACY_WINDOWS') == '1',
+        'multiline_indent': 2,
+        'path_style': 'relpath',
+        'rich_traceback': True,
+        'show_funcname': False,
+        'show_source': True,
+        'show_traceback_locals': False,
+        'show_varnames': False,
+        'show_verbosity_tag': False,
+        'sourcemap_alignment': 'left',
+        'subthreaded': False,
+    }
+
+    def __init__(self) -> None:
+        for k, v in self._preset_conf.items():
+            setattr(self, k, v)
+        assert self.rich_traceback
+        sys.excepthook = self._custom_excepthook
+
+    def __call__(self, **kwargs) -> None:
+        for k, v in kwargs.items():
+            assert hasattr(self, k), k
+            self._apply(k, v)
+
+    def reset(self) -> None:
+        for k, v in self._preset_conf.items():
+            if getattr(self, k, None) != v:  # if None type, always skip it.
+                # assert v is not None
+                self._apply(k, v)
+
+    def _apply(self, key: str, val: tp.Union[bool, int, str]) -> None:
+        setattr(self, key, val)
+        if key == 'console_width':
+            assert isinstance(val, int)
+            console.width = val
+        elif key == 'debug_output':
+            assert isinstance(val, bool)
+            debugger.enabled = val
+        elif key == 'disable_varnames':
+            os.environ['NEOPRINT_DISABLE_VARNAMES'] = '1' if val else '0'
+        elif key == 'legacy_windows':
+            os.environ['NEOPRINT_LEGACY_WINDOWS'] = '1' if val else '0'
+        elif key == 'rich_traceback':
+            # assert isinstance(val, bool)
+            if val:
+                sys.excepthook = self._custom_excepthook
+            else:
+                sys.excepthook = _default_excepthook
+
+    def _custom_excepthook(self, type_, value, traceback) -> None:
+        # print(':r', '[red dim]drain out message queue[/]')
+        # from .logger import logger
+        # if hasattr(logger, '_stop_running'):
+        #     logger._stop_running()  # noqa
+        if type_ is KeyboardInterrupt:
+            # fmt: off
+            from .show import show
+            show(':v7', 'KeyboardInterrupt')
+            sys.exit(0)
+            # fmt: on
+        else:
+            # https://rich.readthedocs.io/en/stable/traceback.html
+            # dprint(getattr(self, 'show_traceback_locals'))
+            rich_console.print(
+                Traceback.from_exception(
+                    type_,
+                    value,
+                    traceback,
+                    show_locals=self.show_traceback_locals,
+                    locals_hide_dunder=True,
+                    locals_hide_sunder=True,
+                    # word_wrap=True,
+                ),
+                soft_wrap=False,  # fixed line wrap problem.
+            )
+
+
+config = _Config()

neoprint/console.py

@@ -0,0 +1,81 @@
+import builtins
+import os
+import sys
+import typing as tp
+from rich.console import Console as RichConsole
+from .debugger import debugger
+
+_stdout = sys.stdout
+
+
+class Console:
+    def __init__(self) -> None:
+        self.width = self.get_console_width()
+
+    def get_console_width(self) -> int:
+        if hasattr(sys.stdout, 'columns'):
+            columns = sys.stdout.columns
+            if columns:
+                return int(columns)  # type: ignore
+        if hasattr(os, 'get_terminal_size'):
+            try:
+                size = os.get_terminal_size()
+                if size.columns > 0:
+                    return int(size.columns)
+            except OSError:
+                pass
+        fallback = os.environ.get('COLUMNS', '')
+        if fallback.isdigit():
+            return int(fallback)
+        return 80
+
+    def print(self, text: str, end: str = '\n', flush: bool = False) -> None:
+        if debugger.enabled:
+            debugger.output.append(text)
+        _stdout.write(text + end)
+        if flush:
+            _stdout.flush()
+
+
+class _LegacyRichConsole(RichConsole):
+    def __init__(self) -> None:
+        # https://github.com/Textualize/rich/issues/2622
+        super().__init__(
+            color_system='standard' if os.name == 'nt' else 'auto',
+            legacy_windows=True,
+        )
+
+    def capture_output(self, *args, **kwargs) -> str:
+        # https://chatgpt.com/share/6a16a585-0e00-8320-97ee-5fc2b572690e
+        with self.capture() as cap:
+            self.print(*args, **kwargs)
+        return cap.get()
+
+
+class _ModernRichConsole(_LegacyRichConsole):
+    def __init__(self) -> None:
+        RichConsole.__init__(
+            self,
+            color_system='standard' if os.name == 'nt' else 'auto',
+            legacy_windows=False,  # make sure ansi color is used
+        )
+
+
+console = Console()
+# CONSOLE_WIDTH = console.width
+rich_console = _ModernRichConsole()
+legacy_rich_console = _LegacyRichConsole()
+
+std_print = tp.cast(tp.Callable, builtins.print)
+con_print = console.print
+# con_error = partial(console.print_exception, word_wrap=True)
+dbg_print = debugger.print
+# non_print = NothingPrinter()
+
+# alias
+bprint = std_print
+cprint = con_print
+dprint = dbg_print
+
+# default alias
+# print = con_print

neoprint/control.py

@@ -0,0 +1,23 @@
+import builtins
+
+from .console import bprint
+from .frame_info import get_last_frame
+from .show import show
+
+effected_packages = set()
+
+
+def setup(scope: str = 'this_package') -> None:
+    assert scope == 'this_package', f'scope `{scope}` is not supported'
+    frame = get_last_frame()
+    effected_packages.add(frame.package_name)
+    if getattr(builtins, 'print') is bprint:
+        setattr(builtins, 'print', _variable_print)
+
+
+def _variable_print(*args, **kwargs) -> None:
+    frame = get_last_frame()
+    if frame.package_name in effected_packages:
+        show(*args, _frame=frame, **kwargs)
+    else:
+        bprint(*args, **kwargs)

neoprint/debugger.py

@@ -0,0 +1,18 @@
+from inspect import currentframe
+from rich.pretty import pprint
+from .frame_info import FrameInfo
+
+
+class _Debugger:
+    def __init__(self) -> None:
+        self.enabled = False
+        self.output = []
+
+    def print(self, *args) -> None:
+        frame = FrameInfo(currentframe().f_back)  # type: ignore
+        pprint(
+            ('[debug]:{}:{}'.format(frame.file_name, frame.line_number), *args)
+        )
+
+
+debugger = _Debugger()

neoprint/format.py

@@ -0,0 +1,224 @@
+import typing as tp
+from inspect import currentframe
+
+from . import text_object as to
+from .config import config
+from .console import dprint  # noqa
+from .frame_info import FrameInfo
+from .markup import Mark
+from .markup import markup_analyzer
+
+
+class T:  # Typehint
+    Args = tp.Tuple[tp.Any, ...]
+    FlushScheme = int
+    #   0: no flush
+    #   1: instant flush
+    #   2: instant flush and drain
+    #   3: wait for flush
+    Marks = tp.Dict[str, tp.Any]
+    Markup = str
+    MarkupPos = int  # -1, 0, 1
+
+
+def format_list(
+    *args,
+    markup: tp.Optional[T.Markup] = None,
+    _elevate_parent_level: int = 0,
+    _frame: tp.Optional[FrameInfo] = None,
+    _mark_position: int = 0,
+) -> tp.List[to.TextObject]:
+    """
+    frame relationship:
+        this_frame: frame to this function.
+        foreign_frame: frame to first call of foreign function.
+            for example:
+                1.
+                    # aaa.py
+                    import neoprint as np  # ln1
+                    np.format_list(...)  # ln2
+                    # foreign_frame is `aaa.py:2`
+                2. 
+                    # neoprint/show.py
+                    def show(...):
+                        x = format_list(
+                            ..., _frame=FrameInfo(currentframe().f_back)
+                        )
+                        # foreign_frame is the one who is calling `show(...)`.
+        target_frame: frame to the most proper place.
+            if ':p' markup is not used, target_frame is foreign_frame.
+            if ':p' markup is set, target_frame = `foreign_frame.f_back_to_:p`.
+        
+        how does caller make foreign_frame:
+            caller can set _frame directly, or set _elevate_parent_level.
+            the following are same:
+                def foo():
+                    format_list(..., _frame=FrameInfo(currentframe().f_back))
+                def bar():
+                    format_list(..., _elevate_parent_level=1)
+            if both params are set, _frame will be used.
+    """
+    if _frame is None:
+        this_frame = FrameInfo(currentframe())  # type: ignore
+        foreign_frame = this_frame.get_parent(1 + _elevate_parent_level)
+    else:
+        foreign_frame = _frame
+    target_frame = foreign_frame
+
+    if markup is None:
+        args, markpos, markup = extract_markup_from_arguments(args)
+    else:
+        markpos = _mark_position
+    # dprint(args, markup, args[-1], markup_analyzer.is_valid_markup(args[-1]))
+    marks = markup_analyzer.analyze(markup, foreign_frame)
+    
+    if marks['p']:
+        target_frame = foreign_frame.get_parent(marks['p'])
+        assert target_frame
+
+    # --------------------------------------------------------------------------
+
+    result = []
+
+    # head part
+    head_parts = get_head_parts(target_frame)
+    result.extend(head_parts)
+
+    # --------------------------------------------------------------------------
+
+    # body part
+    before_body_parts = []
+    body_parts = []
+
+    if marks['i']:
+        before_body_parts.append(to.Index(marks['i']))
+        before_body_parts.append(to.Space())
+
+    if marks['n']:
+        varnames = foreign_frame.varnames
+        if markpos:
+            varnames = varnames[1:] if markpos == 1 else varnames[:-1]
+        # assert len(varnames) == len(args), (varnames, args)
+        if len(varnames) != len(args):
+            # this may because user has modified the source code after call.
+            # we should refresh the AST to get new varnames.
+            foreign_frame.refresh()
+            varnames = foreign_frame.varnames
+            assert len(varnames) == len(args), (varnames, args)
+    else:
+        varnames = (None,) * len(args)
+
+    for name, arg in zip(varnames, args):
+        if name is None:
+            body_parts.append(to.Text(arg))
+        else:
+            body_parts.append(to.NamedVariable(name, arg))
+        body_parts.append(to.InBodySeparator())
+        body_parts.append(to.Space())
+    body_parts = body_parts[:-2]
+
+    if marks['l'] or marks['r']:
+        # there are three cases:
+        #   l1 and r*: expand object
+        #   l2 or r2: special expand object
+        #   l0 and r1: bbcode object
+        if marks['l'] == Mark.EXPAND_FORMAT:
+            body_parts = [
+                to.ExpandedObject(x)
+                if to.ExpandedObject.check_expandable(x)
+                else x
+                for x in body_parts
+            ]
+        elif (
+            marks['l'] == Mark.SPECIAL_EXPAND_FORMAT
+            or marks['r'] == Mark.RICH_OBJECT
+        ):
+            body_parts = [
+                to.SpecialExpandedObject(x)
+                if to.SpecialExpandedObject.check_expandable(x)
+                else to.ExpandedObject(x)
+                if to.ExpandedObject.check_expandable(x)
+                else x
+                for x in body_parts
+            ]
+        elif marks['r'] == Mark.RICH_FORMAT:
+            ...  # TODO
+        else:
+            raise Exception('unreachable case')
+        body_parts = [
+            to.ExpandedObjectGroup(body_parts, head_parts + before_body_parts)
+        ]
+
+    if marks['d']:
+        body_parts = [
+            to.DividerLine(
+                body_parts,
+                head_parts + before_body_parts,
+                bold=marks['d'] == Mark.THICK_DIVIDER_LINE,
+            )
+        ]
+
+    if marks['v']:
+        global_color, global_style = marks['v']
+        for part in body_parts:
+            if part.editable:
+                # dprint(part, global_color, global_style)
+                part.color = global_color
+                part.style = global_style
+
+    result.extend(before_body_parts)
+    result.extend(body_parts)
+
+    return result
+
+
+def format(*args, markup: tp.Optional[str] = None) -> str:
+    if markup is None:
+        args, markpos, markup = extract_markup_from_arguments(args)
+    else:
+        markpos, markup = 0, markup
+    result = format_list(
+        *args, markup=markup, _elevate_parent_level=1, _mark_position=markpos
+    )
+    return ''.join(p.render(color_code_scheme='none') for p in result)
+
+
+# ------------------------------------------------------------------------------
+
+
+def extract_markup_from_arguments(
+    args: T.Args,
+) -> tp.Tuple[T.Args, int, T.Markup]:
+    if (
+        len(args) > 0
+        and isinstance(args[0], str)
+        and args[0].startswith(':')
+        and markup_analyzer.is_valid_markup(args[0])
+    ):
+        return args[1:], 1, args[0]
+    elif (
+        len(args) > 1
+        and isinstance(args[-1], str)
+        and args[-1].startswith(':')
+        and markup_analyzer.is_valid_markup(args[-1])
+    ):
+        return args[:-1], -1, args[-1]
+    else:
+        return args, 0, ''
+
+
+def get_head_parts(frame: FrameInfo) -> tp.List[to.TextObject]:
+    out = []
+    if config.show_source:
+        out.append(to.Source(frame))
+    if config.show_funcname:
+        if out:
+            out.append(to.Space())
+            out.append(to.FuncnameSeparator())
+            out.append(to.Space())
+        out.append(...)  # TODO
+    if out:
+        out.append(to.Space())
+        out.append(to.BodySeparator())
+        out.append(to.Space())
+    return out

neoprint/frame_info.py

@@ -0,0 +1,100 @@
+import inspect
+import typing as tp
+from textwrap import dedent
+from types import FrameType
+
+from . import sourcemap
+
+
+class FrameInfo:
+    file_name: str
+    file_path: str
+    function_name: str
+    line_number: int
+    package_name: str
+    _frame: FrameType
+    _varnames: tp.Optional[tp.Tuple[tp.Optional[str], ...]]
+
+    @classmethod
+    def this_place(cls) -> 'FrameInfo':
+        return cls(inspect.currentframe().f_back)  # type: ignore
+
+    @classmethod
+    def parent_place(cls) -> 'FrameInfo':
+        return cls(inspect.currentframe().f_back.f_back)  # type: ignore
+
+    def __init__(self, frame: FrameType) -> None:
+        self._frame = frame
+        self.refresh()
+
+    def __str__(self) -> str:
+        return self.info
+
+    @property
+    def id(self) -> str:
+        return f'{self.file_path}:{self.line_number}'
+
+    @property
+    def indentation(self) -> int:
+        # https://stackoverflow.com/a/39172552
+        if x := inspect.getframeinfo(self._frame).code_context:
+            ctx = x[0]
+            return len(ctx) - len(ctx.lstrip())
+        return 0
+
+    @property
+    def info(self) -> str:
+        return dedent(
+            f"""
+            <FrameInfo object
+                filepath: {self.file_path}
+                lineno: {self.line_number}
+                funcname: {self.function_name}
+            >
+            """
+        ).rstrip()
+
+    @property
+    def parent(self) -> 'FrameInfo':
+        return self.get_parent(1)
+
+    @property
+    def varnames(self) -> tp.Sequence[tp.Optional[str]]:
+        if self._varnames is None:
+            self._varnames = tuple(self.collect_varnames())
+        return self._varnames
+
+    def collect_varnames(self) -> tp.Sequence[tp.Optional[str]]:
+        return sourcemap.get_varnames(self.file_path, self.line_number)
+
+    def get_parent(self, traceback_level: int = 1) -> 'FrameInfo':
+        frame = self._frame
+        for _ in range(traceback_level):
+            frame = frame.f_back  # type: ignore
+        return FrameInfo(frame)  # type: ignore
+
+    def refresh(self) -> None:
+        frame = self._frame
+        self.function_name = frame.f_code.co_name
+        self.package_name = frame.f_globals['__name__'].split('.', 1)[0]
+        self.file_path = (
+            frame.f_globals.get('__file__', frame.f_code.co_filename)
+            #   note:
+            #   - path may be "<string>", "<unknown>" etc.
+            #   - path may be "<ipython-input-10-5abb16185f48>" in ipython
+            #   environment.
+            #   - `co_filename` may be a relative python in python 3.8.
+            #   - path may not exist.
+        ).replace('\\', '/')
+        self.file_name = (
+            self.file_path
+            if self.file_path[0] == '<'
+            else self.file_path.rsplit('/', 1)[-1]
+        )
+        self.line_number = frame.f_lineno
+        self._varnames = None
+
+
+def get_last_frame() -> FrameInfo:
+    frame = inspect.currentframe().f_back.f_back  # type: ignore
+    return FrameInfo(frame)  # type: ignore