Make media_types keyword-only in the adapter and tighten the export guard

Two corrections to the previous commits.

`rfapi.workspace_search` took `media_types` as a positional-or-keyword
parameter, so the "keyword-only everywhere" claim was only true of the
higher-level SDK methods. Put it behind a bare `*`. The six pre-existing
parameters keep their positions, and a test now pins both the kind and the
positional order.

The CLI export guard tested `--media-types` for truthiness, so an explicit but
empty `--media-types ""` was falsy and fell through to the export route instead
of being rejected — verified by dispatch: the old guard got as far as resolving
the export dataset. Compare against `None` so any explicit value is caught, and
reject the blank value on the search path too.

`parse_media_types_option` also documented an empty string as meaning "use the
API default" while the code raised on it. The code is right — a blank value is
an explicit empty selection — so the docstring now says that.

Author: digaobarbosa

roboflow/adapters/rfapi.py

@@ -546,6 +546,7 @@ def workspace_search(
     page_size: int = 50,
     fields: Optional[List[str]] = None,
     continuation_token: Optional[str] = None,
+    *,
     media_types: Optional[List[str]] = None,
 ) -> dict:
     """Search across all media in a workspace using RoboQL syntax.

roboflow/cli/handlers/search.py

@@ -80,7 +80,9 @@ def _search(args):  # noqa: ANN001
         return
 
     if args.export:
-        if getattr(args, "media_types", None):
+        # `is not None` on purpose: an explicit but invalid value (e.g. --media-types "")
+        # must not silently fall through to the export route.
+        if getattr(args, "media_types", None) is not None:
             output_error(
                 args,
                 "--media-types is not supported with --export",

roboflow/util/search_utils.py

@@ -51,14 +51,16 @@ def parse_media_types_option(raw: Optional[str]) -> Optional[List[str]]:
     """Parse a comma-separated CLI ``--media-types`` value into a normalized list.
 
     Args:
-        raw: Raw option value, e.g. ``"video"`` or ``"image,video"``. ``None`` or an
-            empty string means "use the API default".
+        raw: Raw option value, e.g. ``"video"`` or ``"image,video"``. Only ``None``
+            (the option was not given) means "use the API default".
 
     Returns:
-        A normalized media type list, or ``None`` when nothing was requested.
+        A normalized media type list, or ``None`` when the option was not given.
 
     Raises:
-        ValueError: If the value contains anything other than valid media types.
+        ValueError: If the value is given but blank, or names anything other than a
+            valid media type. A blank value is an explicit empty selection, not a
+            request for the default.
     """
     if raw is None:
         return None

tests/cli/test_search_media_types.py

@@ -179,6 +179,44 @@ def test_export_rejects_media_types(self):
         error = json.loads(result.output)["error"]
         self.assertIn("--media-types is not supported with --export", error["message"])
 
+    @responses.activate
+    def test_export_rejects_an_explicitly_blank_media_types(self):
+        """A blank value is an explicit selection; it must not fall through to the export route."""
+        _stub_workspace_init()
+
+        result = runner.invoke(
+            app,
+            [
+                "--json",
+                "--api-key",
+                API_KEY,
+                "--workspace",
+                WORKSPACE,
+                "search",
+                "*",
+                "--export",
+                "--media-types",
+                "",
+            ],
+        )
+
+        self.assertEqual(result.exit_code, 1)
+        error = json.loads(result.output)["error"]
+        self.assertIn("--media-types is not supported with --export", error["message"])
+
+    @responses.activate
+    def test_blank_media_types_without_export_is_rejected(self):
+        _stub_workspace_init()
+
+        result = runner.invoke(
+            app,
+            ["--json", "--api-key", API_KEY, "--workspace", WORKSPACE, "search", "*", "--media-types", ""],
+        )
+
+        self.assertEqual(result.exit_code, 1)
+        self.assertEqual(_search_bodies(), [])
+        self.assertIn("at least one of", json.loads(result.output)["error"]["message"])
+
 
 class TestImageSearchMediaTypes(unittest.TestCase):
     """`roboflow image search` covers both the workspace and project-scoped paths."""

tests/test_search_media_types.py

@@ -242,6 +242,29 @@ def test_adapter_sends_media_types(self):
 
         self.assertEqual(self._sent()["mediaTypes"], ["video"])
 
+    def test_adapter_media_types_is_keyword_only(self):
+        """Positional callers must keep working, so media_types sits behind a bare `*`."""
+        import inspect
+
+        sig = inspect.signature(rfapi.workspace_search)
+        self.assertEqual(sig.parameters["media_types"].kind, inspect.Parameter.KEYWORD_ONLY)
+        # The pre-existing parameters stay positional-or-keyword, in their original order.
+        positional = [n for n, p in sig.parameters.items() if p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD]
+        self.assertEqual(
+            positional,
+            ["api_key", "workspace_url", "query", "page_size", "fields", "continuation_token"],
+        )
+
+    def test_sdk_search_media_types_is_keyword_only(self):
+        import inspect
+
+        from roboflow.core.project import Project
+        from roboflow.core.workspace import Workspace
+
+        for func in (Project.search, Project.search_all, Workspace.search, Workspace.search_all):
+            kind = inspect.signature(func).parameters["media_types"].kind
+            self.assertEqual(kind, inspect.Parameter.KEYWORD_ONLY, func.__qualname__)
+
     @responses.activate
     def test_adapter_without_selection_omits_media_types(self):
         responses.add(responses.POST, self.SEARCH_URL, json={"results": [], "total": 0}, status=200)