streamdown 0.12.0__tar.gz → 0.13.0__tar.gz

{streamdown-0.12.0 → streamdown-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamdown
-Version: 0.12.0
+Version: 0.13.0
 Summary: A streaming markdown renderer for modern terminals with syntax highlighting
 Project-URL: Homepage, https://github.com/kristopolous/Streamdown
 Project-URL: Bug Tracker, https://github.com/kristopolous/Streamdown/issues
@@ -109,6 +109,31 @@ Width = 120
 Timeout = 1.0
 ```
 
+## Invocation
+The most exciting feature here is `--exec` with it you can do full readline support like this:
+
+     $ sd --exec "llm chat"
+
+And now you have all your readline stuff. It's pretty great.
+
+```shell
+Streamdown - A markdown renderer for modern terminals
+
+positional arguments:
+  filenameList          Input file to process (also takes stdin)
+
+options:
+  -h, --help            show this help message and exit
+  -l LOGLEVEL, --loglevel LOGLEVEL
+                        Set the logging level
+  -c COLOR, --color COLOR
+                        Set the hsv base: h,s,v
+  -w WIDTH, --width WIDTH
+                        Set the width
+  -e EXEC, --exec EXEC  Wrap a program for more 'proper' i/o handling
+
+```
+
 ## Demo
 Do this
 
@@ -131,5 +156,3 @@ I'm really considering using `tinycss2` and making an actual stylesheet engine.
 #### scrape
 This is already partially implemented. The idea is every code block can get extracted and put in a directory so you can have a conversation to generate every piece of a project, similar to Aider, Claude or Goose,  but in the most hands-off yet still convenient way possible.
 
-#### exec
-I'm trying to get a readline capable wrapper so that interaction is as transparent as possible. After many days of research I've given up on trying to hack it through tty/pty hijacking and pipes and decided it has to be a standard wrapper. This should be low effort.

{streamdown-0.12.0 → streamdown-0.13.0}/README.md

@@ -81,6 +81,31 @@ Width = 120
 Timeout = 1.0
 ```
 
+## Invocation
+The most exciting feature here is `--exec` with it you can do full readline support like this:
+
+     $ sd --exec "llm chat"
+
+And now you have all your readline stuff. It's pretty great.
+
+```shell
+Streamdown - A markdown renderer for modern terminals
+
+positional arguments:
+  filenameList          Input file to process (also takes stdin)
+
+options:
+  -h, --help            show this help message and exit
+  -l LOGLEVEL, --loglevel LOGLEVEL
+                        Set the logging level
+  -c COLOR, --color COLOR
+                        Set the hsv base: h,s,v
+  -w WIDTH, --width WIDTH
+                        Set the width
+  -e EXEC, --exec EXEC  Wrap a program for more 'proper' i/o handling
+
+```
+
 ## Demo
 Do this
 
@@ -103,5 +128,3 @@ I'm really considering using `tinycss2` and making an actual stylesheet engine.
 #### scrape
 This is already partially implemented. The idea is every code block can get extracted and put in a directory so you can have a conversation to generate every piece of a project, similar to Aider, Claude or Goose,  but in the most hands-off yet still convenient way possible.
 
-#### exec
-I'm trying to get a readline capable wrapper so that interaction is as transparent as possible. After many days of research I've given up on trying to hack it through tty/pty hijacking and pipes and decided it has to be a standard wrapper. This should be low effort.

{streamdown-0.12.0 → streamdown-0.13.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "streamdown"
-version = "0.12.0"
+version = "0.13.0"
 description = "A streaming markdown renderer for modern terminals with syntax highlighting"
 readme = "README.md"
 requires-python = ">=3.8"

{streamdown-0.12.0 → streamdown-0.13.0}/streamdown/sd.py

@@ -12,6 +12,7 @@ import appdirs, toml
 import logging, tempfile
 import os,      sys
 import pty,     select
+import termios, tty
 
 import math
 import re
@@ -20,6 +21,7 @@ import subprocess
 import traceback
 import colorsys
 import base64
+import importlib
 from io import BytesIO
 import pygments.util
 from argparse import ArgumentParser
@@ -28,7 +30,10 @@ from pygments.lexers import get_lexer_by_name
 from pygments.formatters import Terminal256Formatter
 from pygments.styles import get_style_by_name
 
-from .plugins import latex
+if __package__ is None:
+    from plugins import latex
+else:
+    from .plugins import latex
 
 default_toml = """
 [features]
@@ -77,7 +82,8 @@ UNDERLINE = ["\033[4m", "\033[24m"]
 ITALIC    = ["\033[3m", "\033[23m"]
 
 ESCAPE = r"\033\[[0-9;]*[mK]"
-ANSIESCAPE = r"\033(\[[0-9;]*[mK]|][0-9]*;;.*?\\|\\)"
+ANSIESCAPE = r'\033(?:\[[0-9;?]*[a-zA-Z]|][0-9]*;;.*?\\|\\)'
+#r"\033(\[[0-9;]*[mK]|][0-9]*;;.*?\\|\\)"
 KEYCODE_RE = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
 
 visible = lambda x: re.sub(ANSIESCAPE, "", x)
@@ -114,15 +120,18 @@ class ParseState:
         self.first_line = True
         self.last_line_empty = False
         self.is_pty = False
+        self.is_exec = False
         self.maybe_prompt = False
         self.emit_flag = None
         self.scrape = None
         self.scrape_ix = 0
+        self.terminal = None
 
         self.CodeSpaces = _features.get("CodeSpaces")
         self.Clipboard = _features.get("Clipboard")
         self.Logging = _features.get("Logging")
         self.Timeout = _features.get("Timeout")
+        self.WidthArg = None
 
         # If the entire block is indented this will
         # tell us what that is
@@ -150,7 +159,13 @@ class ParseState:
         self.in_italic = False
         self.in_table = False # (Code.[Header|Body] | False)
         self.in_underline = False
-        self.in_blockquote = False
+        self.block_depth = 0
+
+        self.exec_sub = None
+        self.exec_master = None
+        self.exec_slave = None
+        self.exec_kb = 0
+        self.exec_israw = False
 
         self.exit = 0
         self.where_from = None
@@ -161,7 +176,7 @@ class ParseState:
         return state
 
     def space_left(self):
-        return (MARGIN_SPACES if len(self.current_line) == 0 else "") + (BQUOTE if self.in_blockquote else "")
+        return (Style.MarginSpaces if len(self.current_line) == 0 else "") + (Style.Blockquote * self.block_depth)
 
 state = ParseState()
 
@@ -210,7 +225,7 @@ def format_table(rowList):
         # Correct indentation: This should be outside the c_idx loop
         joined_line = f"{BG}{bg_color}{extra}{FG}{Style.Symbol}│{RESET}".join(line_segments)
         # Correct indentation and add missing characters
-        yield f"{MARGIN_SPACES}{joined_line}{RESET}"
+        yield f"{Style.MarginSpaces}{joined_line}{RESET}"
 
     state.bg = BGRESET
 
@@ -218,21 +233,21 @@ def emit_h(level, text):
     text = line_format(text)
     spaces_to_center = ((state.Width - visible_length(text)) / 2)
     if level == 1:      #
-        return f"\n{MARGIN_SPACES}{BOLD[0]}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{BOLD[1]}\n"
+        return f"\n{Style.MarginSpaces}{BOLD[0]}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{BOLD[1]}\n"
     elif level == 2:    ##
-        return f"\n{MARGIN_SPACES}{BOLD[0]}{FG}{Style.Bright}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{RESET}\n\n"
+        return f"\n{Style.MarginSpaces}{BOLD[0]}{FG}{Style.Bright}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{RESET}\n\n"
     elif level == 3:    ###
-        return f"{MARGIN_SPACES}{FG}{Style.Head}{BOLD[0]}{text}{RESET}"
+        return f"{Style.MarginSpaces}{FG}{Style.Head}{BOLD[0]}{text}{RESET}"
     elif level == 4:    ####
-        return f"{MARGIN_SPACES}{FG}{Style.Symbol}{text}{RESET}"
+        return f"{Style.MarginSpaces}{FG}{Style.Symbol}{text}{RESET}"
     else:  # level 5 or 6
-        return f"{MARGIN_SPACES}{text}{RESET}"
+        return f"{Style.MarginSpaces}{text}{RESET}"
 
 def code_wrap(text_in):
     # get the indentation of the first line
     indent = len(text_in) - len(text_in.lstrip())
     text = text_in.lstrip()
-    mywidth = state.FullWidth - indent
+    mywidth = state.WidthFull - indent
 
     # We take special care to preserve empty lines
     if len(text) == 0:
@@ -378,11 +393,39 @@ def parse(stream):
     byte = None
     TimeoutIx = 0
     while True:
-        if state.is_pty:
+        if state.is_pty or state.is_exec:
             byte = None
-            ready, _, _ = select.select([stream.fileno()], [], [], state.Timeout)
+            ready_in, _, _ = select.select(
+                    [stream.fileno(), state.exec_master], [], [], state.Timeout)
+
+            if state.is_exec: 
+                # This is keyboard input
+                if stream.fileno() in ready_in:
+                    byte = os.read(stream.fileno(), 1)
+
+                    state.exec_kb += 1
+                    os.write(state.exec_master, byte)
+
+                    if byte == b'\n':
+                        state.buffer = b''
+                        print("")
+                        state.exec_kb = 0
+                    else:
+                        continue
 
-            if stream.fileno() in ready: 
+                if state.exec_master in ready_in:
+                    TimeoutIx = 0
+                    byte = os.read(state.exec_master, 1)
+
+                    if state.exec_kb:
+                        os.write(sys.stdout.fileno(), byte)
+
+                if len(ready_in) == 0:
+                    TimeoutIx += 1
+                
+
+
+            elif stream.fileno() in ready_in: 
                 byte = os.read(stream.fileno(), 1)
                 TimeoutIx = 0
             elif TimeoutIx == 0:
@@ -402,14 +445,15 @@ def parse(stream):
 
         line = state.buffer.decode('utf-8')
         state.has_newline = line.endswith('\n')
-        state.maybe_prompt = not state.has_newline and state.current()['none'] and re.match(r'^.*>\s+$', line)
+        # I hate this. There should be better ways.
+        state.maybe_prompt = not state.has_newline and state.current()['none'] and re.match(r'^.*>\s+$', visible(line))
 
         # let's wait for a newline
         if state.maybe_prompt:
             state.emit_flag = Code.Flush
             yield line
+            state.current_line = ''
             state.buffer = b''
-            continue
 
         if not state.has_newline:
             continue
@@ -447,7 +491,7 @@ def parse(stream):
         else:
             state.in_list = False
 
-        if state.first_indent == None:
+        if state.first_indent is None:
             state.first_indent = len(line) - len(line.lstrip())
         if len(line) - len(line.lstrip()) >= state.first_indent:
             line = line[state.first_indent:]
@@ -462,13 +506,21 @@ def parse(stream):
         if state.in_table and not state.in_code and not re.match(r"^\s*\|.+\|\s*$", line):
             state.in_table = False
 
-        block_match = re.match(r"^<.?think>$", line)
+        block_match = re.match(r"^((> )*|<.?think>)", line)
         if block_match:
-            state.in_blockquote = not state.in_blockquote
-            # consume and don't emit
-            if not state.in_blockquote:
-                yield( RESET)
-            continue
+            if block_match.group(1) == '</think>':
+                state.block_depth = 0
+                yield(RESET)
+            elif block_match.group(1) == '<think>':
+                state.block_depth = 1
+            else:
+                state.block_depth = int(len(block_match.group(0)) / 2)
+                # we also need to consume those tokens
+                line = line[state.block_depth * 2:]
+        else:
+            if state.block_depth > 0:
+                yield RESET
+                state.block_depth = 0
 
         #
         # <code><pre>
@@ -532,7 +584,7 @@ def parse(stream):
 
 
                     if code_type == Code.Backtick:
-                        continue
+                            continue
                     else:
                         # otherwise we don't want to consume
                         # nor do we want to be here.
@@ -600,10 +652,10 @@ def parse(stream):
 
                     code_line = ' ' * indent + this_batch.strip()
 
-                    margin = state.FullWidth - visible_length(code_line)
+                    margin = state.WidthFull - visible_length(code_line)
                     yield f"{Style.Codebg}{code_line}{' ' * max(0, margin)}{BGRESET}"  
                 continue
-            except Goto as ex:
+            except Goto:
                 pass
             
             except Exception as ex:
@@ -694,7 +746,7 @@ def parse(stream):
         if hr_match:
             if state.last_line_empty or last_line_empty_cache:
                 # print a horizontal rule using a unicode midline 
-                yield f"{MARGIN_SPACES}{FG}{Style.Symbol}{'─' * state.Width}{RESET}"
+                yield f"{Style.MarginSpaces}{FG}{Style.Symbol}{'─' * state.Width}{RESET}"
             else:
                 # We tell the next level up that the beginning of the buffer should be a flag.
                 # Underneath this condition it will no longer yield
@@ -722,6 +774,7 @@ def emit(inp):
     buffer = []
     flush = False
     for chunk in parse(inp):
+        width_calc()
         if state.emit_flag:
             if state.emit_flag == Code.Flush:
                 flush = True
@@ -770,8 +823,17 @@ def apply_multipliers(name, H, S, V):
     r, g, b = colorsys.hsv_to_rgb(min(1.0, H * m["H"]), min(1.0, S * m["S"]), min(1.0, V * m["V"]))
     return ';'.join([str(int(x * 256)) for x in [r, g, b]]) + "m"
 
+def width_calc():
+    state.WidthFull = state.WidthArg or int(get_terminal_width())
+    state.Width = state.WidthFull - 2 * Style.Margin
+    Style.Codepad = [
+        f"{RESET}{FG}{Style.Dark}{'▄' * state.WidthFull}{RESET}\n",
+        f"{RESET}{FG}{Style.Dark}{'▀' * state.WidthFull}{RESET}"
+    ]
+
 def main():
-    global H, S, V, MARGIN_SPACES
+    global H, S, V
+
     parser = ArgumentParser(description="Streamdown - A markdown renderer for modern terminals")
     parser.add_argument("filenameList", nargs="*", help="Input file to process (also takes stdin)")
     parser.add_argument("-l", "--loglevel", default="INFO", help="Set the logging level")
@@ -796,24 +858,27 @@ def main():
         os.makedirs(args.scrape, exist_ok=True)
         state.scrape = args.scrape
 
-    MARGIN_SPACES = " " * Style.Margin
-    state.FullWidth = int(args.width) or _style.get("Width") or int(get_terminal_width())
-    state.Width = state.FullWidth - 2 * Style.Margin
+    Style.MarginSpaces = " " * Style.Margin
+    state.WidthArg = int(args.width) or _style.get("Width") or 0
+    width_calc()
+
     Style.Codebg = f"{BG}{Style.Dark}"
     Style.Link = f"{FG}{Style.Symbol}{UNDERLINE[0]}"
     Style.Blockquote = f"{FG}{Style.Grey} \u258E "
 
-    Style.Codepad = [
-        f"{RESET}{FG}{Style.Dark}{'▄' * state.FullWidth}{RESET}\n",
-        f"{RESET}{FG}{Style.Dark}{'▀' * state.FullWidth}{RESET}"
-    ]
 
     logging.basicConfig(stream=sys.stdout, level=args.loglevel.upper(), format=f'%(message)s')
+    state.exec_master, state.exec_slave = pty.openpty()
     try:
         inp = sys.stdin
         if args.exec:
-            state.sub = subprocess.Popen(args.exec.split(' '), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            inp = state.sub.stdout
+            state.terminal = termios.tcgetattr(sys.stdin)
+            state.is_exec = True
+            state.exec_sub = subprocess.Popen(args.exec.split(' '), stdin=state.exec_slave, stdout=state.exec_slave, stderr=state.exec_slave, close_fds=True)
+            os.close(state.exec_slave)  # We don't need slave in parent
+            # Set stdin to raw mode so we don't need to press enter
+            tty.setcbreak(sys.stdin.fileno())
+            emit(sys.stdin)
 
         elif args.filenameList:
             # Let's say we only care about logging in streams
@@ -832,11 +897,13 @@ def main():
             os.set_blocking(inp.fileno(), False) 
             emit(inp)
 
-    except KeyboardInterrupt:
+    except (OSError, KeyboardInterrupt):
         state.exit = 130
         
     except Exception as ex:
-        logging.warning(f"Exception thrown: {ex}")
+        if state.terminal:
+            termios.tcsetattr(sys.stdin, termios.TCSADRAIN, state.terminal)
+        logging.warning(f"Exception thrown: {type(ex)} {ex}")
         traceback.print_exc()
 
     if state.Clipboard and state.code_buffer:
@@ -847,6 +914,12 @@ def main():
         base64_string = base64_bytes.decode('utf-8')
         print(f"\033]52;c;{base64_string}\a", end="", flush=True)
 
+
+    if state.terminal:
+        termios.tcsetattr(sys.stdin, termios.TCSADRAIN, state.terminal)
+        os.close(state.exec_master)
+        if state.exec_sub:
+            state.exec_sub.wait()
     sys.exit(state.exit)
 
 if __name__ == "__main__":

streamdown-0.13.0/tests/block.md

@@ -0,0 +1,10 @@
+So here is some text
+
+> and technically we are in blockquote
+> territory with these. Blockquote is one
+> > of the few things that can be embedded
+> > in markdown. Stylistically they are 
+> > different than lists, but
+> not by much.
+
+Now we are out of the blockquote