From d9149d8bc9c10b16ececf1ae6d4a9dabb4dd1649 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 25 Nov 2025 14:43:28 +0000
Subject: [PATCH 1/7] docs: add diff strategy evaluation code to architecture

Added code snippet showing how the diff strategy is evaluated
under the Swap vs Refresh Caveats section for clarity.
---
 architecture.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/architecture.md b/architecture.md
index b2ed4bc..089ba03 100644
--- a/architecture.md
+++ b/architecture.md
@@ -67,6 +67,11 @@ stateDiagram-v2
 > **Swap vs Refresh Caveats**:
 > *   **Full Replace**: Used when the component structure changes significantly. This is the safest fallback but resets the DOM state (e.g., focus, scroll position) unless carefully managed.
 > *   **Partial Replace/Append**: HStream attempts to preserve the DOM by only updating changed elements (identified by consistent IDs). This maintains user focus and input state better than a full refresh.
+>
+> ```python
+> strategy = pick_a_strategy(prev_html, new_html, hs_script_running)
+> # Returns: "1_full_replace", "2_nothing", "3_partial_replace", or "4_partial_append"
+> ```
 
 
 ## Key File Descriptions

From 37eee84e046b40af1acbc243b4aaf6421deace67 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 25 Nov 2025 15:13:25 +0000
Subject: [PATCH 2/7] ci: migrate GitHub workflow from Poetry to UV

Updated CI pipeline to use UV for dependency management:
- Replaced Poetry installation with UV
- Changed dependency installation to use `uv sync`
- Updated all command executions to use `uv run`
- Simplified build and publish steps with `uv build` and `uv publish`
- Removed separate pre-commit installation (included in dev deps)
---
 .github/workflows/python-app.yml | 28 +++++++++++-----------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml
index 70f603c..aaa8825 100644
--- a/.github/workflows/python-app.yml
+++ b/.github/workflows/python-app.yml
@@ -16,41 +16,35 @@ jobs:
       with:
         python-version: '3.x'
 
-    - name: Install Poetry
+    - name: Install UV
       run: |
-        curl -sSL https://install.python-poetry.org | python3 -
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.cargo/bin" >> $GITHUB_PATH
 
-    - name: Install dependencies with Poetry
+    - name: Install dependencies with UV
       run: |
-        poetry install --with dev
-
-    - name: Install pre-commit
-      run: |
-        poetry run pip install pre-commit
+        uv sync
 
     - name: Run pre-commit
       run: |
-        poetry run pre-commit run --all-files
+        uv run pre-commit run --all-files
 
     - name: Install Playwright browsers
       run: |
-        poetry run playwright install
+        uv run playwright install
 
     - name: Run tests
       run: |
-        poetry run pytest --reruns 3 # githubs playwright sometimes fails
+        uv run pytest --reruns 3 # githubs playwright sometimes fails
 
     - name: Build package
       if: github.ref == 'refs/heads/main'
       run: |
-        python -m pip install --upgrade build
-        python -m build
+        uv build
 
     - name: Publish package to PyPI
       if: github.ref == 'refs/heads/main'
       env:
-        TWINE_USERNAME: __token__
-        TWINE_PASSWORD: ${{ secrets.PYPI_TOKEN }}
+        UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
       run: |
