jupyterlab-kernel-terminal-workspace-culler-extension 1.0.21__py3-none-any.whl

jupyterlab_kernel_terminal_workspace_culler_extension/tests/test_culler.py

@@ -0,0 +1,269 @@
+"""Unit tests for the resource culler."""
+
+from datetime import datetime, timedelta, timezone
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from jupyterlab_kernel_terminal_workspace_culler_extension.culler import ResourceCuller
+
+
+@pytest.fixture
+def mock_server_app():
+    """Create a mock server app with kernel, terminal, and session managers."""
+    app = MagicMock()
+
+    # Mock kernel manager
+    app.kernel_manager = MagicMock()
+    app.kernel_manager.list_kernel_ids.return_value = []
+    app.kernel_manager.get_kernel.return_value = None
+    app.kernel_manager.shutdown_kernel = AsyncMock()
+
+    # Mock terminal manager
+    app.terminal_manager = MagicMock()
+    app.terminal_manager.list.return_value = []
+    app.terminal_manager.terminate = AsyncMock()
+
+    # Mock session manager
+    app.session_manager = MagicMock()
+    app.session_manager.list_sessions = AsyncMock(return_value=[])
+    app.session_manager.delete_session = AsyncMock()
+
+    return app
+
+
+@pytest.fixture
+def culler(mock_server_app):
+    """Create a ResourceCuller instance with mocked server app."""
+    return ResourceCuller(mock_server_app)
+
+
+class TestDefaultSettings:
+    """Test default settings initialization."""
+
+    def test_default_kernel_settings(self, culler):
+        """Verify default kernel culling settings."""
+        settings = culler.get_settings()
+        assert settings["kernelCullEnabled"] is True
+        assert settings["kernelCullIdleTimeout"] == 60  # 1 hour
+
+    def test_default_terminal_settings(self, culler):
+        """Verify default terminal culling settings."""
+        settings = culler.get_settings()
+        assert settings["terminalCullEnabled"] is True
+        assert settings["terminalCullIdleTimeout"] == 60  # 1 hour
+
+    def test_default_session_settings(self, culler):
+        """Verify default session culling settings."""
+        settings = culler.get_settings()
+        assert settings["sessionCullEnabled"] is False
+        assert settings["sessionCullIdleTimeout"] == 10080  # 7 days
+
+    def test_default_check_interval(self, culler):
+        """Verify default check interval."""
+        settings = culler.get_settings()
+        assert settings["cullCheckInterval"] == 5
+
+
+class TestUpdateSettings:
+    """Test settings update functionality."""
+
+    def test_update_kernel_settings(self, culler):
+        """Test updating kernel culling settings."""
+        culler.update_settings({
+            "kernelCullEnabled": False,
+            "kernelCullIdleTimeout": 120
+        })
+        settings = culler.get_settings()
+        assert settings["kernelCullEnabled"] is False
+        assert settings["kernelCullIdleTimeout"] == 120
+
+    def test_update_terminal_settings(self, culler):
+        """Test updating terminal culling settings."""
+        culler.update_settings({
+            "terminalCullEnabled": False,
+            "terminalCullIdleTimeout": 45
+        })
+        settings = culler.get_settings()
+        assert settings["terminalCullEnabled"] is False
+        assert settings["terminalCullIdleTimeout"] == 45
+
+    def test_update_session_settings(self, culler):
+        """Test updating session culling settings."""
+        culler.update_settings({
+            "sessionCullEnabled": True,
+            "sessionCullIdleTimeout": 60
+        })
+        settings = culler.get_settings()
+        assert settings["sessionCullEnabled"] is True
+        assert settings["sessionCullIdleTimeout"] == 60
+
+    def test_partial_update(self, culler):
+        """Test that partial updates don't affect other settings."""
+        culler.update_settings({"kernelCullEnabled": False})
+        settings = culler.get_settings()
+        assert settings["kernelCullEnabled"] is False
+        # Other settings should remain at defaults
+        assert settings["terminalCullEnabled"] is True
+        assert settings["sessionCullEnabled"] is False
+
+
+class TestCullIdleKernel:
+    """Test kernel culling functionality."""
+
+    @pytest.mark.asyncio
+    async def test_cull_idle_kernel(self, culler, mock_server_app):
+        """Test that idle kernel exceeding timeout gets culled."""
+        kernel_id = "test-kernel-123"
+        idle_time = datetime.now(timezone.utc) - timedelta(minutes=120)
+
+        mock_kernel = MagicMock()
+        mock_kernel.execution_state = "idle"
+        mock_kernel.last_activity = idle_time
+
+        mock_server_app.kernel_manager.list_kernel_ids.return_value = [kernel_id]
+        mock_server_app.kernel_manager.get_kernel.return_value = mock_kernel
+
+        culled = await culler._cull_kernels()
+
+        assert kernel_id in culled
+        mock_server_app.kernel_manager.shutdown_kernel.assert_called_once_with(kernel_id)
+
+    @pytest.mark.asyncio
+    async def test_skip_busy_kernel(self, culler, mock_server_app):
+        """Test that busy kernels are not culled."""
+        kernel_id = "busy-kernel-123"
+        idle_time = datetime.now(timezone.utc) - timedelta(minutes=120)
+
+        mock_kernel = MagicMock()
+        mock_kernel.execution_state = "busy"
+        mock_kernel.last_activity = idle_time
+
+        mock_server_app.kernel_manager.list_kernel_ids.return_value = [kernel_id]
+        mock_server_app.kernel_manager.get_kernel.return_value = mock_kernel
+
+        culled = await culler._cull_kernels()
+
+        assert kernel_id not in culled
+        mock_server_app.kernel_manager.shutdown_kernel.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_skip_active_kernel(self, culler, mock_server_app):
+        """Test that recently active kernels are not culled."""
+        kernel_id = "active-kernel-123"
+        # Last activity 5 minutes ago - below 60 minute threshold
+        recent_time = datetime.now(timezone.utc) - timedelta(minutes=5)
+
+        mock_kernel = MagicMock()
+        mock_kernel.execution_state = "idle"
+        mock_kernel.last_activity = recent_time
+
+        mock_server_app.kernel_manager.list_kernel_ids.return_value = [kernel_id]
+        mock_server_app.kernel_manager.get_kernel.return_value = mock_kernel
+
+        culled = await culler._cull_kernels()
+
+        assert kernel_id not in culled
+        mock_server_app.kernel_manager.shutdown_kernel.assert_not_called()
+
+
+class TestCullIdleTerminal:
+    """Test terminal culling functionality."""
+
+    @pytest.mark.asyncio
+    async def test_cull_idle_terminal(self, culler, mock_server_app):
+        """Test that idle terminal exceeding timeout gets culled."""
+        terminal_name = "terminal-1"
+        idle_time = datetime.now(timezone.utc) - timedelta(minutes=60)
+
+        mock_server_app.terminal_manager.list.return_value = [
+            {"name": terminal_name, "last_activity": idle_time}
+        ]
+
+        culled = await culler._cull_terminals()
+
+        assert terminal_name in culled
+        mock_server_app.terminal_manager.terminate.assert_called_once_with(terminal_name)
+
+    @pytest.mark.asyncio
+    async def test_skip_active_terminal(self, culler, mock_server_app):
+        """Test that recently active terminals are not culled."""
+        terminal_name = "terminal-1"
+        # Last activity 5 minutes ago - below 30 minute threshold
+        recent_time = datetime.now(timezone.utc) - timedelta(minutes=5)
+
+        mock_server_app.terminal_manager.list.return_value = [
+            {"name": terminal_name, "last_activity": recent_time}
+        ]
+
+        culled = await culler._cull_terminals()
+
+        assert terminal_name not in culled
+        mock_server_app.terminal_manager.terminate.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_cull_terminal_with_iso_string(self, culler, mock_server_app):
+        """Test culling terminal with ISO string timestamp."""
+        terminal_name = "terminal-1"
+        idle_time = (datetime.now(timezone.utc) - timedelta(minutes=60)).isoformat()
+
+        mock_server_app.terminal_manager.list.return_value = [
+            {"name": terminal_name, "last_activity": idle_time}
+        ]
+
+        culled = await culler._cull_terminals()
+
+        assert terminal_name in culled
+
+
+class TestCullResult:
+    """Test cull result retrieval."""
+
+    def test_get_last_cull_result_empty(self, culler):
+        """Test that initial cull result is empty."""
+        result = culler.get_last_cull_result()
+        assert result["kernels_culled"] == []
+        assert result["terminals_culled"] == []
+        assert result["sessions_culled"] == []
+
+    def test_result_consumed_flag(self, culler):
+        """Test that result is marked as consumed after retrieval."""
+        # First call returns empty (result_consumed is True initially)
+        result1 = culler.get_last_cull_result()
+
+        # Simulate a culling that produced results
+        culler._last_cull_result = {
+            "kernels_culled": ["kernel-1"],
+            "terminals_culled": [],
+            "sessions_culled": [],
+        }
+        culler._result_consumed = False
+
+        # First retrieval should return the result
+        result2 = culler.get_last_cull_result()
+        assert result2["kernels_culled"] == ["kernel-1"]
+
+        # Second retrieval should return empty (consumed)
+        result3 = culler.get_last_cull_result()
+        assert result3["kernels_culled"] == []
+
+
+class TestStatus:
+    """Test status retrieval."""
+
+    def test_status_not_running(self, culler):
+        """Test status when culler is not running."""
+        status = culler.get_status()
+        assert status["running"] is False
+
+    def test_status_running(self, culler):
+        """Test status when culler is running."""
+        with patch.object(culler, "_periodic_callback", MagicMock()):
+            status = culler.get_status()
+            assert status["running"] is True
+
+    def test_status_includes_settings(self, culler):
+        """Test that status includes current settings."""
+        status = culler.get_status()
+        assert "settings" in status
+        assert "kernelCullEnabled" in status["settings"]

