fix test

Author: dolaameng

src/kaggle/api/kaggle_api.py

@@ -338,7 +338,7 @@ def kernel_push(self, kernel_push_request):  # noqa: E501
         """
         with tempfile.TemporaryDirectory() as tmpdir:
             meta_file = os.path.join(tmpdir, "kernel-metadata.json")
-            fd, code_file = tempfile.mkstemp("code", "py", tmpdir, text=True)
+            (fd, code_file) = tempfile.mkstemp("code", "py", tmpdir, text=True)
             fd.write(json.dumps(kernel_push_request.code))
             os.close(fd)
             with open(meta_file, "w") as f:

src/kaggle/api/kaggle_api_extended.py

@@ -721,7 +721,7 @@ def _authenticate_with_legacy_apikey(self) -> bool:
         return True
 
     def _authenticate_with_access_token(self):
-        access_token, source = get_access_token_from_env()
+        (access_token, source) = get_access_token_from_env()
         if not access_token:
             return False
 
@@ -1901,7 +1901,7 @@ def dataset_metadata_update(self, dataset, path):
             dataset: The dataset to update.
             path: The path to the metadata file.
         """
-        owner_slug, dataset_slug, effective_path = self.dataset_metadata_prep(dataset, path)
+        (owner_slug, dataset_slug, effective_path) = self.dataset_metadata_prep(dataset, path)
         meta_file = self.get_dataset_metadata_file(effective_path)
         with open(meta_file, "r") as f:
             metadata = json.load(f)
@@ -1954,7 +1954,7 @@ def dataset_metadata(self, dataset, path):
         Returns:
             The path to the downloaded metadata file.
         """
-        owner_slug, dataset_slug, effective_path = self.dataset_metadata_prep(dataset, path)
+        (owner_slug, dataset_slug, effective_path) = self.dataset_metadata_prep(dataset, path)
 
         if not os.path.exists(effective_path):
             os.makedirs(effective_path)
@@ -3462,7 +3462,7 @@ def kernels_output_cli(self, kernel, kernel_opt=None, path=None, force=False, qu
             file_pattern: Regex pattern to match against filenames. Only files matching the pattern will be downloaded.
         """
         kernel = kernel or kernel_opt
-        _, token = self.kernels_output(kernel, path, file_pattern, force, quiet)
+        (_, token) = self.kernels_output(kernel, path, file_pattern, force, quiet)
         if token:
             print(f"Next page token: {token}")
 
@@ -3508,9 +3508,18 @@ def kernels_status_cli(self, kernel, kernel_opt=None):
         else:
             print('%s has status "%s"' % (kernel, status))
 
+    def _resolve_kernel_slug(self, kernel):
+        """Parses a kernel string into (owner_slug, kernel_slug)."""
+        if "/" in kernel:
+            self.validate_kernel_string(kernel)
+            owner_slug, kernel_slug = kernel.split("/")
+        else:
+            owner_slug = self.get_config_value(self.CONFIG_NAME_USER)
+            kernel_slug = kernel
+        return owner_slug, kernel_slug
+
     def benchmarks_pull(self, kernel: str, path: str = None, quiet: bool = False):
         """Pulls a benchmark notebook and converts it to a .py script."""
-        import os
 
         try:
             import jupytext
@@ -3557,8 +3566,6 @@ def benchmarks_publish_and_run(
         self, kernel: str = None, path: str = None, file_name: str = None, quiet: bool = False
     ):
         """Converts a local .py benchmark to .ipynb and pushes it to Kaggle."""
-        import os
-        import json
 
         try:
             import jupytext
