solarwindpy 0.0.1.dev0__py3-none-any.whl → 0.1.1__py3-none-any.whl

tests/test_statusline.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""Tests for .claude/statusline.py color functionality."""
+
+import pytest
+import os
+import sys
+import tempfile
+import json
+from unittest.mock import patch, MagicMock
+from pathlib import Path
+
+# Add .claude to path to import statusline
+sys.path.insert(0, str(Path(__file__).parent.parent / ".claude"))
+import statusline
+
+
+class TestColors:
+    """Test the Colors class and ANSI color functionality."""
+
+    def test_color_codes(self):
+        """Test ANSI color codes are correct."""
+        assert statusline.Colors.RED == "\033[91m"
+        assert statusline.Colors.YELLOW == "\033[93m"
+        assert statusline.Colors.GREEN == "\033[92m"
+        assert statusline.Colors.RESET == "\033[0m"
+
+    def test_colorize_with_no_color_env(self):
+        """Test NO_COLOR environment variable disables colors."""
+        with patch.dict(os.environ, {"NO_COLOR": "1"}):
+            result = statusline.Colors.colorize("test", statusline.Colors.RED)
+            assert result == "test"  # No color codes
+
+    def test_colorize_with_non_tty(self):
+        """Test colors disabled when not TTY."""
+        with patch("sys.stdout.isatty", return_value=False):
+            result = statusline.Colors.colorize("test", statusline.Colors.RED)
+            assert result == "test"  # No color codes
+
+    def test_colorize_with_tty(self):
+        """Test colors applied when TTY and NO_COLOR not set."""
+        with (
+            patch("sys.stdout.isatty", return_value=True),
+            patch.dict(os.environ, {}, clear=True),
+        ):
+            result = statusline.Colors.colorize("test", statusline.Colors.RED)
+            assert result == f"{statusline.Colors.RED}test{statusline.Colors.RESET}"
+
+    def test_color_methods(self):
+        """Test individual color methods."""
+        with (
+            patch("sys.stdout.isatty", return_value=True),
+            patch.dict(os.environ, {}, clear=True),
+        ):
+            assert (
+                statusline.Colors.red("test")
+                == f"{statusline.Colors.RED}test{statusline.Colors.RESET}"
+            )
+            assert (
+                statusline.Colors.yellow("test")
+                == f"{statusline.Colors.YELLOW}test{statusline.Colors.RESET}"
+            )
+            assert (
+                statusline.Colors.green("test")
+                == f"{statusline.Colors.GREEN}test{statusline.Colors.RESET}"
+            )
+
+
+class TestThresholds:
+    """Test threshold constants."""
+
+    def test_token_thresholds(self):
+        """Test token threshold values."""
+        assert statusline.Thresholds.TOKEN_YELLOW == 150_000
+        assert statusline.Thresholds.TOKEN_RED == 180_000
+
+    def test_compaction_thresholds(self):
+        """Test compaction threshold values."""
+        assert statusline.Thresholds.COMPACTION_YELLOW_RATIO == 0.6
+        assert statusline.Thresholds.COMPACTION_RED_RATIO == 0.8
+
+    def test_session_thresholds(self):
+        """Test session duration threshold values."""
+        assert statusline.Thresholds.SESSION_YELLOW_HOURS == 6
+        assert statusline.Thresholds.SESSION_RED_HOURS == 12
+
+
+class TestTokenUsage:
+    """Test token usage estimation and color coding."""
+
+    def test_token_usage_green(self):
+        """Test green color for low token usage."""
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            # Write 100k chars (25k tokens)
+            tf.write(b"x" * 100_000)
+            tf.flush()
+
+            data = {"transcript_path": tf.name}
+            result = statusline.estimate_token_usage(data)
+
+            # Should be green (no color codes when testing)
+            with patch("sys.stdout.isatty", return_value=False):
+                clean_result = statusline.estimate_token_usage(data)
+                assert clean_result == "25k"
+
+        os.unlink(tf.name)
+
+    def test_token_usage_yellow(self):
+        """Test yellow color for medium token usage."""
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            # Write 600k chars (150k tokens)
+            tf.write(b"x" * 600_000)
+            tf.flush()
+
+            data = {"transcript_path": tf.name}
+            with patch("sys.stdout.isatty", return_value=False):
+                result = statusline.estimate_token_usage(data)
+                assert result == "150k"
+
+        os.unlink(tf.name)
+
+    def test_token_usage_red(self):
+        """Test red color for high token usage."""
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            # Write 800k chars (200k tokens)
+            tf.write(b"x" * 800_000)
+            tf.flush()
+
+            data = {"transcript_path": tf.name}
+            with patch("sys.stdout.isatty", return_value=False):
+                result = statusline.estimate_token_usage(data)
+                assert result == "200k"
+
+        os.unlink(tf.name)
+
+    def test_token_usage_missing_file(self):
+        """Test handling of missing transcript file."""
+        data = {"transcript_path": "/nonexistent/file.txt"}
+        result = statusline.estimate_token_usage(data)
+        assert result == "0"
+
+
+class TestCompactionIndicator:
+    """Test compaction indicator and color coding."""
+
+    def test_compaction_green_low(self):
+        """Test green for low file size."""
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            # Write 200KB (25% of 800KB threshold)
+            tf.write(b"x" * 200_000)
+            tf.flush()
+
+            data = {"transcript_path": tf.name}
+            with patch("sys.stdout.isatty", return_value=False):
+                result = statusline.get_compaction_indicator(data)
+                assert result == "●●●"
+
+        os.unlink(tf.name)
+
+    def test_compaction_yellow(self):
+        """Test yellow for medium file size."""
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            # Write 560KB (70% of 800KB threshold)
+            tf.write(b"x" * 560_000)
+            tf.flush()
+
+            data = {"transcript_path": tf.name}
+            with patch("sys.stdout.isatty", return_value=False):
+                result = statusline.get_compaction_indicator(data)
+                assert result == "●○○"
+
+        os.unlink(tf.name)
+
+    def test_compaction_red(self):
+        """Test red for high file size."""
+        with tempfile.NamedTemporaryFile(delete=False) as tf:
+            # Write 720KB (90% of 800KB threshold)
+            tf.write(b"x" * 720_000)
+            tf.flush()
+
+            data = {"transcript_path": tf.name}
+            with patch("sys.stdout.isatty", return_value=False):
+                result = statusline.get_compaction_indicator(data)
+                assert result == "○○○"
+
+        os.unlink(tf.name)
+
+
+class TestUsageIndicator:
+    """Test usage indicator and session duration."""
+
+    def test_usage_green_fresh(self):
+        """Test green for fresh session."""
+        with (
+            patch("time.time", return_value=1000),
+            patch("pathlib.Path.exists", return_value=True),
+            patch("pathlib.Path.read_text", return_value="999.5"),
+        ):  # 0.5 hours ago
+            with patch("sys.stdout.isatty", return_value=False):
+                result = statusline.get_usage_indicator()
+                assert result == "█████"
+
+    def test_usage_thresholds_logic(self):
+        """Test that usage indicator logic follows correct thresholds."""
+        # Test that SESSION_YELLOW_HOURS and SESSION_RED_HOURS are used correctly
+        assert statusline.Thresholds.SESSION_YELLOW_HOURS == 6
+        assert statusline.Thresholds.SESSION_RED_HOURS == 12
+
+        # Test the pattern mapping
+        # <1h: █████, <3h: ████○, <6h: ███○○, <12h: ██○○○, ≥12h: █○○○○
+
+
+class TestStatusLineIntegration:
+    """Test complete status line creation."""
+
+    def test_create_status_line_basic(self):
+        """Test basic status line creation."""
+        data = {
+            "model": {"display_name": "Claude Sonnet 4"},
+            "workspace": {"current_dir": "/Users/test/project"},
+            "transcript_path": "/dev/null",
+        }
+
+        with (
+            patch("subprocess.run") as mock_run,
+            patch("os.environ.get", return_value=""),
+            patch("statusline.estimate_token_usage", return_value="25k"),
+            patch("statusline.get_compaction_indicator", return_value="●●●"),
+            patch("statusline.get_usage_indicator", return_value="█████"),
+        ):
+
+            mock_run.return_value.returncode = 0
+            mock_run.return_value.stdout = "main\n"
+
+            result = statusline.create_status_line(data)
+            assert "[Claude Sonnet 4]" in result
+            assert "📁 project" in result
+            assert "🔤 25k" in result
+            assert "⏱️ ●●●" in result
+            assert "📊 █████" in result
+
+
+if __name__ == "__main__":
+    # Demo script to show colors
+    print("=== StatusLine Color Demo ===")
+    print()
+
+    # Force colors on for demo
+    os.environ.pop("NO_COLOR", None)
+
+    with patch("sys.stdout.isatty", return_value=True):
+        print("Token Usage Colors:")
+        print(f"  Green (low): {statusline.Colors.green('25k tokens')}")
+        print(f"  Yellow (medium): {statusline.Colors.yellow('160k tokens')}")
+        print(f"  Red (high): {statusline.Colors.red('190k tokens')}")
+        print()
+
+        print("Compaction Indicator Colors:")
+        print(f"  Green (safe): {statusline.Colors.green('●●●')}")
+        print(f"  Yellow (warning): {statusline.Colors.yellow('●○○')}")
+        print(f"  Red (critical): {statusline.Colors.red('○○○')}")
+        print()
+
+        print("Usage Indicator Colors:")
+        print(f"  Green (light): {statusline.Colors.green('█████')}")
+        print(f"  Yellow (medium): {statusline.Colors.yellow('███○○')}")
+        print(f"  Red (heavy): {statusline.Colors.red('██○○○')}")
+        print()
+
+        # Sample status line with colors
+        print("Sample Status Line:")
+        sample_data = {
+            "model": {"display_name": "Claude Sonnet 4"},
+            "workspace": {"current_dir": "/Users/test/SolarWindPy"},
+            "transcript_path": "/dev/null",
+        }
+
+        with (
+            patch("subprocess.run") as mock_run,
+            patch("os.environ.get", return_value="solarwindpy-20250404"),
+            patch(
+                "statusline.estimate_token_usage",
+                return_value=statusline.Colors.yellow("160k"),
+            ),
+            patch(
+                "statusline.get_compaction_indicator",
+                return_value=statusline.Colors.yellow("●○○"),
+            ),
+            patch(
+                "statusline.get_usage_indicator",
+                return_value=statusline.Colors.green("█████"),
+            ),
+        ):
+
+            mock_run.return_value.returncode = 0
+            mock_run.return_value.stdout = "feature/solar-activity-testing\n"
+
+            result = statusline.create_status_line(sample_data)
+            print(f"  {result}")

solarwindpy-0.0.1.dev0.dist-info/METADATA

@@ -1,14 +0,0 @@
-Metadata-Version: 2.1
-Name: solarwindpy
-Version: 0.0.1.dev0
-Summary: UNKNOWN
-Home-page: UNKNOWN
-Author: B. L. Alterman
-Author-email: balterma@umich.edu
-License: UNKNOWN
-Platform: UNKNOWN
-Classifier: Development Status :: 1 - Planning
-
-UNKNOWN
-
-

solarwindpy-0.0.1.dev0.dist-info/RECORD

@@ -1,4 +0,0 @@
-solarwindpy-0.0.1.dev0.dist-info/METADATA,sha256=Br45IOAahb-_Cp8MMwN2lIRuUT-FLp3yjQPHCxBiZoY,245
-solarwindpy-0.0.1.dev0.dist-info/WHEEL,sha256=_NOXIqFgOaYmlm9RJLPQZ13BJuEIrp5jx5ptRD5uh3Y,92
-solarwindpy-0.0.1.dev0.dist-info/top_level.txt,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-solarwindpy-0.0.1.dev0.dist-info/RECORD,,

solarwindpy-0.0.1.dev0.dist-info/top_level.txt

@@ -1 +0,0 @@
-