jupyterlab_kernel_terminal_workspace_culler_extension/tests/test_routes.py

@@ -0,0 +1,17 @@
+import json
+
+
+async def test_hello(jp_fetch):
+    # When
+    response = await jp_fetch("jupyterlab-kernel-terminal-workspace-culler-extension", "hello")
+
+    # Then
+    assert response.code == 200
+    payload = json.loads(response.body)
+    assert payload == {
+            "data": (
+                "Hello, world!"
+                " This is the '/jupyterlab-kernel-terminal-workspace-culler-extension/hello' endpoint."
+                " Try visiting me in your browser!"
+            ),
+        }

jupyterlab_kernel_terminal_workspace_culler_extension-1.0.21.data/data/etc/jupyter/jupyter_server_config.d/jupyterlab_kernel_terminal_workspace_culler_extension.json

@@ -0,0 +1,7 @@
+{
+  "ServerApp": {
+    "jpserver_extensions": {
+      "jupyterlab_kernel_terminal_workspace_culler_extension": true
+    }
+  }
+}

jupyterlab_kernel_terminal_workspace_culler_extension-1.0.21.data/data/share/jupyter/labextensions/jupyterlab_kernel_terminal_workspace_culler_extension/install.json

@@ -0,0 +1,5 @@
+{
+  "packageManager": "python",
+  "packageName": "jupyterlab_kernel_terminal_workspace_culler_extension",
+  "uninstallInstructions": "Use your Python package manager (pip, conda, etc.) to uninstall the package jupyterlab_kernel_terminal_workspace_culler_extension"
+}

