streamdown 0.13.0__tar.gz → 0.14.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamdown
-Version: 0.13.0
+Version: 0.14.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
@@ -41,7 +41,11 @@ This will work with [simonw's llm](https://github.com/simonw/llm) unlike with [r
 ### Provides clean copyable code for long code blocks and short terminals. 
 ![copyable](https://github.com/user-attachments/assets/4a3539c5-b5d1-4d6a-8bce-032724d8909d)
 
-### Does OSC 8 links for modern terminals.
+### Supports images, why not?
+Here's kitty and alacritty. Try to do that in glow...
+![doggie](https://github.com/user-attachments/assets/9a392929-b6c2-4204-b257-e09305acb7af)
+
+### Does OSC 8 links for modern terminals (and optionally OSC 52 for clipboard)
 [links.webm](https://github.com/user-attachments/assets/a5f71791-7c58-4183-ad3b-309f470c08a3)
 
 ### Doesn't consume characters like _ and * as style when they are in `blocks like this` because `_they_can_be_varaiables_`

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

@@ -13,7 +13,11 @@ This will work with [simonw's llm](https://github.com/simonw/llm) unlike with [r
 ### Provides clean copyable code for long code blocks and short terminals. 
 ![copyable](https://github.com/user-attachments/assets/4a3539c5-b5d1-4d6a-8bce-032724d8909d)
 
-### Does OSC 8 links for modern terminals.
+### Supports images, why not?
+Here's kitty and alacritty. Try to do that in glow...
+![doggie](https://github.com/user-attachments/assets/9a392929-b6c2-4204-b257-e09305acb7af)
+
+### Does OSC 8 links for modern terminals (and optionally OSC 52 for clipboard)
 [links.webm](https://github.com/user-attachments/assets/a5f71791-7c58-4183-ad3b-309f470c08a3)
 
 ### Doesn't consume characters like _ and * as style when they are in `blocks like this` because `_they_can_be_varaiables_`

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

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

streamdown-0.14.0/streamdown/scrape/file_0.py

@@ -0,0 +1,22 @@
+def fizzbuzz(n):
+for i in range(1, n + 1):
+if i % 3 == 0 and i % 5 == 0:
+print("FizzBuzz")
+elif i % 3 == 0:
+print("Fizz")
+elif i % 5 == 0:
+print("Buzz")
+else:
+print(i)
+
+# Example usage: Print FizzBuzz up to 100 Example usage: Print FizzBuzz up to 100 Example usage: Print FizzBuzz up to 100 Example usage: Print FizzBuzz up to 100
+fizzbuzz(100)
+
+#  Example usage: different range:
+fizzbuzz(20)
+
+#Example usage:  one line output (list comprehension)
+def fizzbuzz_oneline(n):
+print(["FizzBuzz" if i%3==0 and i%5==0 else "Fizz" if i%3==0 else "Buzz" if i%5==0 else i for i in range(1,n+1)])
+
+fizzbuzz_oneline(30)

streamdown-0.14.0/streamdown/scrape/file_1.js

@@ -0,0 +1,27 @@
+function fizzBuzz(n) {
+for (let i = 1; i <= n; i++) {
+if (i % 3 === 0 && i % 5 === 0) {
+console.log("FizzBuzz");
+} else if (i % 3 === 0) {
+console.log("Fizz");
+} else if (i % 5 === 0) {
+console.log("Buzz");
+} else {
+console.log(i);
+}
+}
+}
+
+// Example usage:
+fizzBuzz(100);
+
+// Example usage: different range
+fizzBuzz(25);
+
+// Example one-line output. (arrow function & ternary operator)
+const fizzBuzzOneLine = n => {
+for (let i = 1; i <= n; i++) {
+console.log((i % 3 === 0 ? (i % 5 === 0 ? "FizzBuzz" : "Fizz") : (i % 5 === 0 ? "Buzz" : i)));
+}
+};
+fizzBuzzOneLine(30);

streamdown-0.14.0/streamdown/scrape/file_2.cpp

@@ -0,0 +1,23 @@
+#include <iostream>
+
+void fizzBuzz(int n) {
+for (int i = 1; i <= n; i++) {
+if (i % 3 == 0 && i % 5 == 0) {
+std::cout << "FizzBuzz" << std::endl;
+} else if (i % 3 == 0) {
+std::cout << "Fizz" << std::endl;
+} else if (i % 5 == 0) {
+std::cout << "Buzz" << std::endl;
+} else {
+std::cout << i << std::endl;
+}
+}
+}
+
+int main() {
+fizzBuzz(100);
+
+// Example usage: different range
+fizzBuzz(35);
+return 0;
+}

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

@@ -5,6 +5,7 @@
 #     "pygments",
 #     "pylatexenc",
 #     "appdirs",
+#     "term-image",
 #     "toml"
 # ]
 # ///
@@ -23,6 +24,7 @@ import colorsys
 import base64
 import importlib
 from io import BytesIO
+from term_image.image import from_file, from_url
 import pygments.util
 from argparse import ArgumentParser
 from pygments import highlight
@@ -52,7 +54,7 @@ Dark    = { H = 1.00, S = 1.50, V = 0.25 }
 Mid     = { H = 1.00, S = 1.00, V = 0.50 }
 Symbol  = { H = 1.00, S = 1.00, V = 1.50 }
 Head    = { H = 1.00, S = 2.00, V = 1.50 }
-Grey    = { H = 1.00, S = 0.12, V = 1.25 }
+Grey    = { H = 1.00, S = 0.25, V = 1.37 }
 Bright  = { H = 1.00, S = 2.00, V = 2.00 }
 Syntax  = "monokai"
 """
@@ -80,10 +82,11 @@ BGRESET = "\033[49m"
 BOLD      = ["\033[1m", "\033[22m"]
 UNDERLINE = ["\033[4m", "\033[24m"]
 ITALIC    = ["\033[3m", "\033[23m"]
+STRIKEOUT = ["\033[9m", "\033[29m"]
+SUPER     = [ 0x2070, 0x00B9, 0x00B2, 0x00B3, 0x2074, 0x2075, 0x2076, 0x2077, 0x2078, 0x2079 ]
 
 ESCAPE = r"\033\[[0-9;]*[mK]"
 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)
@@ -131,7 +134,10 @@ class ParseState:
         self.Clipboard = _features.get("Clipboard")
         self.Logging = _features.get("Logging")
         self.Timeout = _features.get("Timeout")
+
         self.WidthArg = None
+        self.WidthFull = None
+        self.WidthWrap = False
 
         # If the entire block is indented this will
         # tell us what that is
@@ -159,24 +165,27 @@ class ParseState:
         self.in_italic = False
         self.in_table = False # (Code.[Header|Body] | False)
         self.in_underline = False
+        self.in_strikeout = 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
 
     def current(self):
-        state = { 'code': self.in_code, 'bold': self.in_bold, 'italic': self.in_italic, 'underline': self.in_underline }
+        state = { 'inline': self.inline_code, 'code': self.in_code, 'bold': self.in_bold, 'italic': self.in_italic, 'underline': self.in_underline }
         state['none'] = all(item is False for item in state.values())
         return state
 
+    def reset_inline(self):
+        self.inline_code = self.in_bold = self.in_italic = self.in_underline = False
+
     def space_left(self):
-        return (Style.MarginSpaces if len(self.current_line) == 0 else "") + (Style.Blockquote * self.block_depth)
+        return Style.MarginSpaces + (Style.Blockquote * self.block_depth) if len(self.current_line) == 0 else "" 
 
 state = ParseState()
 
@@ -233,17 +242,20 @@ def emit_h(level, text):
     text = line_format(text)
     spaces_to_center = ((state.Width - visible_length(text)) / 2)
     if level == 1:      #
-        return f"\n{Style.MarginSpaces}{BOLD[0]}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{BOLD[1]}\n"
+        return f"\n{state.space_left()}{BOLD[0]}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{BOLD[1]}\n"
     elif level == 2:    ##
-        return f"\n{Style.MarginSpaces}{BOLD[0]}{FG}{Style.Bright}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{RESET}\n\n"
+        return f"\n{state.space_left()}{BOLD[0]}{FG}{Style.Bright}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{RESET}\n\n"
     elif level == 3:    ###
-        return f"{Style.MarginSpaces}{FG}{Style.Head}{BOLD[0]}{text}{RESET}"
+        return f"{state.space_left()}{FG}{Style.Head}{BOLD[0]}{text}{RESET}"
     elif level == 4:    ####
-        return f"{Style.MarginSpaces}{FG}{Style.Symbol}{text}{RESET}"
+        return f"{state.space_left()}{FG}{Style.Symbol}{text}{RESET}"
     else:  # level 5 or 6
-        return f"{Style.MarginSpaces}{text}{RESET}"
+        return f"{state.space_left()}{text}{RESET}"
 
 def code_wrap(text_in):
+    if state.WidthWrap and len(text_in) > state.WidthFull:
+        return (0, [text_in])
+
     # get the indentation of the first line
     indent = len(text_in) - len(text_in.lstrip())
     text = text_in.lstrip()
@@ -337,8 +349,20 @@ def text_wrap(text, width = -1, indent = 0, first_line_prefix="", subsequent_lin
     return lines
 
 def line_format(line):
-    def not_text(token):
-        return not token or len(token.rstrip()) != len(token)
+    not_text = lambda token: not token or len(token.rstrip()) != len(token)
+    footnotes = lambda match: ''.join([chr(SUPER[int(i)]) for i in match.group(1)])
+
+    def process_images(match):
+        url = match.group(2)
+        try:
+            if re.match(r"https://", url.lower()):
+                image = from_url(url)
+            else: 
+                image = from_file(url)
+            image.height = 20
+            print(f"{image:|.-1#}")
+        except:
+            return match.group(2)
 
     # Apply OSC 8 hyperlink formatting after other formatting
     def process_links(match):
@@ -346,8 +370,11 @@ def line_format(line):
         url = match.group(2)
         return f'\033]8;;{url}\033\\{Style.Link}{description}{UNDERLINE[1]}\033]8;;\033\\{FGRESET}'
 
+    line = re.sub(r"\!\[([^\]]*)\]\(([^\)]+)\)", process_images, line)
     line = re.sub(r"\[([^\]]+)\]\(([^\)]+)\)", process_links, line)
-    tokenList = re.finditer(r"((\*\*|\*|_|`)|[^_*`]+)", line)
+    line = re.sub(r"\[\^(\d+)\]:?", footnotes, line)
+
+    tokenList = re.finditer(r"((~~|\*\*_|_\*\*|\*{1,3}|_{1,3}|`+)|[^~_*`]+)", line)
     result = ""
 
     for match in tokenList:
@@ -355,8 +382,13 @@ def line_format(line):
         next_token = line[match.end()] if match.end() < len(line) else ""
         prev_token = line[match.start()-1] if match.start() > 0 else ""
 
-        if token == "`":
-            state.inline_code = not state.inline_code
+        # This trick makes sure that things like `` ` `` render right.
+        if "`" in token and (not state.inline_code or state.inline_code == token):
+            if state.inline_code:
+                state.inline_code = False
+            else:
+                state.inline_code = token
+
             if state.inline_code:
                 result += f'{BG}{Style.Mid}'
             else:
@@ -367,7 +399,17 @@ def line_format(line):
         elif state.inline_code:
             result += token
 
-        elif token == "**" and (state.in_bold or not_text(prev_token)):
+        elif token == '~~' and (state.in_strikeout or not_text(prev_token)):
+            state.in_strikeout = not state.in_strikeout
+            result += STRIKEOUT[0] if state.in_strikeout else STRIKEOUT[1]
+
+        elif token in ['**_','_**','___','***'] and (state.in_bold or not_text(prev_token)):
+            state.in_bold = not state.in_bold
+            result += BOLD[0] if state.in_bold else BOLD[1]
+            state.in_italic = not state.in_italic
+            result += ITALIC[0] if state.in_italic else ITALIC[1]
+
+        elif (token == '__' or token == "**") and (state.in_bold or not_text(prev_token)):
             state.in_bold = not state.in_bold
             result += BOLD[0] if state.in_bold else BOLD[1]
  
@@ -380,7 +422,7 @@ def line_format(line):
             else:
                 result += token
 
-        elif token == "_" and (state.in_underline or not_text(prev_token)):
+        elif token == "_" and (state.in_underline or (not_text(prev_token) and next_token.isalnum())):
             state.in_underline = not state.in_underline
             result += UNDERLINE[0] if state.in_underline else UNDERLINE[1]
         else:
@@ -422,8 +464,6 @@ def parse(stream):
 
                 if len(ready_in) == 0:
                     TimeoutIx += 1
-                
-
 
             elif stream.fileno() in ready_in: 
                 byte = os.read(stream.fileno(), 1)
@@ -462,13 +502,30 @@ def parse(stream):
         # Run through the plugins first
         res = latex.Plugin(line, state, Style)
         if res is True:
-          # This means everything was consumed by our plugin and 
-          # we should continue
-          continue
-        elif res is not None:
-          for row in res:
-            yield row
+            # This means everything was consumed by our plugin and 
+            # we should continue
             continue
+        elif res is not None:
+            for row in res:
+                yield row
+                continue
+        
+        # running this here avoids stray |
+        block_match = re.match(r"^\s*((>\s*)+|<.?think>)", line)
+        if not state.in_code and block_match:
+            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 = block_match.group(0).count('>')
+                # we also need to consume those tokens
+                line = line[len(block_match.group(0)):]
+        else:
+            if state.block_depth > 0:
+                line = FGRESET + line
+                state.block_depth = 0
 
         # --- Collapse Multiple Empty Lines if not in code blocks ---
         if not state.in_code:
@@ -483,7 +540,7 @@ def parse(stream):
             else:
                 last_line_empty_cache = state.last_line_empty
                 state.last_line_empty = False
-
+        
         # This is to reset our top-level line-based systems
         # \n buffer
         if not state.in_list and len(state.ordered_list_numbers) > 0:
@@ -506,28 +563,11 @@ 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)
-        if block_match:
-            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>
         #
-        # This needs to be first
         if not state.in_code:
-            code_match = re.match(r"\s*```\s*([^\s]+|$)", line)
+            code_match = re.match(r"\s*```\s*([^\s]+|$)$", line)
             if code_match:
                 state.in_code = Code.Backtick
                 state.code_language = code_match.group(1) or 'Bash'
@@ -563,6 +603,7 @@ def parse(stream):
                         try:
                             ext = get_lexer_by_name(state.code_language).filenames[0].split('.')[-1]
                         except:
+                            logging.warning(f"Can't find canonical extension for {state.code_language}")
                             pass
 
                         open(os.path.join(state.scrape, f"file_{state.scrape_ix}.{ext}"), 'w').write(state.code_buffer)
@@ -584,7 +625,8 @@ def parse(stream):
 
 
                     if code_type == Code.Backtick:
-                            continue
+                        state.code_indent = len(line) - len(line.lstrip())
+                        continue
                     else:
                         # otherwise we don't want to consume
                         # nor do we want to be here.
@@ -600,11 +642,6 @@ def parse(stream):
                         custom_style = get_style_by_name("default")
 
                     formatter = Terminal256Formatter(style=custom_style)
-                    for i, char in enumerate(line):
-                        if char == " ":
-                            state.code_indent += 1
-                        else:
-                            break
                     line = line[state.code_indent :]
 
                 elif line.startswith(" " * state.code_indent):
@@ -652,7 +689,7 @@ def parse(stream):
 
                     code_line = ' ' * indent + this_batch.strip()
 
-                    margin = state.WidthFull - visible_length(code_line)
+                    margin = state.WidthFull - visible_length(code_line) % state.WidthFull
                     yield f"{Style.Codebg}{code_line}{' ' * max(0, margin)}{BGRESET}"  
                 continue
             except Goto:
@@ -714,18 +751,18 @@ def parse(stream):
             if list_type == "number":
                 state.ordered_list_numbers[-1] += 1
 
-            indent = len(state.list_item_stack) * 2
+            indent = (len(state.list_item_stack) - 1) * 2
 
             wrap_width = state.Width - indent - (2 * Style.ListIndent) 
 
             bullet = '•'
             if list_type == "number":
                 list_number = int(max(state.ordered_list_numbers[-1], float(list_item_match.group(2))))
-                bullet = f"{list_number}"
+                bullet = str(list_number)
             
             wrapped_lineList = text_wrap(content, wrap_width, Style.ListIndent,
-                first_line_prefix      = f"{(' ' * (indent - len(bullet)))}{FG}{Style.Symbol}{bullet}{RESET} ",
-                subsequent_line_prefix = " " * (indent - 1)
+                first_line_prefix      = f"{(' ' * (indent ))}{FG}{Style.Symbol}{bullet}{RESET} ",
+                subsequent_line_prefix = " " * (indent)
             )
             for wrapped_line in wrapped_lineList:
                 yield f"{state.space_left()}{wrapped_line}\n"
@@ -742,7 +779,7 @@ def parse(stream):
         #
         # <hr>
         #
-        hr_match = re.match(r"^[\s]*([-=_]){3,}[\s]*$", line)
+        hr_match = re.match(r"^[\s]*([-\*=_]){3,}[\s]*$", line)
         if hr_match:
             if state.last_line_empty or last_line_empty_cache:
                 # print a horizontal rule using a unicode midline 
@@ -764,12 +801,6 @@ def parse(stream):
             for wrapped_line in wrapped_lines:
                 yield f"{state.space_left()}{wrapped_line}\n"
 
-def get_terminal_width():
-    try:
-        return shutil.get_terminal_size().columns
-    except (AttributeError, OSError):
-        return 80
-
 def emit(inp):
     buffer = []
     flush = False
@@ -795,6 +826,9 @@ def emit(inp):
             state.current_line += chunk
             
         buffer.append(chunk)
+        # This *might* be dangerous
+        state.reset_inline()
+
         if flush:
             chunk = "\n".join(buffer)
             buffer = []
@@ -806,17 +840,10 @@ def emit(inp):
         else:
             chunk = buffer.pop(0)
 
-        if state.is_pty:
-            print(chunk, end="", flush=True)
-        else:
-            sys.stdout.write(chunk)
+        print(chunk, end="", flush=True)
 
     if len(buffer):
-        chunk = buffer.pop(0)
-        if state.is_pty:
-            print(chunk, end="", flush=True)
-        else:
-            sys.stdout.write(chunk)
+        print(buffer.pop(0), end="", flush=True)
 
 def apply_multipliers(name, H, S, V):
     m = _style.get(name)
@@ -824,7 +851,20 @@ def apply_multipliers(name, H, S, 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())
+    if not state.WidthFull or not state.WidthArg:
+        if state.WidthArg:
+            state.WidthFull = state.WidthArg
+        else:
+            width = 80
+
+            try:
+                width = shutil.get_terminal_size().columns
+                state.WidthWrap = True
+            except (AttributeError, OSError):
+                pass
+
+            state.WidthFull = width
+
     state.Width = state.WidthFull - 2 * Style.Margin
     Style.Codepad = [
         f"{RESET}{FG}{Style.Dark}{'▄' * state.WidthFull}{RESET}\n",
@@ -838,9 +878,9 @@ def main():
     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")
     parser.add_argument("-c", "--color", default=None, help="Set the hsv base: h,s,v")
-    parser.add_argument("-w", "--width", default="0", help="Set the width")
-    parser.add_argument("-e", "--exec", help="Wrap a program for more 'proper' i/o handling")
-    parser.add_argument("-s", "--scrape", help="Scrape code snippets to a directory")
+    parser.add_argument("-w", "--width", default="0", help="Set the width WIDTH")
+    parser.add_argument("-e", "--exec", help="Wrap a program EXEC for more 'proper' i/o handling")
+    parser.add_argument("-s", "--scrape", help="Scrape code snippets to a directory SCRAPE")
     args = parser.parse_args()
 
     if args.color:
@@ -864,8 +904,7 @@ def main():
 
     Style.Codebg = f"{BG}{Style.Dark}"
     Style.Link = f"{FG}{Style.Symbol}{UNDERLINE[0]}"
-    Style.Blockquote = f"{FG}{Style.Grey} \u258E "
-
+    Style.Blockquote = f"{FG}{Style.Grey}│ "
 
     logging.basicConfig(stream=sys.stdout, level=args.loglevel.upper(), format=f'%(message)s')
     state.exec_master, state.exec_slave = pty.openpty()

{streamdown-0.13.0 → streamdown-0.14.0}/tests/chunk-buffer.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-TIMEOUT=${TIMEOUT:-0.1}
+TIMEOUT=${TIMEOUT:-0.01}
 
 while [[ $# -gt 0 ]]; do
     echo "## File: $1"