cvat-cli 2.70.0__tar.gz → 2.71.0__tar.gz

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cvat-cli
-Version: 2.70.0
+Version: 2.71.0
 Summary: Command-line client for CVAT
 Author-email: "CVAT.ai Corporation" <support@cvat.ai>
 License-Expression: MIT
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: cvat-sdk==2.70.0
+Requires-Dist: cvat-sdk==2.71.0
 Requires-Dist: attrs>=24.2.0
 Requires-Dist: Pillow>=10.3.0
 

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/pyproject.toml

@@ -16,7 +16,7 @@ classifiers = [
 ]
 requires-python = ">=3.10"
 dependencies = [
-    "cvat-sdk==2.70.0",
+    "cvat-sdk==2.71.0",
 
     "attrs>=24.2.0",
     "Pillow>=10.3.0",

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/src/cvat_cli/__main__.py

@@ -9,6 +9,7 @@ import sys
 
 import urllib3.exceptions
 from cvat_sdk import exceptions
+from cvat_sdk.core.exceptions import AuthStoreError
 
 from ._internal.commands_all import COMMANDS
 from ._internal.common import (
@@ -31,10 +32,21 @@ def main(args: list[str] = None):
 
     configure_logger(logger, parsed_args)
 
+    executor = popattr(parsed_args, "_executor")
+    needs_client = popattr(parsed_args, "_needs_client")
+
     try:
-        with build_client(parsed_args, logger=logger) as client:
-            popattr(parsed_args, "_executor")(client, **vars(parsed_args))
-    except (exceptions.ApiException, urllib3.exceptions.HTTPError, CriticalError) as e:
+        if needs_client:
+            with build_client(parsed_args, logger=logger) as client:
+                executor(client, **vars(parsed_args))
+        else:
+            executor(parsed_args)
+    except (
+        exceptions.ApiException,
+        urllib3.exceptions.HTTPError,
+        CriticalError,
+        AuthStoreError,
+    ) as e:
         logger.critical(e)
         return 1
 

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/src/cvat_cli/_internal/agent.py

@@ -36,6 +36,7 @@ from .agent_driver import (
     worker_current_function,
 )
 from .agent_driver_detection import AgentDetectionFunctionDriver
+from .agent_driver_interaction import AgentInteractionFunctionDriver
 from .agent_driver_tracking import AgentTrackingFunctionDriver, TrackingStateIdGenerator
 from .common import CriticalError, FunctionLoader
 
@@ -227,6 +228,9 @@ def get_function_driver_class(function_spec: object) -> type[AgentFunctionDriver
     if isinstance(function_spec, cvataa.DetectionFunctionSpec):
         return AgentDetectionFunctionDriver
 
+    if isinstance(function_spec, cvataa.InteractionFunctionSpec):
+        return AgentInteractionFunctionDriver
+
     if isinstance(function_spec, cvataa.TrackingFunctionSpec):
         return AgentTrackingFunctionDriver
 

cvat_cli-2.71.0/src/cvat_cli/_internal/agent_driver_interaction.py

@@ -0,0 +1,218 @@
+# Copyright (C) CVAT.ai Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from collections import OrderedDict
+from datetime import datetime, timedelta, timezone
+from typing import Any, cast
+
+import attrs
+import cvat_sdk.auto_annotation as cvataa
+import PIL.Image
+
+from .agent_driver import (
+    AgentFunctionDriver,
+    BadArError,
+    IncompatibleFunctionError,
+    worker_current_function,
+)
+
+_MAX_AGE_OF_PP_IMAGE = timedelta(minutes=10)
+
+
+class _InteractionFunctionContextImpl(cvataa.InteractionFunctionContext):
+    pass
+
+
+@attrs.frozen(kw_only=True)
+class _InteractionPromptsImpl(cvataa.InteractionPrompts):
+    pos_points: tuple[tuple[float, float], ...]
+    neg_points: tuple[tuple[float, float], ...]
+    bounding_box: tuple[tuple[float, float], tuple[float, float]] | None
+
+
+@attrs.define(kw_only=True)
+class _PpImageCacheEntry:
+    pp_image: object
+    last_accessed_at: datetime = attrs.field(factory=lambda: datetime.now(tz=timezone.utc))
+
+
+class _PpImageCache:
+    _MISSING = object()
+
+    def __init__(self):
+        self._contents = OrderedDict[object, _PpImageCacheEntry]()
+
+    def get(self, key: object) -> object:
+        if cache_entry := self._contents.get(key):
+            cache_entry.last_accessed_at = datetime.now(tz=timezone.utc)
+            self._contents.move_to_end(key)
+            return cache_entry.pp_image
+
+        return self._MISSING
+
+    def set(self, key: object, pp_image: object) -> None:
+        if key in self._contents:
+            self._contents.move_to_end(key)
+        else:
+            self.prune()
+
+        self._contents[key] = _PpImageCacheEntry(pp_image=pp_image)
+
+    def prune(self) -> None:
+        cutoff = datetime.now(tz=timezone.utc) - _MAX_AGE_OF_PP_IMAGE
+
+        while self._contents and next(iter(self._contents.values())).last_accessed_at < cutoff:
+            self._contents.popitem(last=False)
+
+
+_pp_image_cache: _PpImageCache
+
+
+def _worker_job_interact(
+    cache_key: object, image: PIL.Image.Image, prompts: cvataa.InteractionPrompts
+) -> list[cvataa.InteractionResultShape]:
+    current_function = cast(cvataa.InteractionFunction, worker_current_function())
+    context = _InteractionFunctionContextImpl()
+
+    if hasattr(current_function, "preprocess_image"):
+        pp_image = current_function.preprocess_image(context, image)
+    else:
+        pp_image = image
+
+    _pp_image_cache.set(cache_key, pp_image)
+
+    return current_function.detect(context, pp_image, prompts)
+
+
+def _worker_job_interact_from_cache(
+    cache_key: object, prompts: cvataa.InteractionPrompts
+) -> list[cvataa.InteractionResultShape] | None:
+    current_function = cast(cvataa.InteractionFunction, worker_current_function())
+
+    pp_image = _pp_image_cache.get(cache_key)
+    if pp_image is _PpImageCache._MISSING:
+        return None
+
+    context = _InteractionFunctionContextImpl()
+    return current_function.detect(context, pp_image, prompts)
+
+
+class AgentInteractionFunctionDriver(AgentFunctionDriver[cvataa.InteractionFunctionSpec]):
+    FUNCTION_KIND = "interactor"
+
+    @classmethod
+    def init_worker(cls, state_id_generator: object) -> None:
+        global _pp_image_cache
+        _pp_image_cache = _PpImageCache()
+
+    @classmethod
+    def get_remote_function_fields(cls, spec: cvataa.InteractionFunctionSpec) -> dict[str, Any]:
+        fields = {"min_pos_points": spec.min_pos_points}
+
+        if spec.min_neg_points is not None:
+            fields["min_neg_points"] = spec.min_neg_points
+
+        match spec.min_bounding_boxes:
+            case 0:
+                fields["startswith_box_optional"] = True
+            case 1:
+                fields["startswith_box"] = True
+            case None:
+                pass
+            case _:
+                assert False, f"Unexpected min_bounding_boxes value: {spec.min_bounding_boxes}"
+
+        return fields
+
+    def validate_function_compatibility(self, remote_function: dict) -> None:
+        remote_min_pos_points = remote_function["min_pos_points"]
+        if remote_min_pos_points < self._function_spec.min_pos_points:
+            raise IncompatibleFunctionError(
+                "the remote function allows prompts with "
+                f"{remote_min_pos_points} positive point(s), but the function object "
+                f"requires at least {self._function_spec.min_pos_points}"
+            )
+
+        remote_min_neg_points = remote_function["min_neg_points"]
+        if remote_min_neg_points >= 0:
+            if self._function_spec.min_neg_points is None:
+                raise IncompatibleFunctionError(
+                    "the remote function allows prompts with negative points, but the "
+                    "function object does not"
+                )
+
+            if remote_min_neg_points < self._function_spec.min_neg_points:
+                raise IncompatibleFunctionError(
+                    "the remote function allows prompts with "
+                    f"{remote_min_neg_points} negative point(s), but the function object "
+                    f"requires at least {self._function_spec.min_neg_points}"
+                )
+        else:
+            if self._function_spec.min_neg_points not in {None, 0}:
+                raise IncompatibleFunctionError(
+                    "the remote function does not allow prompts with negative points, "
+                    "but the function object requires at least "
+                    f"{self._function_spec.min_neg_points}"
+                )
+
+        if self._function_spec.min_bounding_boxes is None:
+            if remote_function["startswith_box"] or remote_function["startswith_box_optional"]:
+                raise IncompatibleFunctionError(
+                    "the remote function allows prompts with bounding boxes, but the "
+                    "function object does not"
+                )
+        elif self._function_spec.min_bounding_boxes == 1:
+            if not remote_function["startswith_box"]:
+                raise IncompatibleFunctionError(
+                    "the remote function does not require bounding boxes in prompts, "
+                    "but the function object does"
+                )
+
+    def _calculate_result_for_interact_ar(
+        self, ar_params: dict[str, Any], check_in: object
+    ) -> dict[str, Any]:
+        pos_points = tuple(map(tuple, ar_params["pos_points"]))
+        neg_points = tuple(map(tuple, ar_params["neg_points"]))
+        bounding_box = tuple(map(tuple, ar_params["obj_bbox"])) or None
+
+        if len(pos_points) < self._function_spec.min_pos_points:
+            raise BadArError("not enough positive points")
+
+        if self._function_spec.min_neg_points is None:
+            if len(neg_points) > 0:
+                raise BadArError("negative points are not supported")
+        else:
+            if len(neg_points) < self._function_spec.min_neg_points:
+                raise BadArError("not enough negative points")
+
+        if self._function_spec.min_bounding_boxes is None and bounding_box is not None:
+            raise BadArError("bounding boxes are not supported")
+        elif self._function_spec.min_bounding_boxes == 1 and bounding_box is None:
+            raise BadArError("a bounding box is required")
+
+        prompts = _InteractionPromptsImpl(
+            pos_points=pos_points, neg_points=neg_points, bounding_box=bounding_box
+        )
+
+        cache_key = (ar_params["task"], ar_params["frame"], tuple(ar_params.get("roi") or ()))
+
+        shapes = self._executor.result(
+            self._executor.submit(_worker_job_interact_from_cache, cache_key, prompts)
+        )
+
+        if shapes is None:
+            sample, _ = self._get_sample_from_ar_params(ar_params)
+
+            shapes = self._executor.result(
+                self._executor.submit(
+                    _worker_job_interact,
+                    cache_key,
+                    self._load_image_for_ar(sample, ar_params),
+                    prompts,
+                )
+            )
+
+        return {"shapes": [attrs.asdict(shape) for shape in shapes]}
+
+    _CALCULATE_RESULT_PER_AR_TYPE = {"interact": _calculate_result_for_interact_ar}

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/src/cvat_cli/_internal/command_base.py

@@ -53,7 +53,10 @@ class CommandGroup:
 
         for name, command in self._commands.items():
             subparser = subparsers.add_parser(name, description=command.description)
-            subparser.set_defaults(_executor=command.execute)
+            subparser.set_defaults(
+                _executor=command.execute,
+                _needs_client=getattr(command, "needs_client", True),
+            )
             command.configure_parser(subparser)
 
     def execute(self) -> None:

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/src/cvat_cli/_internal/commands_all.py

@@ -3,12 +3,14 @@
 # SPDX-License-Identifier: MIT
 
 from .command_base import CommandGroup, DeprecatedAlias
+from .commands_config import COMMANDS as COMMANDS_CONFIG
 from .commands_functions import COMMANDS as COMMANDS_FUNCTIONS
 from .commands_projects import COMMANDS as COMMANDS_PROJECTS
 from .commands_tasks import COMMANDS as COMMANDS_TASKS
 
 COMMANDS = CommandGroup(description="Perform operations on CVAT resources.")
 
+COMMANDS.add_command("config", COMMANDS_CONFIG)
 COMMANDS.add_command("function", COMMANDS_FUNCTIONS)
 COMMANDS.add_command("project", COMMANDS_PROJECTS)
 COMMANDS.add_command("task", COMMANDS_TASKS)

cvat_cli-2.71.0/src/cvat_cli/_internal/commands_config.py

@@ -0,0 +1,45 @@
+# Copyright (C) CVAT.ai Corporation
+#
+# SPDX-License-Identifier: MIT
+
+from __future__ import annotations
+
+import argparse
+
+from cvat_sdk.core.auth import AuthStore
+
+from .command_base import CommandGroup
+from .common import CriticalError
+
+COMMANDS = CommandGroup(description="Manage local CVAT CLI configuration.")
+
+
+@COMMANDS.command_class("default-server")
+class ConfigDefaultServer:
+    needs_client = False
+    description = (
+        "Print, set, or unset the default server used by the non-profile "
+        "credential paths (--auth, CVAT_ACCESS_TOKEN, prompt)."
+    )
+
+    def configure_parser(self, parser: argparse.ArgumentParser) -> None:
+        parser.add_argument("server", nargs="?", default=None, help="server URL to remember")
+        parser.add_argument("--unset", action="store_true", help="clear the saved default server")
+
+    def execute(self, args: argparse.Namespace) -> None:
+        store = AuthStore()
+
+        if args.unset and args.server is not None:
+            raise CriticalError("Cannot combine a server value with --unset.")
+
+        if args.unset:
+            store.clear_default_server()
+            print("Default server cleared.")
+        elif args.server is not None:
+            if not args.server.strip():
+                raise CriticalError("Default server cannot be empty. Use --unset to clear it.")
+            store.set_default_server(args.server)
+            print(f"Default server is now {args.server!r}.")
+        else:
+            current = store.get_default_server()
+            print(current if current is not None else "(no default server set)")

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/src/cvat_cli/_internal/common.py

@@ -42,6 +42,7 @@ def configure_common_arguments(parser: argparse.ArgumentParser) -> None:
         default=logging.INFO,
         help="show debug output",
     )
+    parser.set_defaults(_needs_client=True)
 
 
 def configure_logger(logger: logging.Logger, parsed_args: argparse.Namespace) -> None:

cvat_cli-2.71.0/src/cvat_cli/version.py

@@ -0,0 +1 @@
+VERSION = "2.71.0"

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/src/cvat_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cvat-cli
-Version: 2.70.0
+Version: 2.71.0
 Summary: Command-line client for CVAT
 Author-email: "CVAT.ai Corporation" <support@cvat.ai>
 License-Expression: MIT
@@ -9,7 +9,7 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
-Requires-Dist: cvat-sdk==2.70.0
+Requires-Dist: cvat-sdk==2.71.0
 Requires-Dist: attrs>=24.2.0
 Requires-Dist: Pillow>=10.3.0
 

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/src/cvat_cli.egg-info/SOURCES.txt

@@ -13,9 +13,11 @@ src/cvat_cli/_internal/__init__.py
 src/cvat_cli/_internal/agent.py
 src/cvat_cli/_internal/agent_driver.py
 src/cvat_cli/_internal/agent_driver_detection.py
+src/cvat_cli/_internal/agent_driver_interaction.py
 src/cvat_cli/_internal/agent_driver_tracking.py
 src/cvat_cli/_internal/command_base.py
 src/cvat_cli/_internal/commands_all.py
+src/cvat_cli/_internal/commands_config.py
 src/cvat_cli/_internal/commands_functions.py
 src/cvat_cli/_internal/commands_projects.py
 src/cvat_cli/_internal/commands_tasks.py

{cvat_cli-2.70.0 → cvat_cli-2.71.0}/src/cvat_cli.egg-info/requires.txt

@@ -1,3 +1,3 @@
-cvat-sdk==2.70.0
+cvat-sdk==2.71.0
 attrs>=24.2.0
 Pillow>=10.3.0

cvat_cli-2.70.0/src/cvat_cli/version.py

@@ -1 +0,0 @@
-VERSION = "2.70.0"