streamdown 0.14.0__tar.gz → 0.15.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamdown
-Version: 0.14.0
+Version: 0.15.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
@@ -23,6 +23,7 @@ Requires-Python: >=3.8
 Requires-Dist: appdirs
 Requires-Dist: pygments
 Requires-Dist: pylatexenc
+Requires-Dist: term-image
 Requires-Dist: toml
 Description-Content-Type: text/markdown
 
@@ -30,30 +31,30 @@ Description-Content-Type: text/markdown
 
 [![PyPI version](https://badge.fury.io/py/streamdown.svg)](https://badge.fury.io/py/streamdown)
 
-I needed a streaming Markdown renderer and I couldn't find one. So here we go. From the ground up. It's a bad idea but it has to be done.
+Streamdown is the streaming markdown renderer for the terminal that rocks.
+This will work with [simonw's llm](https://github.com/simonw/llm). You even get full readline and keyboard navigation support.
 
-[sd demo](https://github.com/user-attachments/assets/48dba6fa-2282-4be9-8087-a2ad8e7c7d12)
+It's fully streaming and does not block
+![Streamdown is Amazing](https://github.com/user-attachments/assets/268cb340-78cc-4df0-a773-c5ac95eceeeb)
 
-This will work with [simonw's llm](https://github.com/simonw/llm) unlike with [richify.py](https://github.com/gianlucatruda/richify) which rerenders the whole buffer and blocks with an elipses or [glow](https://github.com/charmbracelet/glow) which buffers everything, this streams and does exactly what it says.
+### Provides clean copyable code for long code lines
+You may have noticed that other, *inferior* renderers will inject line breaks when copying code that wraps around. We're better and now, you can be as well.
+![Handle That Mandle](https://github.com/user-attachments/assets/a27aa70c-f691-4796-84f0-c2eb18c7de23)
 
-## Some Features
-
-### Provides clean copyable code for long code blocks and short terminals. 
-![copyable](https://github.com/user-attachments/assets/4a3539c5-b5d1-4d6a-8bce-032724d8909d)
-
-### Supports images, why not?
+### Supports images
 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_`
-![dunder](https://github.com/user-attachments/assets/d41d7fec-6dec-4387-b53d-f2098f269a5e)
-
 ### Tables are carefully supported
 ![table](https://github.com/user-attachments/assets/dbe3d13e-6bac-4f45-bf30-f1857ed98898)
 
+As well as everything else...
+
+![dunder](https://github.com/user-attachments/assets/d41d7fec-6dec-4387-b53d-f2098f269a5e)
+
 ### Colors are highly (and quickly) configurable for people who care a lot, or just a little.
 ![configurable](https://github.com/user-attachments/assets/04b36749-4bb8-4c14-9758-84eb6e19b704)
 
@@ -84,7 +85,7 @@ Defines the base Hue (H), Saturation (S), and Value (V) from which all other pal
 *   `Width` (integer, default: `0`): Along with the `Margin`, `Width` specifies the base width of the content, which when set to 0, means use the terminal width. See [#6](https://github.com/kristopolous/Streamdown/issues/6) for more details
 *   `PrettyPad` (boolean, default: `false`): Uses a unicode vertical pad trick to add a half height background to code blocks. This makes copy/paste have artifacts. See [#2](https://github.com/kristopolous/Streamdown/issues/2). I like it on. But that's just me
 *   `ListIndent` (integer, default: `2`): This is the recursive indent for the list styles.
-*   `Syntax` (string, default `monokai`): This the syntax [highlighting theme which come via pygments](https://pygments.org/styles/).
+*   `Syntax` (string, default `monokai`): This is the syntax [highlighting theme which come via pygments](https://pygments.org/styles/).
 
 Example:
 ```toml
@@ -143,10 +144,8 @@ Do this
 
     $ ./streamdown/sd.py tests/*md
 
-Certainly room for improvement and I'll probably continue to make them
-
 ## Install from source
-At least one of these should work, hopefully
+After the git clone least one of these should work, hopefully. it's using the modern uv pip tool.
 
     $ pipx install -e .
     $ pip install -e .

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

@@ -2,30 +2,30 @@
 
 [![PyPI version](https://badge.fury.io/py/streamdown.svg)](https://badge.fury.io/py/streamdown)
 
-I needed a streaming Markdown renderer and I couldn't find one. So here we go. From the ground up. It's a bad idea but it has to be done.
+Streamdown is the streaming markdown renderer for the terminal that rocks.
+This will work with [simonw's llm](https://github.com/simonw/llm). You even get full readline and keyboard navigation support.
 
-[sd demo](https://github.com/user-attachments/assets/48dba6fa-2282-4be9-8087-a2ad8e7c7d12)
+It's fully streaming and does not block
+![Streamdown is Amazing](https://github.com/user-attachments/assets/268cb340-78cc-4df0-a773-c5ac95eceeeb)
 
-This will work with [simonw's llm](https://github.com/simonw/llm) unlike with [richify.py](https://github.com/gianlucatruda/richify) which rerenders the whole buffer and blocks with an elipses or [glow](https://github.com/charmbracelet/glow) which buffers everything, this streams and does exactly what it says.
+### Provides clean copyable code for long code lines
+You may have noticed that other, *inferior* renderers will inject line breaks when copying code that wraps around. We're better and now, you can be as well.
+![Handle That Mandle](https://github.com/user-attachments/assets/a27aa70c-f691-4796-84f0-c2eb18c7de23)
 
-## Some Features
-
-### Provides clean copyable code for long code blocks and short terminals. 
-![copyable](https://github.com/user-attachments/assets/4a3539c5-b5d1-4d6a-8bce-032724d8909d)
-
-### Supports images, why not?
+### Supports images
 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_`
-![dunder](https://github.com/user-attachments/assets/d41d7fec-6dec-4387-b53d-f2098f269a5e)
-
 ### Tables are carefully supported
 ![table](https://github.com/user-attachments/assets/dbe3d13e-6bac-4f45-bf30-f1857ed98898)
 
+As well as everything else...
+
+![dunder](https://github.com/user-attachments/assets/d41d7fec-6dec-4387-b53d-f2098f269a5e)
+
 ### Colors are highly (and quickly) configurable for people who care a lot, or just a little.
 ![configurable](https://github.com/user-attachments/assets/04b36749-4bb8-4c14-9758-84eb6e19b704)
 
@@ -56,7 +56,7 @@ Defines the base Hue (H), Saturation (S), and Value (V) from which all other pal
 *   `Width` (integer, default: `0`): Along with the `Margin`, `Width` specifies the base width of the content, which when set to 0, means use the terminal width. See [#6](https://github.com/kristopolous/Streamdown/issues/6) for more details
 *   `PrettyPad` (boolean, default: `false`): Uses a unicode vertical pad trick to add a half height background to code blocks. This makes copy/paste have artifacts. See [#2](https://github.com/kristopolous/Streamdown/issues/2). I like it on. But that's just me
 *   `ListIndent` (integer, default: `2`): This is the recursive indent for the list styles.
-*   `Syntax` (string, default `monokai`): This the syntax [highlighting theme which come via pygments](https://pygments.org/styles/).
+*   `Syntax` (string, default `monokai`): This is the syntax [highlighting theme which come via pygments](https://pygments.org/styles/).
 
 Example:
 ```toml
@@ -115,10 +115,8 @@ Do this
 
     $ ./streamdown/sd.py tests/*md
 
-Certainly room for improvement and I'll probably continue to make them
-
 ## Install from source
-At least one of these should work, hopefully
+After the git clone least one of these should work, hopefully. it's using the modern uv pip tool.
 
     $ pipx install -e .
     $ pip install -e .

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "streamdown"
-version = "0.14.0"
+version = "0.15.0"
 description = "A streaming markdown renderer for modern terminals with syntax highlighting"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -31,6 +31,7 @@ dependencies = [
     "appdirs",
     "toml",
     "pylatexenc",
+    'term-image'
 ]
 
 [project.urls]

streamdown-0.15.0/pythonvgo.md

@@ -0,0 +1,187 @@
+🫣# Python vs. Go: Let's get ready to rumble!
+![](python-go.png)
+🫣
+Python and Go (Golang) are both popular programming languages, but they cater to different needs and philosophies. Here's a detailed comparison:
+🫣
+
+**Python:** 🫣
+
+* **Strengths:** 🫣
+    * **Readability:**  Known for its clean and easy-to-understand syntax, emphasizing code readability.  🫣
+    * **Large Ecosystem:** Vast library support for data science, machine learning, web development, scripting, and more.  Packages like NumPy, Pandas, Django, and Flask make complex tasks simpler.  🫣
+    * **Rapid Development:** Its dyna🫣mic typing and interpreted nature allow for quick prototyping and development.
+    * **Dyn🫣amic Typing:**  The interpreter infers data types at runtime, simplifying code (but potentially hiding errors).  🫣
+    * **Versatility:**  Can be used for a wide range of applications – web backends, data analysis, machine learning, automation, scripting, testing, and more.  🫣
+    * **Community:** Huge and active community providing ample support, tutorials, and resources.  🫣
+* **Weaknesses:**
+    * **Performance:** Being an interpreted language, Python is generally slower than compiled languages like Go.  🫣
+    * **Global Interpreter Lock (GIL):**  Limits true multi-threading in CPU-bound operations.  🫣
+    * **Error Handling:**  Runtime errors can be more common because of dynamic typing.  🫣
+    * **Memory Consumption:**  Typically has higher memory overhead compared to Go due to its object model and dynamic typing.
+
+**Go:**
+
+* **Strengths:**
+    * **Performance:** Compiled language that produces efficient, native machine code. Generally much faster than Python.
+    * **Concurrency:**  Built-in support for concurrency through Goroutines (lightweight threads) and Channels, making it easy to write concurrent and parallel programs. 
+🫣    * **Static Typing:** Helps catch errors at compile-time.
+    * **Garbage Collection:** Automatic memory management reduces the risk of memory leaks.
+    * **Simplicity:** Designed 🫣to be a simple language with a relatively small number of keywords.  Focuses on getting things done efficiently.
+    * **Scalability:**  Well-suited for building scalable network services and distributed systems.
+    * **Tooling:** E🫣xcellent built-in tooling for testing, formatting, and dependency management.
+* **Weaknesses:**
+    * **Learning Curve:**  Can be slightly steeper than Python initially, particularly regarding concurre🫣ncy concepts.
+    * **Error Handling:** Explicit error handling (returning errors as values) can lead to verbose code.  (While necessary, it's less concise than Python's `try...except`)
+    * **Generics (Relatively New):**  Generics were only added in Go 1.18 (released in 2022).  Prior to that, code reusability for different types was more challenging.
+    * **Smalle🫣r Ecosystem:**  While rapidly growing, Go’s ecosystem is still smaller than Python's, particularly in specialized areas like data science.
+
+**Use Cases:**
+
+* **Python:** Data science, machine learning, web development (Django, Flask), scripting, automation, prototyping, and educational purposes.
+* **Go:** Cloud infrastructure (Docker, Kubernetes), network services, distributed systems, command-line tools, DevOps, and high-performance backend services.
+
+
+
+## Code Examples:
+
+**1. Hello World:**
+
+**Python:**
+```🫣python
+print("Hello, World!")
+```
+
+**Go:**
+```go
+package main
+
+import "fmt"
+
+func main() {
+	fmt.Println("Hello, World!")
+}
+```
+
+**2.  Simple Web Server:**
+
+**Python (using Flask🫣):**
+```python
+from flask import Flask
+
+app = Flask(__name__)
+
+@app.route("/")
+def hello_world():
+    return "<p>Hello, World!</p>"
+
+if __name__ == '__main__':
+    app.run(debug=True)
+```
+
+**Go (using net/http):**
+```go
+package main
+
+import (
+	"fmt"
+	"net/http"
+)
+
+func handler(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, "Hello, World!")
+}
+
+func main() {
+	http.HandleFunc("/", handler)
+	fmt.Println("Server listening on port 8080")
+	http.ListenAndServe(":8080", nil)
+}
+```
+
+**3. Concurrent Processing (Simple):**
+
+**Python (using threading - limited by GIL):**
+
+```python
+import threading
+
+def process_task(task_id):
+    print(f"Task {task_id} started")
+    # Simulate some work
+    import time
+    time.sleep(2)
+    print(f"Task {task_id} completed")
+
+tasks = [1, 2, 3]
+threads = []
+
+for task in tasks:
+    thread = threading.Thread(🫣target=process_task, args=(task,))
+    threads.append(thread)
+    thread.start()
+
+for thread in threads:
+    thread.join()
+
+print("All tasks comple🫣ted.")
+```
+
+**Go (using Goroutines and Channels):**
+
+```go
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+func processTask(taskID int, wg *sync.WaitGroup) {
+	defer wg.Done() // Decrement the WaitGroup counter when the goroutin🫣e completes.
+	fmt.Printf("Task %d started🫣\n", taskID)
+	// Simulate some work
+	//time.Sleep(2 * time🫣.Second) // Go uses time.Second, etc.
+	fmt.Printf("Task %d completed\n", taskID)
+}
+
+func main() {
+	var wg sync.WaitGroup
+	tasks := []int{1, 2, 3}
+
+	for _, task := range tasks {
+		wg.Add(1) // Increment the WaitGroup counter for each🫣 goroutine.
+		go processTask(task, &wg)
+	}
+
+	wg.Wait()
+	fmt.Prin🫣tln("All tasks completed.")
+}
+```
+
+
+## Comparative Table o🫣f Features:
+
+| Feature             | Python                           | Go (Golang)                  |
+|----------------------|----------------------------------|-------------------------------|
+| **Typi🫣ng**          | Dynamic, strong     🫣             | Static, strong                |
+| **Compilation**     | Interpreted                      | Compiled                      |
+| **Perfo🫣rmance**      | Generally slower                | Generally faster              |
+| **Concurrency**       | Through threads (GIL limited)   | Goroutines & Chan🫣nels 🫣(built-in) |
+| **Error Handling**   | Exceptions (try-except)           | Explicit error val🫣ues          |
+| **Memory Management**| Automatic (Garbage Collection)   | Automatic (Garbage Collection) |
+| **Syntax**           | Readable, concise               | Simple, explicit               |
+| **Ecosystem**🫣        | Huge, mature                   | Growing, focused               |
+| **Learning Curve**    | Easier                           | Moderate                      |
+| **Generics**          | Present                          | Added in 1.18 (relatively new)|
+| **Typical Use Cases**| Data science, web dev, scripting | Cloud, networking, system programming |
+| **Community**        | Very large, active               | Growing, dedicated            |
+| **Object Orientation**| Full support                    | Structs with methods, interfaces|
+
+
+
+**In Summary:**
+
+* **Choose Python 🫣if:** You need rapid development, a large ecosystem of libraries, or are focused on data science, machine learning, or scripting.  Readability and ease of use are priorities.
+
+* **Choose Go if:** You need high performance, concurrency, scalability, and are building infrastructure, network services, or command-line tools.  Deterministic error handling and a simple, efficient language are key.
+🫣

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

@@ -26,6 +26,7 @@ import importlib
 from io import BytesIO
 from term_image.image import from_file, from_url
 import pygments.util
+from functools import reduce
 from argparse import ArgumentParser
 from pygments import highlight
 from pygments.lexers import get_lexer_by_name
@@ -91,8 +92,8 @@ KEYCODE_RE = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
 
 visible = lambda x: re.sub(ANSIESCAPE, "", x)
 visible_length = lambda x: len(visible(x))
-
 extract_ansi_codes = lambda text: re.findall(ESCAPE, text)
+remove_ansi = lambda line, codeList: reduce(lambda line, code: line.replace(code, ''), codeList, line)
 
 def debug_write(text):
     if state.Logging:
@@ -271,6 +272,7 @@ def code_wrap(text_in):
 
     return (indent, res)
 
+
 # This marvelously obscure code "compacts" long lines of repetitive ANSI format strings by
 # removing duplicates. Here's how it works
 def ansi_collapse(codelist, inp):
@@ -665,6 +667,10 @@ 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)
+
+                    # 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\[39(;00|)m", '', highlighted_code)
     
                     # Since we are streaming we ignore the resets and newlines at the end
                     if highlighted_code.endswith(FGRESET + "\n"):

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

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