streamdown 0.18.0__py3-none-any.whl → 0.20.0__py3-none-any.whl

streamdown/sd.py

@@ -65,7 +65,7 @@ Symbol  = { H = 1.00, S = 1.00, V = 1.50 }
 Head    = { H = 1.00, S = 1.00, V = 1.75 }
 Grey    = { H = 1.00, S = 0.25, V = 1.37 }
 Bright  = { H = 1.00, S = 2.00, V = 2.00 }
-Syntax  = "monokai"
+Syntax  = "dracula"
 """
 
 def ensure_config_file():
@@ -92,6 +92,7 @@ BOLD      = ["\033[1m", "\033[22m"]
 UNDERLINE = ["\033[4m", "\033[24m"]
 ITALIC    = ["\033[3m", "\033[23m"]
 STRIKEOUT = ["\033[9m", "\033[29m"]
+LINK      = ["\033]8;;", "\033]8;;\033\\"]
 SUPER     = [ 0x2070, 0x00B9, 0x00B2, 0x00B3, 0x2074, 0x2075, 0x2076, 0x2077, 0x2078, 0x2079 ]
 
 ESCAPE = r"\033\[[0-9;]*[mK]"
@@ -100,7 +101,7 @@ KEYCODE_RE = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
 
 visible = lambda x: re.sub(ANSIESCAPE, "", x)
 # cjk characters are double width
-visible_length = lambda x: len(visible(x)) + cjk_count(x)
+visible_length = lambda x: len(visible(x)) + dbl_count(x)
 extract_ansi_codes = lambda text: re.findall(ESCAPE, text)
 remove_ansi = lambda line, codeList: reduce(lambda line, code: line.replace(code, ''), codeList, line)
 
@@ -116,8 +117,8 @@ def savebrace():
     if state.Savebrace and state.code_buffer_raw:
         path = os.path.join(tempfile.gettempdir(), "sd", 'savebrace')
         with open(path, "a") as f:
-            f.write(state.code_buffer_raw)
-        
+            f.write(state.code_buffer_raw + "\x00")
+            f.flush()
 
 class Goto(Exception):
     pass
@@ -208,7 +209,7 @@ class ParseState:
         return offset + (state.current_width(listwidth = True) if Style.PrettyBroken else self.WidthFull)
 
     def current_width(self, listwidth = False):
-        return self.Width - (len(visible(self.space_left(listwidth))) + Style.Margin)
+        return self.Width - (len(visible(self.space_left(listwidth))))
 
     def space_left(self, listwidth = False):
         pre = ' ' * (len(state.list_item_stack)) * Style.ListIndent if listwidth else ''
@@ -216,6 +217,20 @@ class ParseState:
 
 state = ParseState()
 
+def override_background(style_name, background_color):
+    base_style = get_style_by_name(style_name)
+    base_style.background_color = background_color
+    for i in base_style:
+        i[1]['bgcolor'] = background_color
+    for i,v in base_style.styles.items():
+        if v and 'bg' in v:
+            base_style.styles[i] = re.sub(r'bg:[^ ]*', '', base_style.styles[i] )
+    for k,v in base_style._styles.items():
+         if v[4] != '':
+             v[4] = ''
+
+    return base_style
+
 def format_table(rowList):
     num_cols = len(rowList)
     row_height = 0
@@ -224,15 +239,20 @@ def format_table(rowList):
     # Calculate max width per column (integer division)
     # Subtract num_cols + 1 for the vertical borders '│'
     available_width = state.current_width() - (num_cols + 1)
-    col_width = max(1, available_width // num_cols)
+
+    width_base = available_width // num_cols
+    width_mod  = available_width % num_cols
+
+    col_width_list = [width_base + (1 if i < width_mod else 0) for i in range(num_cols)]
     bg_color = Style.Mid if state.in_table == Style.Head else Style.Dark
     state.bg = f"{BG}{bg_color}"
 
     # First Pass: Wrap text and calculate row heights
     # Note this is where every cell is formatted so if 
     # you are styling, do it before here!
-    for row in rowList:
-        wrapped_cell = text_wrap(row, width=col_width, force_truncate=True)
+    for ix in range(len(rowList)):
+        row = rowList[ix]
+        wrapped_cell = text_wrap(row, width=col_width_list[ix], force_truncate=True)
 
         # Ensure at least one line, even for empty cells
         if not wrapped_cell:
@@ -248,13 +268,14 @@ def format_table(rowList):
         line_segments = []
 
         # Now we want to snatch this row index from all our cells
-        for cell in wrapped_cellList:
+        for iy in range(len(wrapped_cellList)):
+            cell = wrapped_cellList[iy]
             segment = ''
             if ix < len(cell):
                 segment = cell[ix]
 
             # Margin logic is correctly indented here
-            margin_needed = col_width - visible_length(segment)
+            margin_needed = col_width_list[iy] - visible_length(segment)
             margin_segment = segment + (" " * max(0, margin_needed))
             line_segments.append(f"{BG}{bg_color}{extra} {margin_segment}")
 
@@ -269,7 +290,7 @@ def emit_h(level, text):
     text = line_format(text)
     spaces_to_center = (state.current_width() -  visible_length(text)) / 2
     if level == 1:      #
-        return f"{state.space_left()}\n{state.space_left()}{BOLD[0]}{' ' * math.floor(spaces_to_center)}{text}{BOLD[1]}"
+        return f"{state.space_left()}\n{state.space_left()}{BOLD[1]}{' ' * math.floor(spaces_to_center)}{text}{BOLD[1]}"
     elif level == 2:    ##
         return f"{state.space_left()}\n{state.space_left()}{BOLD[0]}{FG}{Style.Bright}{' ' * math.floor(spaces_to_center)}{text}{' ' * math.ceil(spaces_to_center)}{BOLD[1]}{FGRESET}"
     elif level == 3:    ###
@@ -337,21 +358,35 @@ def ansi_collapse(codelist, inp):
 
 
 def split_text(text):
-    return re.split(
-        r'(?<=[\u4E00-\u9FFF\u3400-\u4DBF\uF900-\uFAFF])|(?=[\u4E00-\u9FFF\u3400-\u4DBF\uF900-\uFAFF])|\s+',
+    return [x for x in re.split(
+        r'(?<=['
+            r'\u3000-\u303F'
+            r'\u4E00-\u9FFF'
+            r'\u3400-\u4DBF'
+            r'\uF900-\uFAFF'
+          r'])|(?=['
+            #r'\u4E00-\u9FFF'
+            r'\u3400-\u4DBF'
+            r'\uF900-\uFAFF'
+          r'])|\s+',
         text
-    )
+    ) if x]
 
 def text_wrap(text, width = -1, indent = 0, first_line_prefix="", subsequent_line_prefix="", force_truncate=False):
     if width == -1:
         width = state.Width
 
     # The empty word clears the buffer at the end.
-    words = split_text(line_format(text)) + [""]
+    formatted = line_format(text)
+    #print(bytes(formatted, 'utf-8'), formatted)
+    words = split_text(formatted) + [""]
+    #print([bytes(i, 'utf-8') for i in words])
+
     lines = []
     current_line = ""
     current_style = []
     
+    oldword = ''
     for word in words:
         # we apply the style if we see it at the beginning of the word
         codes = extract_ansi_codes(word)
@@ -360,8 +395,12 @@ def text_wrap(text, width = -1, indent = 0, first_line_prefix="", subsequent_lin
             current_style.append(codes.pop(0))
 
         if len(word) and visible_length(current_line) + visible_length(word) + 1 <= width:  # +1 for space
-
-            current_line += (" " if len(visible(word)) > 0 and current_line and not cjk_count(word) else "") + word
+            space = ""
+            if len(visible(word)) > 0 and current_line:
+                space = " "
+            if (":" in visible(word) or cjk_count(word)) and cjk_count(oldword):
+                space = ""
+            current_line += space + word
         else:
             # Word doesn't fit, finalize the previous line
             prefix = first_line_prefix if not lines else subsequent_line_prefix
@@ -373,6 +412,10 @@ def text_wrap(text, width = -1, indent = 0, first_line_prefix="", subsequent_lin
             margin = max(0, width - visible_length(line_content))
 
             if line_content.strip() != "":
+                # We make absolutely positively sure beyond any doubt
+                # that we have closed our hyperlink OSC
+                if LINK[0] in line_content:
+                    line_content += LINK[1]
                 lines.append(line_content + state.bg + ' ' * margin)
 
             current_line = (" " * indent) + "".join(current_style) + word
@@ -383,19 +426,30 @@ def text_wrap(text, width = -1, indent = 0, first_line_prefix="", subsequent_lin
         if codes:
             current_style = ansi_collapse(current_style, codes)
 
+        oldword = word
+
     if len(lines) < 1:
         return []
 
     return lines
 
+def dbl_count(s):
+    dbl_re = re.compile(
+        r'[\u2e80-\u2eff\u3000-\u303f\u3400-\u4dbf'
+        r'\U00004e00-\U00009fff\U0001f300-\U0001f6ff'
+        r'\U0001f900-\U0001f9ff\U0001fa70-\U0001faff]',
+        re.UNICODE
+    )
+    return len(dbl_re.findall(visible(s)))
+
 def cjk_count(s):
     cjk_re = re.compile(
         r'[\u4E00-\u9FFF'      # CJK Unified Ideographs
-        r'|\u3400-\u4DBF'       # CJK Unified Ideographs Extension A
-        r'|\uF900-\uFAFF'       # CJK Compatibility Ideographs
-		r'|\uFF00-\uFFEF'       # CJK Compatibility Punctuation
-        r'|\u3000-\u303F'      # CJK Symbols and Punctuation
-        r'|\U0002F800-\U0002FA1F]' # CJK Compatibility Ideographs Supplement
+        r'\u3400-\u4DBF'       # CJK Unified Ideographs Extension A
+        r'\uF900-\uFAFF'       # CJK Compatibility Ideographs
+		r'\uFF00-\uFFEF'       # CJK Compatibility Punctuation
+        r'\u3000-\u303F'      # CJK Symbols and Punctuation
+        r'\U0002F800-\U0002FA1F]' # CJK Compatibility Ideographs Supplement
     )
     
     return len(cjk_re.findall(visible(s)))
@@ -420,7 +474,7 @@ def line_format(line):
     def process_links(match):
         description = match.group(1)
         url = match.group(2)
-        return f'\033]8;;{url}\033\\{Style.Link}{description}{UNDERLINE[1]}\033]8;;\033\\{FGRESET}'
+        return f'{LINK[0]}{url}\033\\{Style.Link}{description}{UNDERLINE[1]}{LINK[1]}{FGRESET}'
 
     line = re.sub(r"\!\[([^\]]*)\]\(([^\)]+)\)", process_images, line)
     line = re.sub(r"\[([^\]]+)\]\(([^\)]+)\)", process_links, line)
@@ -437,19 +491,24 @@ def line_format(line):
         # 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:
+                if ' ' in state.inline_code:
+                    savebrace()
                 state.inline_code = False
             else:
                 state.inline_code = token
+                state.code_buffer_raw = ''
 
             if state.inline_code:
                 result += f'{BG}{Style.Mid}'
             else:
                 result += state.bg
+                state.code_buffer_raw = ''
    
         # This is important here because we ignore formatting
         # inside of our code block.
         elif state.inline_code:
             result += token
+            state.code_buffer_raw += token
 
         elif token == '~~' and (state.in_strikeout or not_text(prev_token)):
             state.in_strikeout = not state.in_strikeout
@@ -552,6 +611,7 @@ def parse(stream):
             continue
 
         state.buffer = b''
+        """
         # Run through the plugins first
         res = latex.Plugin(line, state, Style)
         if res is True:
@@ -562,6 +622,7 @@ def parse(stream):
             for row in res:
                 yield row
                 continue
+        """
         
         # running this here avoids stray |
         block_match = re.match(r"^\s*((>\s*)+|<.?think>)", line)
@@ -632,7 +693,6 @@ def parse(stream):
                     state.code_language = 'Bash'
 
             if state.in_code:
-                savebrace()
                 state.code_buffer = state.code_buffer_raw = ""
                 state.code_gen = 0
                 state.code_first_line = True
@@ -664,6 +724,7 @@ def parse(stream):
                         open(os.path.join(state.scrape, f"file_{state.scrape_ix}.{ext}"), 'w').write(state.code_buffer_raw)
                         state.scrape_ix += 1
 
+                    savebrace()
                     state.code_language = None
                     state.code_indent = 0
                     code_type = state.in_code
@@ -691,10 +752,10 @@ def parse(stream):
                     state.code_first_line = False
                     try:
                         lexer = get_lexer_by_name(state.code_language)
-                        custom_style = get_style_by_name(Style.Syntax)
+                        custom_style = override_background(Style.Syntax, ansi2hex(Style.Dark))
                     except pygments.util.ClassNotFound:
                         lexer = get_lexer_by_name("Bash")
-                        custom_style = get_style_by_name("default")
+                        custom_style = override_background("default", ansi2hex(Style.Dark))
 
                     formatter = TerminalTrueColorFormatter(style=custom_style)
                     if line.startswith(' ' * state.code_indent):
@@ -713,6 +774,7 @@ def parse(stream):
                 else:
                     continue
 
+                highlighted_code = highlight(line, lexer, formatter)
                 indent, line_wrap = code_wrap(line)
                 
                 state.where_from = "in code"
@@ -724,15 +786,18 @@ def parse(stream):
                     # then naively search back until our visible_lengths() match. This is not fast and there's certainly smarter
                     # ways of doing it but this thing is way trickery than you think
                     highlighted_code = highlight(state.code_buffer + tline, lexer, formatter)
+                    #print("(",highlighted_code,")")
 
                     # Sometimes the highlighter will do things like a full reset or a background reset.
                     # This is not what we want
-                    highlighted_code = re.sub(r"\033\[49(;00|)m", '', highlighted_code)
+                    highlighted_code = re.sub(r"\033\[[34]9(;00|)m", '', highlighted_code)
     
                     # Since we are streaming we ignore the resets and newlines at the end
                     if highlighted_code.endswith(FGRESET + "\n"):
                         highlighted_code = highlighted_code[: -(1 + len(FGRESET))]
 
+                    #print(bytes(highlighted_code, 'utf-8'))
+
                     # turns out highlight will eat leading newlines on empty lines
                     vislen = visible_length(state.code_buffer.lstrip())
 
@@ -834,7 +899,7 @@ def parse(stream):
         # This is intentional ... we can get here in llama 4 using
         # a weird thing
         if state.in_list:
-            indent = (len(state.list_item_stack) - 1) * Style.ListIndent + (len(bullet) - 1)
+            indent = (len(state.list_item_stack) - 1) * Style.ListIndent #+ (len(bullet) - 1)
             wrap_width = state.current_width() - indent - (2 * Style.ListIndent) 
             
             wrapped_lineList = text_wrap(content, wrap_width, Style.ListIndent,
@@ -920,6 +985,11 @@ def emit(inp):
     if len(buffer):
         print(buffer.pop(0), file=sys.stdout, end="", flush=True)
 
+def ansi2hex(ansi_code):
+    parts = ansi_code.strip('m').split(";")
+    r, g, b = map(int, parts)
+    return f"#{r:02x}{g:02x}{b:02x}"
+
 def apply_multipliers(name, H, S, V):
     m = _style.get(name)
     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"]))
@@ -1035,6 +1105,8 @@ def main():
         os.close(state.exec_master)
         if state.exec_sub:
             state.exec_sub.wait()
+
+    print(RESET, end="")
     sys.exit(state.exit)
 
 if __name__ == "__main__":

{streamdown-0.18.0.dist-info → streamdown-0.20.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamdown
-Version: 0.18.0
+Version: 0.20.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
@@ -36,43 +36,51 @@ Description-Content-Type: text/markdown
 </p>
 
 
-Streamdown works with [simonw's llm](https://github.com/simonw/llm) along with any other streaming markdown, even something basic like curl. 
-It supports standard piping like any normal pager and a clean `execvp` option for robustly wrapping around interactive programs with readline or their own ANSI stuff to manage.
+Streamdown works with any streaming markdown such as [simonw's llm](https://github.com/simonw/llm) or even something basic like curl. 
+
+It supports standard piping and files as arguments like any normal pager but can also run as a wrapper so you retain full keyboard interactivity. Arrow keys, control, alt, all still work.
 ```bash
 $ pip install streamdown
 ```
 ![Streamdown is Amazing](https://github.com/user-attachments/assets/268cb340-78cc-4df0-a773-c5ac95eceeeb)
 
 ### Provides clean copyable code for long code lines
-Some *inferior* renderers inject line breaks when copying code that wraps around. We're better and now you are too!
+Other renderers inject line breaks when copying code that wraps around. Streamdown's better and now you are too!
 ![Handle That Mandle](https://github.com/user-attachments/assets/a27aa70c-f691-4796-84f0-c2eb18c7de23)
-**Tip**: You can make things prettier if you don't mind if this guarantee is broken. See the `PrettyBroken` flag below!
+**Tip**: You can make things prettier if you don't mind if this guarantee is broken. See the `PrettyBroken` flag below! (There's still 2 other convenient ways of getting code blocks out.)
 
 ### Supports images
-Here's kitty and alacritty. Try to do that in glow...
+Here's kitty and alacritty. 
 ![doggie](https://github.com/user-attachments/assets/81c43983-68cd-40c1-b1d5-aa3a52004504)
 
 ### Supports hyperlinks (OSC 8) and clipboard (OSC 52)
+The optional `Clipboard` feature puts the final codeblock into your clipboard. See below for details.
+
 [links.webm](https://github.com/user-attachments/assets/a5f71791-7c58-4183-ad3b-309f470c08a3)
 
-### Supports tables
-![table](https://github.com/user-attachments/assets/dbe3d13e-6bac-4f45-bf30-f1857ed98898)
+### As well as everything else...
+Here's the `Savebrace` feature with `screen-query` and `sd-picker` from [llmehelp](https://github.com/kristopolous/llmehelp). You can have an ongoing conversation in tmux with your terminal session. Then use popups and fzf to insert command or coding blocks all with a keystroke.
+
+This allows you to interactively debug  in a way that the agent doesn't just wander off doing silly things.
 
-As well as everything else...
-![dunder](https://github.com/user-attachments/assets/d41d7fec-6dec-4387-b53d-f2098f269a5e)
+It takes about 2 minutes to set up and about 0.2s to use. Fast, fluid and free.
+![screenquery](https://github.com/user-attachments/assets/517be4fe-6962-4e4c-b2f2-563471bc48d0)
 
-Very ... Carefully ... Supported ... 
-![cjk1](https://github.com/user-attachments/assets/75162ade-4734-440e-aaa3-5ffc17a0dd46)
+### ...It even supports CJK 
+Compare how streamdown wraps and spaces this tabular Chinese description of programming languages to other leading markdown renderers.
+
+Only one generates the text without truncation. 很美！
+![cjk](https://github.com/user-attachments/assets/cae485d7-c478-4836-9732-d9fa49e13bc9)
 
 ### Colors are highly (and quickly) configurable for people who care a lot, or just a little.
 ![configurable](https://github.com/user-attachments/assets/19ca2ec9-8ea1-4a79-87ca-8352789269fe)
 
-### Has a [Plugin](https://github.com/kristopolous/Streamdown/tree/main/streamdown/plugins) system to extend the parser and renderer.
+### Has a [Plugin](https://github.com/kristopolous/Streamdown/tree/main/streamdown/plugins) system to extend the parser and renderers.
 For instance, here is the [latex plugin](https://github.com/kristopolous/Streamdown/blob/main/streamdown/plugins/latex.py) doing math inside a table:
 ![calc](https://github.com/user-attachments/assets/0b0027ca-8ef0-4b4a-b4ae-e36ff623a683)
 
 
-## TOML Configuration 
+## Configuration 
 
 It's located at `~/.config/streamdown/config.toml` (following the XDG Base Directory Specification). If this file does not exist upon first run, it will be created with default values. 
 
@@ -80,7 +88,9 @@ Here are the sections:
 
 **`[style]`**
 
-Defines the base Hue (H), Saturation (S), and Value (V) from which all other palette colors are derived. The defaults are [at the beginning of the source](https://github.com/kristopolous/Streamdown/blob/main/streamdown/sd.py#L33).
+Defines the base Hue (H), Saturation (S), and Value (V) from which all other palette colors are derived. This can also be specified at runtime via command line arguments. See below! 
+
+The default values are [at the beginning of the source](https://github.com/kristopolous/Streamdown/blob/main/streamdown/sd.py#L33).
 
 *   `HSV`: [ 0.0 - 1.0, 0.0 - 1.0, 0.0 - 1.0 ] 
 *   `Dark`: Multipliers for background elements, code blocks. 

{streamdown-0.18.0.dist-info → streamdown-0.20.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 streamdown/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-streamdown/sd.py,sha256=gFm6WqrWsMqV8EW9tcq7ebGoXpDFrTd89_ka21AaHm8,39118
+streamdown/sd.py,sha256=ggXlCGovA6cS3686BLnk0ISzf2xXrx7UwuKjwjs6RUM,41475
 streamdown/ss,sha256=sel_phpaecrw6WGIHRLROsD7BFShf0rSDHheflwdUn8,277
 streamdown/ss1,sha256=CUVf86_2zeAle2oQCeTfWYqtHBrAFR_UgvptuYMQzFU,3151
 streamdown/plugins/README.md,sha256=KWqYELs9WkKJmuDzYv3cvPlZMkArsNCBUe4XDoTLjLA,1143
 streamdown/plugins/latex.py,sha256=xZMGMdx_Sw4X1piZejXFHfEG9qazU4fGeceiMI0h13Y,648
-streamdown-0.18.0.dist-info/METADATA,sha256=Lyrf0k6BjC4wjiwwWz5b7aOFPtLR5uJ41e-SRGr1JC0,8062
-streamdown-0.18.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-streamdown-0.18.0.dist-info/entry_points.txt,sha256=HroKFsFMGf_h9PRTE96NjvjJQWupMW5TGP5RGUr1O_Q,74
-streamdown-0.18.0.dist-info/licenses/LICENSE.MIT,sha256=SnY46EPirUsF20dZDR8HpyVgS2_4Tjxuc6f-4OdqO7U,1070
-streamdown-0.18.0.dist-info/RECORD,,
+streamdown-0.20.0.dist-info/METADATA,sha256=LpTl5FFiZJMk_9OC9Kqqq72satHDEHn19rGnJ93XSKY,8843
+streamdown-0.20.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+streamdown-0.20.0.dist-info/entry_points.txt,sha256=HroKFsFMGf_h9PRTE96NjvjJQWupMW5TGP5RGUr1O_Q,74
+streamdown-0.20.0.dist-info/licenses/LICENSE.MIT,sha256=SnY46EPirUsF20dZDR8HpyVgS2_4Tjxuc6f-4OdqO7U,1070
+streamdown-0.20.0.dist-info/RECORD,,