jupyterlab_kernel_terminal_workspace_culler_extension-1.0.21.data/data/share/jupyter/labextensions/jupyterlab_kernel_terminal_workspace_culler_extension/package.json

@@ -0,0 +1,219 @@
+{
+  "name": "jupyterlab_kernel_terminal_workspace_culler_extension",
+  "version": "1.0.21",
+  "description": "Jupyterlab extension to kill unused kernels, terminals and workspaces. User can configure the idle time (minutes) after which the resource will be released automatically. This helps with the locked memory, insane number of terminals opened etc.",
+  "keywords": [
+    "jupyter",
+    "jupyterlab",
+    "jupyterlab-extension"
+  ],
+  "homepage": "https://github.com/stellarshenson/jupyterlab_kernel_terminal_workspace_culler_extension",
+  "bugs": {
+    "url": "https://github.com/stellarshenson/jupyterlab_kernel_terminal_workspace_culler_extension/issues"
+  },
+  "license": "BSD-3-Clause",
+  "author": {
+    "name": "Stellars Henson",
+    "email": "konrad.jelen@gmail.com"
+  },
+  "files": [
+    "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}",
+    "style/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}",
+    "src/**/*.{ts,tsx}",
+    "schema/*.json"
+  ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "style": "style/index.css",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/stellarshenson/jupyterlab_kernel_terminal_workspace_culler_extension.git"
+  },
+  "scripts": {
+    "build": "jlpm build:lib && jlpm build:labextension:dev",
+    "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension",
+    "build:labextension": "jupyter labextension build .",
+    "build:labextension:dev": "jupyter labextension build --development True .",
+    "build:lib": "tsc --sourceMap",
+    "build:lib:prod": "tsc",
+    "clean": "jlpm clean:lib",
+    "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
+    "clean:lintcache": "rimraf .eslintcache .stylelintcache",
+    "clean:labextension": "rimraf jupyterlab_kernel_terminal_workspace_culler_extension/labextension jupyterlab_kernel_terminal_workspace_culler_extension/_version.py",
+    "clean:all": "jlpm clean:lib && jlpm clean:labextension && jlpm clean:lintcache",
+    "eslint": "jlpm eslint:check --fix",
+    "eslint:check": "eslint . --cache --ext .ts,.tsx",
+    "install:extension": "jlpm build",
+    "lint": "jlpm stylelint && jlpm prettier && jlpm eslint",
+    "lint:check": "jlpm stylelint:check && jlpm prettier:check && jlpm eslint:check",
+    "prettier": "jlpm prettier:base --write --list-different",
+    "prettier:base": "prettier \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
+    "prettier:check": "jlpm prettier:base --check",
+    "stylelint": "jlpm stylelint:check --fix",
+    "stylelint:check": "stylelint --cache \"style/**/*.css\"",
+    "test": "jest --coverage",
+    "watch": "run-p watch:src watch:labextension",
+    "watch:src": "tsc -w --sourceMap",
+    "watch:labextension": "jupyter labextension watch ."
+  },
+  "dependencies": {
+    "@jupyterlab/application": "^4.0.0",
+    "@jupyterlab/coreutils": "^6.0.0",
+    "@jupyterlab/services": "^7.0.0",
+    "@jupyterlab/settingregistry": "^4.0.0",
+    "@jupyterlab/terminal": "^4.0.0"
+  },
+  "devDependencies": {
+    "@jupyterlab/builder": "^4.0.0",
+    "@jupyterlab/testutils": "^4.0.0",
+    "@types/jest": "^29.2.0",
+    "@types/json-schema": "^7.0.11",
+    "@types/react": "^18.0.26",
+    "@types/react-addons-linked-state-mixin": "^0.14.22",
+    "@typescript-eslint/eslint-plugin": "^6.1.0",
+    "@typescript-eslint/parser": "^6.1.0",
+    "css-loader": "^6.7.1",
+    "eslint": "^8.36.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^5.0.0",
+    "jest": "^29.2.0",
+    "mkdirp": "^1.0.3",
+    "npm-run-all2": "^7.0.1",
+    "prettier": "^3.0.0",
+    "rimraf": "^5.0.10",
+    "source-map-loader": "^1.0.2",
+    "style-loader": "^3.3.1",
+    "stylelint": "^15.10.1",
+    "stylelint-config-recommended": "^13.0.0",
+    "stylelint-config-standard": "^34.0.0",
+    "stylelint-csstree-validator": "^3.0.0",
+    "stylelint-prettier": "^4.0.0",
+    "typescript": "~5.5.4",
+    "yjs": "^13.5.0"
+  },
+  "resolutions": {
+    "lib0": "0.2.111"
+  },
+  "sideEffects": [
+    "style/*.css",
+    "style/index.js"
+  ],
+  "styleModule": "style/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "jupyterlab": {
+    "discovery": {
+      "server": {
+        "managers": [
+          "pip"
+        ],
+        "base": {
+          "name": "jupyterlab_kernel_terminal_workspace_culler_extension"
+        }
+      }
+    },
+    "extension": true,
+    "outputDir": "jupyterlab_kernel_terminal_workspace_culler_extension/labextension",
+    "schemaDir": "schema",
+    "_build": {
+      "load": "static/remoteEntry.61977aac2cfde9b88947.js",
+      "extension": "./extension",
+      "style": "./style"
+    }
+  },
+  "eslintIgnore": [
+    "node_modules",
+    "dist",
+    "coverage",
+    "**/*.d.ts",
+    "tests",
+    "**/__tests__",
+    "ui-tests"
+  ],
+  "eslintConfig": {
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/eslint-recommended",
+      "plugin:@typescript-eslint/recommended",
+      "plugin:prettier/recommended"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+      "project": "tsconfig.json",
+      "sourceType": "module"
+    },
+    "plugins": [
+      "@typescript-eslint"
+    ],
+    "rules": {
+      "@typescript-eslint/naming-convention": [
+        "error",
+        {
+          "selector": "interface",
+          "format": [
+            "PascalCase"
+          ],
+          "custom": {
+            "regex": "^I[A-Z]",
+            "match": true
+          }
+        }
+      ],
+      "@typescript-eslint/no-unused-vars": [
+        "warn",
+        {
+          "args": "none"
+        }
+      ],
+      "@typescript-eslint/no-explicit-any": "off",
+      "@typescript-eslint/no-namespace": "off",
+      "@typescript-eslint/no-use-before-define": "off",
+      "@typescript-eslint/quotes": [
+        "error",
+        "single",
+        {
+          "avoidEscape": true,
+          "allowTemplateLiterals": false
+        }
+      ],
+      "curly": [
+        "error",
+        "all"
+      ],
+      "eqeqeq": "error",
+      "prefer-arrow-callback": "error"
+    }
+  },
+  "prettier": {
+    "singleQuote": true,
+    "trailingComma": "none",
+    "arrowParens": "avoid",
+    "endOfLine": "auto",
+    "overrides": [
+      {
+        "files": "package.json",
+        "options": {
+          "tabWidth": 4
+        }
+      }
+    ]
+  },
+  "stylelint": {
+    "extends": [
+      "stylelint-config-recommended",
+      "stylelint-config-standard",
+      "stylelint-prettier/recommended"
+    ],
+    "plugins": [
+      "stylelint-csstree-validator"
+    ],
+    "rules": {
+      "csstree/validator": true,
+      "property-no-vendor-prefix": null,
+      "selector-class-pattern": "^([a-z][A-z\\d]*)(-[A-z\\d]+)*$",
+      "selector-no-vendor-prefix": null,
+      "value-no-vendor-prefix": null
+    }
+  }
+}