kop-cli 0.2.0b1__tar.gz → 0.2.0b2__tar.gz

{kop_cli-0.2.0b1 → kop_cli-0.2.0b2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kop-cli
-Version: 0.2.0b1
+Version: 0.2.0b2
 Summary: Terminal-based kubernetes operation platform
 Author-email: vegaoqiang <vegaoqiang@gmail.com>
 License-Expression: Apache-2.0

kop_cli-0.2.0b2/scripts/set_release_version.py

@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Set the source package version using PEP 440 normalization."""
+
+from __future__ import annotations
+
+import argparse
+import re
+from pathlib import Path
+
+try:
+    from packaging.version import Version
+except ModuleNotFoundError:
+    from pip._vendor.packaging.version import Version
+
+
+VERSION_PATTERN = re.compile(r'^__version__\s*=\s*["\']([^"\']+)["\']\s*$')
+
+
+def read_version(path: Path) -> str:
+    for line in path.read_text(encoding="utf-8").splitlines():
+        match = VERSION_PATTERN.match(line)
+        if match:
+            return match.group(1)
+    raise SystemExit(f"Unable to find __version__ in {path}")
+
+
+def write_version(path: Path, version: str) -> None:
+    lines = path.read_text(encoding="utf-8").splitlines(keepends=True)
+    for index, line in enumerate(lines):
+        if VERSION_PATTERN.match(line.strip()):
+            newline = "\n" if line.endswith("\n") else ""
+            lines[index] = f'__version__ = "{version}"{newline}'
+            path.write_text("".join(lines), encoding="utf-8")
+            return
+    raise SystemExit(f"Unable to find __version__ in {path}")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("version", nargs="?")
+    parser.add_argument("--path", default="src/kop/__init__.py")
+    args = parser.parse_args()
+
+    version_path = Path(args.path)
+    if args.version:
+        write_version(version_path, str(Version(args.version)))
+
+    print(read_version(version_path))
+
+
+if __name__ == "__main__":
+    main()

kop_cli-0.2.0b2/src/kop/__init__.py

@@ -0,0 +1,2 @@
+__version__ = "0.2.0b2"
+__git_commit__ = ""

{kop_cli-0.2.0b1 → kop_cli-0.2.0b2}/src/kop/renderers/fields.py

@@ -38,7 +38,7 @@ def container_status_renderer(value):
     if ephemeral_container_statuses is None:
         ephemeral_container_statuses = []
 
-    all_container_status = value.container_statuses + init_container_statuses + ephemeral_container_statuses
+    all_container_status = value.container_statuses or [] + init_container_statuses + ephemeral_container_statuses
     status_texts = []
     for cs in all_container_status:
         if cs.ready and cs.started:

{kop_cli-0.2.0b1 → kop_cli-0.2.0b2}/src/kop/views/ResourceView.py

@@ -94,7 +94,7 @@ class ResourceView(Screen):
         self.resource_type: Optional[str] = None
         self.resource_kind_name: Optional[str] = None
         self.page_index: int = 0
-        self.resource_pages: dict[str, list[tuple[object, list, Optional[str]]]] = {}
+        self.resource_pages: dict[str, list[tuple[object, list, Optional[str], int]]] = {}
 
     def compose(self) -> ComposeResult: 
             yield Header()
@@ -179,10 +179,10 @@ class ResourceView(Screen):
         namespace: Optional[str],
         keyword: Optional[str],
         continue_token: Optional[str] = None,
-    ) -> Tuple[Optional[BaseFactory], Optional[object], list]:
+    ) -> Tuple[Optional[BaseFactory], Optional[object], list, int]:
         factory_cls = ResourceRegistry.get_factory(resource_type)
         if not factory_cls:
-            return None, None, []
+            return None, None, [], 0
         factory = factory_cls(self.endpoint)
         try:
             data = factory.fetch(
@@ -192,11 +192,10 @@ class ResourceView(Screen):
             )
         except TypeError:
             data = factory.fetch(namespace=namespace)
-        if keyword:
-            data = factory.filter(data, keyword)
-        cleaned = factory.clean(data)
+        filtered = factory.filter(data, keyword) if keyword else data
+        cleaned = factory.clean(filtered)
         cleaned.sort(key=lambda vm: vm.name)
-        return factory, data, cleaned
+        return factory, data, cleaned, len(filtered.items)
 
     def _fetch_resource_with_timeout(
         self,
@@ -205,7 +204,7 @@ class ResourceView(Screen):
         keyword: Optional[str],
         timeout: float,
         continue_token: Optional[str] = None,
-    ) -> Tuple[Optional[BaseFactory], Optional[object], list]:
+    ) -> Tuple[Optional[BaseFactory], Optional[object], list, int]:
         """Run kubernetes fetch in a daemon thread so app shutdown isn't blocked by stuck API calls."""
         result: Queue[Tuple[str, object]] = Queue(maxsize=1)
 
@@ -264,7 +263,9 @@ class ResourceView(Screen):
         page_index: int,
         factory: Optional[BaseFactory],
         data: Optional[object],
+        keyword: Optional[str],
         cleaned: list,
+        resource_count: int,
     ) -> None:
         if request_id != self._resource_request_id:
             return