-        python -m pip install --upgrade twine
-        python -m twine upload dist/*
+        uv publish

From 704ca4c5345ba0b830ffa38b70ad43b1792c692f Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 25 Nov 2025 15:29:31 +0000
Subject: [PATCH 3/7] test: add e2e tests for diff update strategies

Created comprehensive end-to-end tests using Playwright that verify
each of the four diff update strategies through user interactions:

1. Full Replace (1_full_replace) - Initial page load
2. Nothing (2_nothing) - Button click with no content change
3. Partial Replace (3_partial_replace) - Content changes and element removal
4. Partial Append (4_partial_append) - Adding new elements

Tests mimic real user actions like typing, clicking buttons, and
toggling checkboxes to trigger different DOM update strategies.
---
 tests/test_diff_strategies.py | 320 ++++++++++++++++++++++++++++++++++
 1 file changed, 320 insertions(+)
 create mode 100644 tests/test_diff_strategies.py

diff --git a/tests/test_diff_strategies.py b/tests/test_diff_strategies.py
new file mode 100644
index 0000000..d9fbf6a
--- /dev/null
+++ b/tests/test_diff_strategies.py
@@ -0,0 +1,320 @@
+"""
+End-to-end tests for content update (diff) strategies.
+
+This module tests that the correct diff strategies are applied when users
+interact with hstream components, triggering different types of DOM updates.
+"""
+import platform
+from time import sleep
+from playwright.sync_api import sync_playwright
+from .conftest import write_py_script
+
+
+def wait_for_server():
+    """Wait for server to be ready on GitHub CI."""
+    if not platform.system() == "Darwin":
+        sleep(10)
+
+
+def setup_test_script(contents):
+    """Helper to write test script and wait for server."""
+    sleep(0)
+    write_py_script(contents=contents)
+    wait_for_server()
+
+
+def test_full_replace_strategy_on_initial_load():
+    """
+    Test that full replace strategy is used on initial page load.
+
+    Strategy: 1_full_replace
+    Trigger: First page load with no previous HTML
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+hs.markdown('# Initial Load')
+hs.markdown('This is the first render')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        # Verify content is present (full replace happened)
+        assert "Initial Load" in page.inner_text("body")
+        assert "This is the first render" in page.inner_text("body")
+        browser.close()
+
+
+def test_nothing_strategy_when_no_change():
+    """
+    Test that nothing strategy is used when user action doesn't change output.
+
+    Strategy: 2_nothing
+    Trigger: Button click that doesn't change any displayed content
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+# State that doesn't affect output
+clicked = hs.button('Click me (no visible change)')
+
+hs.markdown('Static content that never changes')
+hs.markdown('More static content')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        initial_content = page.inner_text("body")
+
+        # Click button but output remains the same
+        button = page.locator('button:has-text("Click me")')
+        button.click()
+        sleep(2)
+
+        # Content should be identical (nothing strategy)
+        assert page.inner_text("body") == initial_content
+        browser.close()
+
+
+def test_partial_replace_strategy_when_content_changes():
+    """
+    Test that partial replace strategy is used when existing content changes.
+
+    Strategy: 3_partial_replace
+    Trigger: Text input that updates existing markdown elements
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+text = hs.text_input('Enter text', default_value='original')
+
+hs.markdown(f'You typed: {text}')
+hs.markdown('This line stays the same')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        assert "You typed: original" in page.inner_text("body")
+
+        # Type new text - this should trigger partial replace
+        text_input = page.locator("input[type=text]")
+        text_input.fill("updated")
+        text_input.press("Enter")
+        sleep(2)
+
+        # Content should be updated (partial replace)
+        assert "You typed: updated" in page.inner_text("body")
+        assert "This line stays the same" in page.inner_text("body")
+        browser.close()
+
+
+def test_partial_replace_strategy_when_elements_removed():
+    """
+    Test that partial replace strategy is used when conditional elements are removed.
+
+    Strategy: 3_partial_replace
+    Trigger: Checkbox that controls visibility of elements (fewer elements shown)
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+show_extra = hs.checkbox('Show extra content', default_value=True)
+
+hs.markdown('Line 1: Always visible')
+hs.markdown('Line 2: Always visible')
+
+if show_extra:
+    hs.markdown('Line 3: Conditional')
+    hs.markdown('Line 4: Conditional')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        # Initially all 4 lines should be visible
+        assert "Line 1: Always visible" in page.inner_text("body")
+        assert "Line 3: Conditional" in page.inner_text("body")
+        assert "Line 4: Conditional" in page.inner_text("body")
+
+        # Uncheck to remove conditional elements (partial replace with fewer elements)
+        checkbox = page.locator("input[type=checkbox]")
+        checkbox.uncheck()
+        text_input = page.locator("input[type=text]")
+        text_input.focus()  # Trigger update
+        sleep(2)
+
+        # Conditional lines should be gone
+        assert "Line 1: Always visible" in page.inner_text("body")
+        assert "Line 2: Always visible" in page.inner_text("body")
+        assert "Line 3: Conditional" not in page.inner_text("body")
+        browser.close()
+
+
+def test_partial_append_strategy_when_elements_added():
+    """
+    Test that partial append strategy is used when new elements are added.
+
+    Strategy: 4_partial_append
+    Trigger: Checkbox that shows additional content at the end
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+show_more = hs.checkbox('Show more content', default_value=False)
+
+hs.markdown('Line 1: Always here')
+hs.markdown('Line 2: Always here')
+
+if show_more:
+    hs.markdown('Line 3: Newly added')
+    hs.markdown('Line 4: Newly added')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        # Initially only 2 lines
+        assert "Line 1: Always here" in page.inner_text("body")
+        assert "Line 2: Always here" in page.inner_text("body")
+        assert "Line 3: Newly added" not in page.inner_text("body")
+
+        # Check box to add new elements (partial append)
+        checkbox = page.locator("input[type=checkbox]")
+        checkbox.check()
+        text_input = page.locator("input[type=text]")
+        text_input.focus()  # Trigger update
+        sleep(2)
+
+        # New lines should be appended
+        assert "Line 1: Always here" in page.inner_text("body")
+        assert "Line 2: Always here" in page.inner_text("body")
+        assert "Line 3: Newly added" in page.inner_text("body")
+        assert "Line 4: Newly added" in page.inner_text("body")
+        browser.close()
+
+
+def test_partial_append_with_counter():
+    """
+    Test partial append strategy with a counter that adds items incrementally.
+
+    Strategy: 4_partial_append
+    Trigger: Button clicks that add new list items
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+if hs.button('Add item'):
+    if 'count' not in hs.session_state:
+        hs.session_state['count'] = 1
+    else:
+        hs.session_state['count'] += 1
+
+count = hs.session_state.get('count', 0)
+
+hs.markdown('## Item List')
+for i in range(count):
+    hs.markdown(f'- Item {i + 1}')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        # Initially no items
+        initial_text = page.inner_text("body")
+        assert "Item 1" not in initial_text
+
+        # Click to add first item
+        button = page.locator('button:has-text("Add item")')
+        button.click()
+        sleep(2)
+        assert "Item 1" in page.inner_text("body")
+
+        # Click to add second item (partial append)
+        button.click()
+        sleep(2)
+        assert "Item 1" in page.inner_text("body")
+        assert "Item 2" in page.inner_text("body")
+
+        # Click to add third item (partial append)
+        button.click()
+        sleep(2)
+        assert "Item 1" in page.inner_text("body")
+        assert "Item 2" in page.inner_text("body")
+        assert "Item 3" in page.inner_text("body")
+        browser.close()
+
+
+def test_multiple_inputs_partial_replace():
+    """
+    Test partial replace with multiple interactive elements.
+
+    Strategy: 3_partial_replace
+    Trigger: Multiple inputs that change different parts of the content
+    """
+    setup_test_script(
+        contents="""
+from hstream import hs
+
+name = hs.text_input('Name', default_value='Alice')
+age = hs.number_input('Age', default_value=25)
+
+hs.markdown(f'## User Profile')
+hs.markdown(f'Name: {name}')
+hs.markdown(f'Age: {age}')
+hs.markdown(f'Status: Active')
+"""
+    )
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        page = browser.new_page()
+        page.goto("http://127.0.0.1:9000/")
+        sleep(2)
+
+        assert "Name: Alice" in page.inner_text("body")
+        assert "Age: 25" in page.inner_text("body")
+
+        # Change name (partial replace)
+        text_input = page.locator("input[type=text]")
+        text_input.fill("Bob")
+        text_input.press("Enter")
+        sleep(2)
+
+        assert "Name: Bob" in page.inner_text("body")
+        assert "Age: 25" in page.inner_text("body")
+        assert "Status: Active" in page.inner_text("body")
+
+        # Change age (partial replace)
+        number_input = page.locator("input[type=number]")
+        number_input.fill("30")
+        number_input.press("Enter")
+        sleep(2)
+
+        assert "Name: Bob" in page.inner_text("body")
+        assert "Age: 30" in page.inner_text("body")
+        browser.close()

From e77e77ea3211e0a8fefe78f82763d8d61b0830a1 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 25 Nov 2025 15:34:32 +0000
Subject: [PATCH 4/7] feat: add debug logging for diff strategy selection

Added logging to verify which diff strategy is selected during testing:
- Uncommented and enhanced print statement in views.py to log strategy
- Added verify_strategy_in_logs() helper function in tests
- Updated all diff strategy tests to capture and verify logs
- Tests now assert both the logged strategy AND the expected content

Each test now validates:
1. The correct diff strategy was selected (via log assertion)
2. The UI content matches expectations (existing assertions)

This provides comprehensive validation that the diff logic is working
correctly at both the selection and application levels.
---
 hstream/django_server/hs/views.py |  2 +-
 tests/test_diff_strategies.py     | 50 ++++++++++++++++++++++++++-----
 2 files changed, 44 insertions(+), 8 deletions(-)

diff --git a/hstream/django_server/hs/views.py b/hstream/django_server/hs/views.py
index bb8ff98..70cae86 100644
--- a/hstream/django_server/hs/views.py
+++ b/hstream/django_server/hs/views.py
@@ -82,7 +82,7 @@ def partial_or_full_html_content(request):
     update_strategy = pick_a_strategy(
         prev_html, html, get_session_var(request, "hs_script_running", False)
     )
-    # print(f"update strategy: {update_strategy}")
+    print(f"[DIFF_STRATEGY] Selected strategy: {update_strategy}")
     response = HttpResponse()
     if get_session_var(request, "hs_script_running", False):
         response.headers["HX-Trigger"] = "update_content_event"
diff --git a/tests/test_diff_strategies.py b/tests/test_diff_strategies.py
index d9fbf6a..4d4f784 100644
--- a/tests/test_diff_strategies.py
+++ b/tests/test_diff_strategies.py
@@ -23,7 +23,21 @@ def setup_test_script(contents):
     wait_for_server()
 
 
-def test_full_replace_strategy_on_initial_load():
+def verify_strategy_in_logs(capsys, expected_strategy):
+    """
+    Verify that the expected diff strategy was logged by the server.
+
+    Args:
+        capsys: pytest's capsys fixture for capturing stdout/stderr
+        expected_strategy: The strategy string to look for (e.g., "1_full_replace")
+    """
+    captured = capsys.readouterr()
+    all_output = captured.out + captured.err
+    strategy_log = f"[DIFF_STRATEGY] Selected strategy: {expected_strategy}"
+    assert strategy_log in all_output, f"Expected strategy '{expected_strategy}' not found in logs. Output:\n{all_output[-2000:]}"
+
+
+def test_full_replace_strategy_on_initial_load(capsys):
     """
     Test that full replace strategy is used on initial page load.
 
@@ -43,13 +57,16 @@ def test_full_replace_strategy_on_initial_load():
         page.goto("http://127.0.0.1:9000/")
         sleep(2)
 
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "1_full_replace")
+
         # Verify content is present (full replace happened)
         assert "Initial Load" in page.inner_text("body")
         assert "This is the first render" in page.inner_text("body")
         browser.close()
 
 
-def test_nothing_strategy_when_no_change():
+def test_nothing_strategy_when_no_change(capsys):
     """
     Test that nothing strategy is used when user action doesn't change output.
 
@@ -80,12 +97,15 @@ def test_nothing_strategy_when_no_change():
         button.click()
         sleep(2)
 
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "2_nothing")
+
         # Content should be identical (nothing strategy)
         assert page.inner_text("body") == initial_content
         browser.close()
 
 
-def test_partial_replace_strategy_when_content_changes():
+def test_partial_replace_strategy_when_content_changes(capsys):
     """
     Test that partial replace strategy is used when existing content changes.
 
@@ -116,13 +136,16 @@ def test_partial_replace_strategy_when_content_changes():
         text_input.press("Enter")
         sleep(2)
 
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "3_partial_replace")
+
         # Content should be updated (partial replace)
         assert "You typed: updated" in page.inner_text("body")
         assert "This line stays the same" in page.inner_text("body")
         browser.close()
 
 
-def test_partial_replace_strategy_when_elements_removed():
+def test_partial_replace_strategy_when_elements_removed(capsys):
     """
     Test that partial replace strategy is used when conditional elements are removed.
 
@@ -161,6 +184,9 @@ def test_partial_replace_strategy_when_elements_removed():
         text_input.focus()  # Trigger update
         sleep(2)
 
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "3_partial_replace")
+
         # Conditional lines should be gone
         assert "Line 1: Always visible" in page.inner_text("body")
         assert "Line 2: Always visible" in page.inner_text("body")
@@ -168,7 +194,7 @@ def test_partial_replace_strategy_when_elements_removed():
         browser.close()
 
 
-def test_partial_append_strategy_when_elements_added():
+def test_partial_append_strategy_when_elements_added(capsys):
     """
     Test that partial append strategy is used when new elements are added.
 
@@ -207,6 +233,9 @@ def test_partial_append_strategy_when_elements_added():
         text_input.focus()  # Trigger update
         sleep(2)
 
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "4_partial_append")
+
         # New lines should be appended
         assert "Line 1: Always here" in page.inner_text("body")
         assert "Line 2: Always here" in page.inner_text("body")
@@ -215,7 +244,7 @@ def test_partial_append_strategy_when_elements_added():
         browser.close()
 
 
-def test_partial_append_with_counter():
+def test_partial_append_with_counter(capsys):
     """
     Test partial append strategy with a counter that adds items incrementally.
 
@@ -258,6 +287,10 @@ def test_partial_append_with_counter():
         # Click to add second item (partial append)
         button.click()
         sleep(2)
+
+        # Verify correct strategy was selected for append
+        verify_strategy_in_logs(capsys, "4_partial_append")
+
         assert "Item 1" in page.inner_text("body")
         assert "Item 2" in page.inner_text("body")
 
@@ -270,7 +303,7 @@ def test_partial_append_with_counter():
         browser.close()
 
 
-def test_multiple_inputs_partial_replace():
+def test_multiple_inputs_partial_replace(capsys):
     """
     Test partial replace with multiple interactive elements.
 
@@ -305,6 +338,9 @@ def test_multiple_inputs_partial_replace():
         text_input.press("Enter")
         sleep(2)
 
+        # Verify correct strategy was selected
+        verify_strategy_in_logs(capsys, "3_partial_replace")
+
         assert "Name: Bob" in page.inner_text("body")
         assert "Age: 25" in page.inner_text("body")
         assert "Status: Active" in page.inner_text("body")

From 257bae7934bc1162f951d14cb7c4884dd77cecee Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 25 Nov 2025 15:42:37 +0000
Subject: [PATCH 5/7] style: fix linting issues from pre-commit hooks

- Remove duplicate imports in views.py
- Fix unused variable in demo/example.py
- Make component re-export explicit in __init__.py
- Apply black formatting
- Fix trailing whitespace and end-of-file issues
---
 agents.md                         |  2 +-
 architecture.md                   |  2 +-
 demo/example.py                   |  7 ++++---
 demo/file upload.py               |  5 +++--
 hstream/__init__.py               |  2 +-
 hstream/components/components.py  | 16 +++++++++-------
 hstream/django_server/hs/views.py | 26 ++++++++++++--------------
 test_custom_component.py          |  7 +++++--
 tests/test_diff_strategies.py     |  4 +++-
 9 files changed, 39 insertions(+), 32 deletions(-)

diff --git a/agents.md b/agents.md
index 23733c1..c238f96 100644
--- a/agents.md
+++ b/agents.md
@@ -1 +1 @@
-@architecture.md
\ No newline at end of file
+@architecture.md
diff --git a/architecture.md b/architecture.md
index 089ba03..e32b5a8 100644
--- a/architecture.md
+++ b/architecture.md
@@ -9,7 +9,7 @@ This flow covers the process from running the command to the user seeing the ini
 ```mermaid
 stateDiagram-v2
     direction LR
-    
+
     state "CLI & Server Startup" as Startup {
         [*] --> RunCommand: hstream run <script>
         RunCommand --> DjangoBoot: run_server()
diff --git a/demo/example.py b/demo/example.py
index 359b438..c5f264f 100644
--- a/demo/example.py
+++ b/demo/example.py
@@ -35,14 +35,15 @@
     """
     )
 
-
     hs.markdown("""Or create forms like:""")
     with hs.html("form"):
         user_number = hs.number_input(
             "Input a number",
             default_value=0,
         )
-        hs.markdown(f"Your number is {'*even*' if int(user_number) % 2 == 0 else '*odd*'}")
+        hs.markdown(
+            f"Your number is {'*even*' if int(user_number) % 2 == 0 else '*odd*'}"
+        )
     with hs.html("header"):
         hs.markdown("## HStream also supports displaying plots")
     with hs.html("section"):
@@ -72,7 +73,7 @@
             fig, ax = plt.subplots()
             ax.plot(x, y)
             hs.pyplot(fig, key="myplot")
-        except Exception as e:
+        except Exception:
             hs.markdown(
                 "hmmm seems you don't have matplotlib installed, please install it with `pip install matplotlib`"
             )
diff --git a/demo/file upload.py b/demo/file upload.py
index 20481b9..6f9e31e 100644
--- a/demo/file upload.py	
+++ b/demo/file upload.py	
@@ -1,8 +1,9 @@
 from hstream import hs
+
 hs.markdown("# upload")
 uploaded_file = hs.file_upload("Upload your file")
 
 if uploaded_file and hs.button("Process and Download"):
-    hs.markdown('uploaded')
-    
+    hs.markdown("uploaded")
+
 hs.markdown(uploaded_file)
diff --git a/hstream/__init__.py b/hstream/__init__.py
index a0fc718..52fc2e5 100644
--- a/hstream/__init__.py
+++ b/hstream/__init__.py
@@ -1,5 +1,5 @@
 from hstream.hs import hs as hstream
-from hstream.components.components import component
+from hstream.components.components import component as component
 
 
 hs = hstream()
diff --git a/hstream/components/components.py b/hstream/components/components.py
index 97f908a..01c34db 100644
--- a/hstream/components/components.py
+++ b/hstream/components/components.py
@@ -48,7 +48,6 @@ def component(component_function):
     return wrapped_func
 
 
-
 class ComponentsGeneric:
     def get_key_based_on_call(self, message):
         """Displays a navigation bar with a list of items.
@@ -525,7 +524,7 @@ def write_dataframe(self, df, key: str = None, striped=False, **kwargs) -> None:
                 .replace('class="dataframe"', f'class="{striped}"')
             )
             self.doc.asis(html)
-            
+
     @component_wrapper
     def file_upload(
         self,
@@ -546,13 +545,16 @@ def file_upload(
         """
         with self.tag("label"):
             self.text(label)
-        
+
         # Check if we have a filename
         has_file = kwargs.get("value") and isinstance(kwargs["value"], str)
-        
+
         if has_file:
             # Show current file info with option to clear
-            with self.tag("div", style="margin: 5px 0; padding: 10px; background-color: #f0f0f0; border-radius: 3px; display: flex; justify-content: space-between; align-items: center;"):
+            with self.tag(
+                "div",
+                style="margin: 5px 0; padding: 10px; background-color: #f0f0f0; border-radius: 3px; display: flex; justify-content: space-between; align-items: center;",
+            ):
                 with self.tag("span"):
                     self.text(f"Current file: {kwargs['value']}")
                 with self.tag(
@@ -561,7 +563,7 @@ def file_upload(
                     ("hx-vals", '{"new_value": null}'),
                     ("hx-swap", "none"),
                     ("type", "button"),
-                    style="background-color: #ff4444; color: white; border: none; padding: 5px 10px; border-radius: 3px; cursor: pointer;"
+                    style="background-color: #ff4444; color: white; border: none; padding: 5px 10px; border-radius: 3px; cursor: pointer;",
                 ):
                     self.text("Remove")
         else:
@@ -577,6 +579,6 @@ def file_upload(
                 ("hx-encoding", "multipart/form-data"),
             ):
                 pass
-        
+
         # Return the filename directly
         return lambda x: str(x) if x else None
diff --git a/hstream/django_server/hs/views.py b/hstream/django_server/hs/views.py
index 70cae86..beac9d6 100644
--- a/hstream/django_server/hs/views.py
+++ b/hstream/django_server/hs/views.py
@@ -173,44 +173,42 @@ def run_user_code_and_return_hs_instance(file: Path, request: HttpRequest) -> hs
     finally:
         set_session_var(request, "hs_script_should_stop", False)
     return users_hs_instance
-import os
-import tempfile
-from pathlib import Path
+
 
 def set_component_value(
     request: HttpRequest,
 ):
     component_id = request.GET.get("component_id")
-    
+
     request_server_stop_running_user_script(request, wait=True)
-    
+
     # Handle file uploads
     if request.FILES and "new_value" in request.FILES:
         uploaded_file = request.FILES["new_value"]
-        
+
         # Create tmp directory if it doesn't exist
         tmp_dir = Path("tmp")
         tmp_dir.mkdir(exist_ok=True)
-        
+
         # Save file to tmp directory
         file_path = tmp_dir / uploaded_file.name
-        with open(file_path, 'wb') as f:
+        with open(file_path, "wb") as f:
             for chunk in uploaded_file.chunks():
                 f.write(chunk)
-        
+
         # Set the filename as the value
         new_value = uploaded_file.name
-        print(f'File saved to: {file_path}')
-        
+        print(f"File saved to: {file_path}")
+
     else:
         # Handle regular form data
         new_value = request.POST.get("new_value")
         if new_value is None:
             new_value = request.GET.get("new_value")
-    
+
     set_session_var(request, component_id, new_value)
-    print('Component value set to:', new_value)
-    
+    print("Component value set to:", new_value)
+
     response = HttpResponse(f"suc: {request.session[component_id]}", status=200)
     response.headers["HX-Reswap"] = "none"
     response.headers["HX-Trigger"] = "trigger_run_hs_event"
diff --git a/test_custom_component.py b/test_custom_component.py
index 700eec5..6fa913f 100644
--- a/test_custom_component.py
+++ b/test_custom_component.py
@@ -1,22 +1,25 @@
 from hstream import hstream as hs
 from hstream import component
 
+
 @component
 def my_custom_component(self, label, key=None, **kwargs):
     with self.tag("div", ("class", "custom-component")):
         self.text(f"Custom: {label}")
     return "custom_value"
 
+
 def test_custom_component():
     # Verify the method exists on the hs instance
     assert hasattr(hs, "my_custom_component")
-    
-    # Verify it runs (this is a basic check, fully running it requires the django context usually, 
+
+    # Verify it runs (this is a basic check, fully running it requires the django context usually,
     # but we can check if the method is callable and returns what we expect from the wrapper)
     # Note: The wrapper expects 'key' or generates one, and interacts with _hs_session.
     # For this unit test, we might hit session errors if we run it fully without mocking.
     # Let's just check registration for now.
     print("Custom component registered successfully")
 
+
 if __name__ == "__main__":
     test_custom_component()
diff --git a/tests/test_diff_strategies.py b/tests/test_diff_strategies.py
index 4d4f784..fbea6e8 100644
--- a/tests/test_diff_strategies.py
+++ b/tests/test_diff_strategies.py
@@ -34,7 +34,9 @@ def verify_strategy_in_logs(capsys, expected_strategy):
     captured = capsys.readouterr()
     all_output = captured.out + captured.err
     strategy_log = f"[DIFF_STRATEGY] Selected strategy: {expected_strategy}"
-    assert strategy_log in all_output, f"Expected strategy '{expected_strategy}' not found in logs. Output:\n{all_output[-2000:]}"
+    assert (
+        strategy_log in all_output
+    ), f"Expected strategy '{expected_strategy}' not found in logs. Output:\n{all_output[-2000:]}"
 
 
 def test_full_replace_strategy_on_initial_load(capsys):

From ae5a758541eb32ab1f36c38e850db2e5f05b7f1c Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 25 Nov 2025 23:10:22 +0000
Subject: [PATCH 6/7] feat: implement auto-versioning with hatch-vcs and GitHub
 tags
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This commit implements automatic version management and PyPI publishing:

**Changes:**
- Updated pyproject.toml to use dynamic versioning via hatch-vcs
- Version now derived from git tags instead of hardcoded value
- Split workflow into separate test and publish jobs
- Added automatic tag creation on every push to main (patch bump)
- Auto-publish to PyPI when tag is created
- Create GitHub releases automatically with changelog

**How it works:**
1. Every push to main runs tests
2. Tests pass → auto-creates new tag (v0.1.58 → v0.1.59)
3. Tag creation triggers build with version from tag
4. Package automatically published to PyPI
5. GitHub release created with changelog

**Benefits:**
- No manual version updates needed
- Version controlled via git tags
- Only publishes on tagged releases
- Prevents accidental publishes
- Automated release notes

To manually trigger a specific version bump:
- Patch: git commit -m "fix: bug fix"
- Minor: git commit -m "feat: new feature"
- Major: git commit -m "feat!: breaking change"
---
 .github/workflows/python-app.yml | 54 ++++++++++++++++++++++++++++----
 .gitignore                       |  3 ++
 pyproject.toml                   | 10 ++++--
 uv.lock                          |  3 +-
 4 files changed, 60 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/python-app.yml b/.github/workflows/python-app.yml
index aaa8825..6a503db 100644
--- a/.github/workflows/python-app.yml
+++ b/.github/workflows/python-app.yml
@@ -3,16 +3,17 @@ name: Python application
 on: [push, pull_request]
 
 jobs:
-  build:
-
+  test:
     runs-on: ubuntu-latest
 
     steps:
     - name: Checkout repository
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Fetch all history for versioning
 
     - name: Set up Python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v4
       with:
         python-version: '3.x'
 
@@ -37,14 +38,55 @@ jobs:
       run: |
         uv run pytest --reruns 3 # githubs playwright sometimes fails
 
+  publish:
+    needs: test
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write  # Allows pushing tags
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0  # Fetch all history for versioning
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.x'
+
+    - name: Install UV
+      run: |
+        curl -LsSf https://astral.sh/uv/install.sh | sh
+        echo "$HOME/.cargo/bin" >> $GITHUB_PATH
+
+    - name: Install dependencies
+      run: |
+        uv sync
+
+    - name: Bump version and push tag
+      id: tag_version
+      uses: mathieudutour/github-tag-action@v6.1
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        default_bump: patch
+        tag_prefix: v
+
     - name: Build package
-      if: github.ref == 'refs/heads/main'
       run: |
         uv build
 
     - name: Publish package to PyPI
-      if: github.ref == 'refs/heads/main'
       env:
         UV_PUBLISH_TOKEN: ${{ secrets.PYPI_TOKEN }}
       run: |
         uv publish
+
+    - name: Create GitHub Release
+      uses: ncipollo/release-action@v1
+      with:
+        tag: ${{ steps.tag_version.outputs.new_tag }}
+        name: Release ${{ steps.tag_version.outputs.new_tag }}
+        body: ${{ steps.tag_version.outputs.changelog }}
diff --git a/.gitignore b/.gitignore
index ecc9912..56719c5 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,6 +2,9 @@
 Dockerfile
 example.py
 
+# Auto-generated version file
+hstream/_version.py
+
 .*pyc
 # Byte-compiled / optimized / DLL files
 __pycache__/
diff --git a/pyproject.toml b/pyproject.toml
index 989956d..f4170d7 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = "hstream"
-version = "0.1.57"
+dynamic = ["version"]
 description = ""
 authors = [{ name = "Conrad", email = "conradbez1@gmail.com" }]
 readme = "README.md"
@@ -16,6 +16,12 @@ dependencies = [
 [project.scripts]
 hstream = "hstream.cli:cli"
 
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build.hooks.vcs]
+version-file = "hstream/_version.py"
+
 [tool.uv]
 dev-dependencies = [
     "black>=24.4.2",
@@ -32,5 +38,5 @@ dev-dependencies = [
 ]
 
 [build-system]
-requires = ["hatchling"]
+requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
diff --git a/uv.lock b/uv.lock
index 24de1e9..fb7d564 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,5 +1,5 @@
 version = 1
-revision = 2
+revision = 3
 requires-python = ">=3.10"
 resolution-markers = [
     "python_full_version >= '3.12'",
@@ -364,7 +364,6 @@ wheels = [
 
 [[package]]
 name = "hstream"
-version = "0.1.57"
 source = { editable = "." }
 dependencies = [
     { name = "beautifulsoup4" },

From 9024342353ab6dbad7bcd4f7f04d70d4fa470cc3 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 25 Nov 2025 23:18:20 +0000
Subject: [PATCH 7/7] docs: update CONTRIBUTE.md with auto-versioning workflow

- Added How It Works section explaining auto-deploy flow
- Added Initial Setup instructions for creating first tag
- Added Manual Version Bumps section for semantic versioning
- Moved old manual process to collapsed section for reference
---
 CONTRIBUTE.md | 47 +++++++++++++++++++++++++++++++++++++++++++----
 1 file changed, 43 insertions(+), 4 deletions(-)

diff --git a/CONTRIBUTE.md b/CONTRIBUTE.md
index 72ceb9a..ee15d7a 100644
--- a/CONTRIBUTE.md
+++ b/CONTRIBUTE.md
@@ -1,15 +1,54 @@
 ## Deploy
 
-1. increment version in `setup.py`
+We use automatic versioning and deployment with hatch-vcs and GitHub Actions.
 
-2. `rm -rf build/ hstream.egg-info/ dist/`
+### How It Works:
 
-3. `pip install twine build`
+```
+Push to main → Tests pass → Auto-create tag → Build with version → Publish to PyPI → Create GitHub release
+```
 
-4. `python -m build`
+Every push to the main branch will:
+1. Run all tests
+2. Automatically create a new git tag (patch version bump: v0.1.58 → v0.1.59)
+3. Build the package with the version from the tag
+4. Publish to PyPI automatically
+5. Create a GitHub release with changelog
+
+### Important: Initial Setup Needed
+
+Before the auto-versioning works, you need to create an initial tag:
+
+```bash
+# Switch to main branch and create initial tag
+git checkout main
+git tag v0.1.58  # Use the next version number
+git push origin v0.1.58
+```
+
+After that, every push to main will auto-increment the patch version.
+
+### Manual Version Bumps
 
+The default is to bump the patch version (0.1.X), but you can control the version bump with commit messages:
+
+- **Patch bump** (default): `git commit -m "fix: bug fix"`
+- **Minor bump**: `git commit -m "feat: new feature"`
+- **Major bump**: `git commit -m "feat!: breaking change"`
+
+### Old Manual Process (Deprecated)
+
+<details>
+<summary>Click to see the old manual deployment process (no longer used)</summary>
+
+1. increment version in `setup.py`
+2. `rm -rf build/ hstream.egg-info/ dist/`
+3. `pip install twine build`
+4. `python -m build`
 5. `twine upload dist/*`
 
+</details>
+
 ## Kill orphaned uvicorn processes
 
 `kill -9 $(lsof -t -i:8000)` (or whatever port they we're using)