@@ -3594,12 +3601,7 @@ def benchmarks_publish_and_run(
             if not kernel:
                 raise ValueError("A kernel slug must be specified to create a new metadata file.")
 
-            if "/" in kernel:
-                self.validate_kernel_string(kernel)
-                owner_slug, kernel_slug = kernel.split("/")
-            else:
-                owner_slug = self.get_config_value(self.CONFIG_NAME_USER)
-                kernel_slug = kernel
+            owner_slug, kernel_slug = self._resolve_kernel_slug(kernel)
 
             title = kernel_slug.replace("-", " ").title()
             metadata = {
@@ -3627,12 +3629,7 @@ def benchmarks_publish_and_run(
                 metadata = json.load(f)
 
             if kernel:
-                if "/" in kernel:
-                    self.validate_kernel_string(kernel)
-                    owner_slug, kernel_slug = kernel.split("/")
-                else:
-                    owner_slug = self.get_config_value(self.CONFIG_NAME_USER)
-                    kernel_slug = kernel
+                owner_slug, kernel_slug = self._resolve_kernel_slug(kernel)
 
                 new_id = f"{owner_slug}/{kernel_slug}"
                 if metadata.get("id") != new_id:
@@ -3666,9 +3663,6 @@ def benchmarks_publish_and_run_cli(self, kernel=None, kernel_opt=None, path=None
 
     def benchmarks_get_results(self, kernel: str = None, path: str = None, poll_interval: int = 60, timeout: int = None):
         """Polls the status of a benchmark until complete, then downloads the output."""
-        import os
-        import time
-        import json
 
         if kernel is None:
             check_path = path or os.getcwd()
@@ -3699,7 +3693,7 @@ def benchmarks_get_results(self, kernel: str = None, path: str = None, poll_inte
                 print(f"Benchmark {kernel} failed!{error_txt}")
                 print(f"Attempting to download partial logs for debugging...")
                 try:
-                    self.kernels_output(kernel, path=path, force=True, quiet=False)
+                    self.kernels_output(kernel, path=path, file_pattern=None, force=True, quiet=False)
                 except Exception as log_err:
                     print(f"Could not retrieve backend logs: {log_err}")
                 raise ValueError(f"Benchmark execution terminated with an error state.")
@@ -3712,7 +3706,7 @@ def benchmarks_get_results(self, kernel: str = None, path: str = None, poll_inte
 
         # Now download output
         print(f"Downloading results for {kernel}...")
-        return self.kernels_output(kernel=kernel, path=path, force=True, quiet=False)
+        return self.kernels_output(kernel=kernel, path=path, file_pattern=None, force=True, quiet=False)
 
     def benchmarks_get_results_cli(self, kernel, kernel_opt=None, path=None, poll_interval=60, timeout=None):
         kernel = kernel or kernel_opt
@@ -4798,7 +4792,7 @@ def files_upload_cli(self, local_paths, inbox_path, no_resume, no_compress):
         files_to_create = []
         with ResumableUploadContext(no_resume) as upload_context:
             for local_path in local_paths:
-                upload_file, file_name = self.file_upload_cli(local_path, inbox_path, no_compress, upload_context)
+                (upload_file, file_name) = self.file_upload_cli(local_path, inbox_path, no_compress, upload_context)
                 if upload_file is None:
                     continue
 

src/kaggle/cli.py

@@ -1446,7 +1446,9 @@ class Help(object):
     command_model_instances_update = "Update a model variation"
 
     # Model Instance Versions params
-    param_model_instance_version = "Model variation version URL suffix in format <owner>/<model-name>/<framework>/<variation-slug>/<version-number>"
+    param_model_instance_version = (
+        "Model variation version URL suffix in format <owner>/<model-name>/<framework>/<variation-slug>/<version-number>"
+    )
 
     # Model Instance Versions params
     command_model_instance_versions_new = "Create a new model variation version"

tests/test_benchmarks.py

@@ -22,7 +22,9 @@ def test_benchmarks_pull(self, mock_write, mock_read):
             with open(dummy_ipynb, "w") as f:
                 f.write("{}")
 
-            result_dir = self.api.benchmarks_pull("testuser/my-benchmark", path=tmpdir, quiet=True)
+            result_dir = self.api.benchmarks_pull(
+                "testuser/my-benchmark", path=tmpdir, quiet=True
+            )
             self.assertEqual(result_dir, tmpdir)
 
             # 1. notebooks should be renamed to benchmark.ipynb
@@ -33,7 +35,9 @@ def test_benchmarks_pull(self, mock_write, mock_read):
             # 2. jupytext read and write should be called
             mock_read.assert_called_once_with(benchmark_ipynb)
             mock_write.assert_called_once()
-            self.assertEqual(mock_write.call_args[0][1], os.path.join(tmpdir, "benchmark.py"))
+            self.assertEqual(
+                mock_write.call_args[0][1], os.path.join(tmpdir, "benchmark.py")
+            )
             self.assertEqual(mock_write.call_args[1]["fmt"], "py:percent")
             self.api.kernels_pull.assert_called_once_with(
                 "testuser/my-benchmark", path=tmpdir, metadata=True, quiet=True
@@ -51,15 +55,20 @@ def test_benchmarks_publish_and_run(self, mock_write, mock_read):
             self.api.kernels_push = MagicMock(return_value="push_success")
 
             result = self.api.benchmarks_publish_and_run(
-                kernel="testuser/new-benchmark", path=tmpdir, file_name="benchmark.py", quiet=True
+                kernel="testuser/new-benchmark",
+                path=tmpdir,
+                file_name="benchmark.py",
+                quiet=True,
             )
 
             self.assertEqual(result, "push_success")
 
             # verify jupytext was used to read .py and write .ipynb
             mock_read.assert_called_once_with(py_file, fmt="py:percent")
             mock_write.assert_called_once()
-            self.assertEqual(mock_write.call_args[0][1], os.path.join(tmpdir, "benchmark.ipynb"))
+            self.assertEqual(
+                mock_write.call_args[0][1], os.path.join(tmpdir, "benchmark.ipynb")
+            )
 
             # verify metadata was created correctly
             metadata_file = os.path.join(tmpdir, "kernel-metadata.json")
@@ -85,7 +94,14 @@ def test_benchmarks_publish_and_run_existing_metadata(self, mock_write, mock_rea
             # Create existing metadata
             metadata_file = os.path.join(tmpdir, "kernel-metadata.json")
             with open(metadata_file, "w") as f:
-                json.dump({"id": "otheruser/existing-benchmark", "code_file": "old.ipynb", "keywords": ["tag1"]}, f)
+                json.dump(
+                    {
+                        "id": "otheruser/existing-benchmark",
+                        "code_file": "old.ipynb",
+                        "keywords": ["tag1"],
+                    },
+                    f,
+                )
 
             self.api.kernels_push = MagicMock(return_value="push_success")
 
@@ -118,7 +134,9 @@ def test_benchmarks_publish_and_run_explicit_kernel(self, mock_write, mock_read)
             self.api.kernels_push = MagicMock(return_value="push_success")
 
             # Act with explicit kernel override
-            self.api.benchmarks_publish_and_run(kernel="newuser/new-benchmark", path=tmpdir, quiet=True)
+            self.api.benchmarks_publish_and_run(
+                kernel="newuser/new-benchmark", path=tmpdir, quiet=True
+            )
 
             # Assert
             self.api.kernels_push.assert_called_once_with(tmpdir)
@@ -130,7 +148,6 @@ def test_benchmarks_publish_and_run_explicit_kernel(self, mock_write, mock_read)
             self.assertNotIn("id_no", metadata)
             self.assertIn("personal-benchmark", metadata["keywords"])
 
-
     @patch("time.sleep")
     def test_benchmarks_get_results(self, mock_sleep):
         # mock status to return 'running' once, then 'complete'
@@ -139,16 +156,24 @@ def __init__(self, status):
                 self.status = status
                 self.failure_message = ""
 
-        self.api.kernels_status = MagicMock(side_effect=[MockStatus("running"), MockStatus("complete")])
+        self.api.kernels_status = MagicMock(
+            side_effect=[MockStatus("running"), MockStatus("complete")]
+        )
         self.api.kernels_output = MagicMock(return_value="output_data")
 
-        result = self.api.benchmarks_get_results("testuser/my-bench", path="some_path", poll_interval=10)
+        result = self.api.benchmarks_get_results(
+            "testuser/my-bench", path="some_path", poll_interval=10
+        )
 
         self.assertEqual(result, "output_data")
         self.assertEqual(self.api.kernels_status.call_count, 2)
         mock_sleep.assert_called_once_with(10)
         self.api.kernels_output.assert_called_once_with(
-            kernel="testuser/my-bench", path="some_path", force=True, quiet=False
+            kernel="testuser/my-bench",
+            path="some_path",
+            file_pattern=None,
+            force=True,
+            quiet=False,
         )
 
     def test_benchmarks_get_results_error(self):
@@ -158,6 +183,7 @@ def __init__(self):
                 self.failure_message = "syntax error"
 
         self.api.kernels_status = MagicMock(return_value=MockStatusError())
+        self.api.kernels_output = MagicMock()
 
         with self.assertRaisesRegex(ValueError, "error state"):
             self.api.benchmarks_get_results("testuser/my-bench")
@@ -168,22 +194,25 @@ class MockStatus:
             def __init__(self, status):
                 self.status = status
                 self.failure_message = ""
-                
+
         self.api.kernels_status = MagicMock(return_value=MockStatus("complete"))
         self.api.kernels_output = MagicMock(return_value="output_data")
 
         with tempfile.TemporaryDirectory() as tmpdir:
             # Create existing metadata
             metadata_file = os.path.join(tmpdir, "kernel-metadata.json")
             with open(metadata_file, "w") as f:
-                import json
                 json.dump({"id": "implicit/my-bench"}, f)
 
             result = self.api.benchmarks_get_results(kernel=None, path=tmpdir)
 
             self.assertEqual(result, "output_data")
             self.api.kernels_output.assert_called_once_with(
-                kernel="implicit/my-bench", path=tmpdir, force=True, quiet=False
+                kernel="implicit/my-bench",
+                path=tmpdir,
+                file_pattern=None,
+                force=True,
+                quiet=False,
             )