@@ -274,10 +275,15 @@ class ResourceView(Screen):
 
         self.FACTORY_CACHE = factory
         self.data = data
+        if keyword != self.keyword:
+            filtered = factory.filter(data, self.keyword) if self.keyword else data
+            cleaned = factory.clean(filtered)
+            cleaned.sort(key=lambda vm: vm.name)
+            resource_count = len(filtered.items)
         next_token = getattr(getattr(data, "metadata", None), "_continue", None)
         cache_key = self._resource_cache_key(resource_type, namespace)
         pages = self.resource_pages.setdefault(cache_key, [])
-        page_entry = (data, cleaned, next_token)
+        page_entry = (data, cleaned, next_token, resource_count)
         if page_index < len(pages):
             pages[page_index] = page_entry
             del pages[page_index + 1 :]
@@ -296,7 +302,7 @@ class ResourceView(Screen):
             self.table.raw_data = data.items
             self.table.data = cleaned
 
-        self.panel.resource_count = len(data.items)
+        self.panel.resource_count = resource_count
 
     def _handle_resource_error(self, request_id: int, exc: Exception) -> None:
         if request_id != self._resource_request_id:
@@ -316,7 +322,7 @@ class ResourceView(Screen):
     ) -> None:
         worker = get_current_worker()
         try:
-            factory, data, cleaned = self._fetch_resource_with_timeout(
+            factory, data, cleaned, resource_count = self._fetch_resource_with_timeout(
                 resource_type,
                 namespace,
                 keyword,
@@ -337,7 +343,9 @@ class ResourceView(Screen):
             page_index,
             factory,
             data,
+            keyword,
             cleaned,
+            resource_count,
         )
 
     def _load_resource(
@@ -367,14 +375,19 @@ class ResourceView(Screen):
         pages = self.resource_pages.get(cache_key, [])
         if page_index < 0 or page_index >= len(pages):
             return False
-        data, cleaned, _ = pages[page_index]
+        if not self.FACTORY_CACHE:
+            return False
+        data, _cleaned, _continue_token, _resource_count = pages[page_index]
         self.data = data
         self.page_index = page_index
+        filtered = self.FACTORY_CACHE.filter(data, self.keyword) if self.keyword else data
+        cleaned = self.FACTORY_CACHE.clean(filtered)
+        cleaned.sort(key=lambda vm: vm.name)
         if self.table:
             self.table.raw_data = data.items
             self.table.data = cleaned
         if self.panel:
-            self.panel.resource_count = len(data.items)
+            self.panel.resource_count = len(filtered.items)
         self.refresh_bindings()
         return True
         

{kop_cli-0.2.0b1 → kop_cli-0.2.0b2}/src/kop/widgets/Panel.py

@@ -2,7 +2,8 @@ from textual.message import Message
 from textual.events import Mount
 from textual.reactive import Reactive
 from textual.app import ComposeResult
-from textual.widgets import Static, Input, Label, Select
+from textual.css.query import NoMatches
+from textual.widgets import Static, Input, Label, Select, ListView
 from textual.containers import Grid, Horizontal
 from textual.timer import Timer
 from textual.binding import Binding
@@ -66,6 +67,7 @@ class ResourcePanel(Static):
     debounce_time: float = 0.3
 
     BINDINGS = [
+        Binding(key="tab", action="focus_table", show=False),
         Binding(key="escape", action="clear", show=False),
     ]
 
@@ -128,6 +130,30 @@ class ResourcePanel(Static):
     def _on_mount(self, event: Mount) -> None:
         self.post_message(self.RequireNamespace().set_sender(self))
 
+    def check_action(self, action: str, parameters: tuple[object, ...]) -> Optional[bool]:
+        if action != "focus_table":
+            return True
+        focused = self.app.focused
+        if not isinstance(focused, (Input, Select)):
+            return False
+
+        parent = focused.parent
+        while parent is not None:
+            if parent is self:
+                break
+            parent = parent.parent
+        else:
+            return False
+
+        try:
+            self.screen.query_one("#list_view", ListView)
+        except NoMatches:
+            return False
+        return True
+
+    def action_focus_table(self) -> None:
+        self.screen.query_one("#list_view", ListView).focus()
+
     def action_clear(self) -> None:
         """
         clear search input
@@ -147,4 +173,4 @@ class ResourcePanel(Static):
         def __init__(self, query: str) -> None:
             super().__init__()
             self.query = query
-        
+        

{kop_cli-0.2.0b1 → kop_cli-0.2.0b2}/tests/test_resource_view.py

@@ -6,8 +6,11 @@ from unittest.mock import MagicMock
 
 from textual.app import App
 from textual.screen import Screen
+from textual.widgets import ListView
 
+from kop.models import ColumnModel
 from kop.registry import ResourceRegistry
+from kop.renderers.table import TableRenderer
 from kop.views.ResourceView import ResourceView
 from kop.widgets.Panel import ResourcePanel
 from kop.controllers.handler import BaseActionHandlerMixin
@@ -36,6 +39,46 @@ class _FakeActiveTimer:
         self.reset_called = True
 
 
+class _Row(dict):
+    def __getattr__(self, item):
+        try:
+            return self[item]
+        except KeyError as exc:
+            raise AttributeError(item) from exc
+
+
+def test_resource_panel_tab_focuses_table_list_view() -> None:
+    app = ResourceHarnessApp()
+
+    async def _run() -> None:
+        async with app.run_test(size=(120, 40)) as pilot:
+            await pilot.pause()
+            view = app.view
+            assert view is not None
+
+            table = TableRenderer(
+                columns=[ColumnModel(title="Name", width=1, field="name")],
+                data=[_Row(name="pod-a")],
+                raw_data=[SimpleNamespace(metadata=SimpleNamespace(name="pod-a"), name="pod-a")],
+            )
+            await view.query_one("#resource_container").mount(table, after=view.panel)
+            await pilot.pause()
+
+            for selector in ("#namespace_select", "#search_input"):
+                widget = view.query_one(selector)
+                widget.focus()
+                await pilot.pause()
+
+                await pilot.press("tab")
+                await pilot.pause()
+
+                focused = app.focused
+                assert isinstance(focused, ListView)
+                assert focused.id == "list_view"
+
+    asyncio.run(_run())
+
+
 def test_fetch_resource_returns_none_when_factory_missing(monkeypatch) -> None:
     app = ResourceHarnessApp()
     monkeypatch.setattr(ResourceRegistry, "get_factory", lambda _resource_type: None)
@@ -45,10 +88,11 @@ def test_fetch_resource_returns_none_when_factory_missing(monkeypatch) -> None:
             view = app.view
             assert view is not None
 
-            factory, data, cleaned = view._fetch_resource("pods", None, None)
+            factory, data, cleaned, resource_count = view._fetch_resource("pods", None, None)
             assert factory is None
             assert data is None
             assert cleaned == []
+            assert resource_count == 0
 
     asyncio.run(_run())
 
@@ -86,10 +130,62 @@ def test_fetch_resource_filters_and_sorts(monkeypatch) -> None:
             view = app.view
             assert view is not None
 
-            factory, data, cleaned = view._fetch_resource("pods", None, "a")
+            factory, data, cleaned, resource_count = view._fetch_resource("pods", None, "a")
             assert isinstance(factory, FakeFactory)
-            assert [item.name for item in data.items] == ["a"]
+            assert [item.name for item in data.items] == ["b", "a"]
             assert [item.name for item in cleaned] == ["a"]
+            assert resource_count == 1
+
+    asyncio.run(_run())
+
+
+def test_apply_resource_recomputes_display_when_keyword_changes() -> None:
+    app = ResourceHarnessApp()
+
+    class FakeFactory:
+        resource_type = "pods"
+
+        def filter(self, raw, keyword):
+            return SimpleNamespace(
+                items=[item for item in raw.items if keyword in item.name],
+                metadata=raw.metadata,
+            )
+
+        def clean(self, raw):
+            return [SimpleNamespace(name=item.name) for item in raw.items]
+
+    async def _run() -> None:
+        async with app.run_test(size=(120, 40)):
+            view = app.view
+            assert view is not None
+            view._resource_request_id = 1
+            view.keyword = ""
+            view._table_resource_type = "pods"
+            view.table = SimpleNamespace(raw_data=[], data=[])
+            view.panel = SimpleNamespace(resource_count=0)
+
+            data = SimpleNamespace(
+                items=[SimpleNamespace(name="a"), SimpleNamespace(name="b")],
+                metadata=SimpleNamespace(_continue=None),
+            )
+
+            view._set_loading = lambda _is_loading: None
+            view.refresh_bindings = lambda: None
+            view._apply_resource(
+                1,
+                "pods",
+                None,
+                0,
+                FakeFactory(),
+                data,
+                "a",
+                [SimpleNamespace(name="a")],
+                1,
+            )
+
+            assert view.data is data
+            assert [item.name for item in view.table.data] == ["a", "b"]
+            assert view.panel.resource_count == 2
 
     asyncio.run(_run())
 
@@ -128,7 +224,7 @@ def test_fetch_resource_uses_dynamic_page_size_from_screen_height(monkeypatch) -
         async with app.run_test(size=(120, 40)):
             view = app.view
             assert view is not None
-            _factory, _data, _cleaned = view._fetch_resource("pods", None, None)
+            _factory, _data, _cleaned, _resource_count = view._fetch_resource("pods", None, None)
 
     asyncio.run(_run())
 
@@ -442,19 +538,22 @@ def test_mock_pods_over_200_items_with_pagination_tokens(monkeypatch) -> None:
             assert view is not None
             monkeypatch.setattr(view, "_get_page_size", lambda: 100)
 
-            _, page1, cleaned1 = view._fetch_resource("pods", None, None)
+            _, page1, cleaned1, count1 = view._fetch_resource("pods", None, None)
             assert len(page1.items) == 100
             assert len(cleaned1) == 100
+            assert count1 == 100
             assert page1.metadata._continue == "100"
 
-            _, page2, cleaned2 = view._fetch_resource("pods", None, None, continue_token=page1.metadata._continue)
+            _, page2, cleaned2, count2 = view._fetch_resource("pods", None, None, continue_token=page1.metadata._continue)
             assert len(page2.items) == 100
             assert len(cleaned2) == 100
+            assert count2 == 100
             assert page2.metadata._continue == "200"
 
-            _, page3, cleaned3 = view._fetch_resource("pods", None, None, continue_token=page2.metadata._continue)
+            _, page3, cleaned3, count3 = view._fetch_resource("pods", None, None, continue_token=page2.metadata._continue)
             assert len(page3.items) == 50
             assert len(cleaned3) == 50
+            assert count3 == 50
             assert page3.metadata._continue is None
 
     asyncio.run(_run())
@@ -469,6 +568,7 @@ def test_mock_pod_pagination_next_and_prev_from_cached_pages() -> None:
             SimpleNamespace(items=rows, metadata=SimpleNamespace(_continue=next_token)),
             rows,
             next_token,
+            len(rows),
         )
 
     async def _run() -> None:
@@ -488,6 +588,10 @@ def test_mock_pod_pagination_next_and_prev_from_cached_pages() -> None:
             view.data = view.resource_pages[key][0][0]
             view.table = SimpleNamespace(raw_data=[], data=[])
             view.panel = SimpleNamespace(resource_count=0)
+            view.FACTORY_CACHE = SimpleNamespace(
+                filter=lambda data, _keyword: data,
+                clean=lambda data: data.items,
+            )
 
             view.action_next_page()
             assert view.page_index == 1
@@ -516,6 +620,7 @@ def test_pagination_bindings_visibility_changes_by_page() -> None:
             SimpleNamespace(items=rows, metadata=SimpleNamespace(_continue=next_token)),
             rows,
             next_token,
+            len(rows),
         )
 
     async def _run() -> None:

kop_cli-0.2.0b1/src/kop/__init__.py

@@ -1,2 +0,0 @@
-__version__ = "0.2.0b1"
-__git_commit__ = ""