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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cvat-cli
-Version: 2.69.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.69.0
+Requires-Dist: cvat-sdk==2.71.0
 Requires-Dist: attrs>=24.2.0
 Requires-Dist: Pillow>=10.3.0
 

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

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

{cvat_cli-2.69.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.69.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.69.0 → cvat_cli-2.71.0}/src/cvat_cli/_internal/agent_driver.py

@@ -5,7 +5,7 @@
 from __future__ import annotations
 
 from collections.abc import Callable
-from typing import TYPE_CHECKING, Any, ClassVar, Protocol
+from typing import TYPE_CHECKING, Any, ClassVar, Generic, Protocol, TypeVar
 
 import cvat_sdk.auto_annotation as cvataa
 import cvat_sdk.datasets as cvatds
@@ -47,10 +47,13 @@ class CheckInCallback(Protocol):
         """
 
 
-class AgentFunctionDriver:
+SpecT = TypeVar("SpecT")
+
+
+class AgentFunctionDriver(Generic[SpecT]):
     FUNCTION_KIND: ClassVar[str]
 
-    def __init__(self, client: Client, executor: RecoverableExecutor, function_spec: object):
+    def __init__(self, client: Client, executor: RecoverableExecutor, function_spec: SpecT) -> None:
         self._client = client
         self._executor = executor
         self._function_spec = function_spec
@@ -59,6 +62,10 @@ class AgentFunctionDriver:
     def init_worker(cls, state_id_generator: TrackingStateIdGenerator) -> None:
         pass
 
+    @classmethod
+    def get_remote_function_fields(cls, spec: SpecT) -> dict[str, Any]:
+        raise NotImplementedError
+
     def validate_function_compatibility(self, remote_function: dict) -> None:
         raise NotImplementedError
 
@@ -93,3 +100,17 @@ class AgentFunctionDriver:
             raise BadArError(f"Frame with index {frame_index} does not exist in the task")
 
         return sample, ds.labels
+
+    def _load_image_for_ar(self, sample, ar_params):
+        image = sample.media.load_image()
+
+        if roi := ar_params.get("roi"):
+            xtl, ytl, xbr, ybr = roi
+            width, height = image.size
+
+            if xbr > width or ybr > height:
+                raise BadArError("Invalid ROI")
+
+            return image.crop((xtl, ytl, xbr, ybr))
+
+        return image

{cvat_cli-2.69.0 → cvat_cli-2.71.0}/src/cvat_cli/_internal/agent_driver_detection.py

@@ -30,9 +30,45 @@ def _worker_job_detect(
     return current_function.detect(context, image)
 
 
-class AgentDetectionFunctionDriver(AgentFunctionDriver):
+class AgentDetectionFunctionDriver(AgentFunctionDriver[cvataa.DetectionFunctionSpec]):
     FUNCTION_KIND = "detector"
-    _function_spec: cvataa.DetectionFunctionSpec
+
+    @staticmethod
+    def _dump_sublabel_spec(
+        sl_spec: models.SublabelRequest | models.PatchedLabelRequest,
+    ) -> dict:
+        result = {
+            "name": sl_spec.name,
+            "attributes": [
+                {
+                    "name": attribute_spec.name,
+                    "input_type": attribute_spec.input_type,
+                    "values": attribute_spec.values,
+                }
+                for attribute_spec in getattr(sl_spec, "attributes", [])
+            ],
+        }
+
+        if getattr(sl_spec, "type", "any") != "any":
+            # Add the type conditionally, to stay compatible with older
+            # CVAT versions when the function doesn't define label types.
+            result["type"] = sl_spec.type
+
+        return result
+
+    @classmethod
+    def get_remote_function_fields(cls, spec: cvataa.DetectionFunctionSpec) -> dict[str, Any]:
+        labels_v2 = []
+
+        for label_spec in spec.labels:
+            labels_v2.append(cls._dump_sublabel_spec(label_spec))
+
+            if sublabels := getattr(label_spec, "sublabels", None):
+                labels_v2[-1]["sublabels"] = [
+                    cls._dump_sublabel_spec(sublabel) for sublabel in sublabels
+                ]
+
+        return {"labels_v2": labels_v2}
 
     def _validate_sublabel_compatibility(
         self, remote_sl: dict, sl: models.Sublabel | None, sl_desc: str
@@ -134,7 +170,9 @@ class AgentDetectionFunctionDriver(AgentFunctionDriver):
             for sample_index, sample in enumerate(samples):
                 context = self._create_detection_function_context(ar_params, sample.frame_name)
                 annotations = self._executor.result(
-                    self._executor.submit(_worker_job_detect, context, sample.media.load_image())
+                    self._executor.submit(
+                        _worker_job_detect, context, self._load_image_for_ar(sample, ar_params)
+                    )
                 )
 
                 tags, shapes = mapper.validate_and_remap(annotations, sample.frame_index)
@@ -155,7 +193,9 @@ class AgentDetectionFunctionDriver(AgentFunctionDriver):
         context = self._create_detection_function_context(ar_params, sample.frame_name)
 
         annotations = self._executor.result(
-            self._executor.submit(_worker_job_detect, context, sample.media.load_image())
+            self._executor.submit(
+                _worker_job_detect, context, self._load_image_for_ar(sample, ar_params)
+            )
         )
 
         tags, shapes = mapper.validate_and_remap(annotations, sample.frame_index)

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.69.0 → cvat_cli-2.71.0}/src/cvat_cli/_internal/agent_driver_tracking.py

@@ -146,9 +146,8 @@ class _TrackingFunctionShapeContextImpl(cvataa.TrackingFunctionShapeContext):
     original_shape_type: str
 
 
-class AgentTrackingFunctionDriver(AgentFunctionDriver):
+class AgentTrackingFunctionDriver(AgentFunctionDriver[cvataa.TrackingFunctionSpec]):
     FUNCTION_KIND = "tracker"
-    _function_spec: cvataa.TrackingFunctionSpec
 
     @classmethod
     def init_worker(cls, state_id_generator: TrackingStateIdGenerator) -> None:
@@ -158,6 +157,10 @@ class AgentTrackingFunctionDriver(AgentFunctionDriver):
         global _tracking_state_id_generator
         _tracking_state_id_generator = state_id_generator
 
+    @classmethod
+    def get_remote_function_fields(cls, spec: cvataa.TrackingFunctionSpec) -> dict[str, Any]:
+        return {"supported_shape_types": sorted(spec.supported_shape_types)}
+
     def validate_function_compatibility(self, remote_function: dict) -> None:
         remote_supported_shape_types = frozenset(remote_function["supported_shape_types"])
         unsupported = remote_supported_shape_types - self._function_spec.supported_shape_types

{cvat_cli-2.69.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.69.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.69.0 → cvat_cli-2.71.0}/src/cvat_cli/_internal/commands_functions.py

@@ -8,12 +8,9 @@ import textwrap
 from collections.abc import Sequence
 from typing import Any
 
-import cvat_sdk.auto_annotation as cvataa
-from cvat_sdk import Client, models
+from cvat_sdk import Client
 
-from .agent import FUNCTION_PROVIDER_NATIVE, run_agent
-from .agent_driver_detection import AgentDetectionFunctionDriver
-from .agent_driver_tracking import AgentTrackingFunctionDriver
+from .agent import FUNCTION_PROVIDER_NATIVE, get_function_driver_class, run_agent
 from .command_base import CommandGroup
 from .common import FunctionLoader, configure_function_implementation_arguments
 
@@ -40,29 +37,6 @@ class FunctionCreateNative:
 
         configure_function_implementation_arguments(parser)
 
-    @staticmethod
-    def _dump_sublabel_spec(
-        sl_spec: models.SublabelRequest | models.PatchedLabelRequest,
-    ) -> dict:
-        result = {
-            "name": sl_spec.name,
-            "attributes": [
-                {
-                    "name": attribute_spec.name,
-                    "input_type": attribute_spec.input_type,
-                    "values": attribute_spec.values,
-                }
-                for attribute_spec in getattr(sl_spec, "attributes", [])
-            ],
-        }
-
-        if getattr(sl_spec, "type", "any") != "any":
-            # Add the type conditionally, to stay compatible with older
-            # CVAT versions when the function doesn't define label types.
-            result["type"] = sl_spec.type
-
-        return result
-
     def execute(
         self,
         client: Client,
@@ -72,32 +46,16 @@ class FunctionCreateNative:
         function_loader: FunctionLoader,
     ) -> None:
         function = function_loader.load()
+        driver_class = get_function_driver_class(function.spec)
 
         remote_function: dict[str, Any] = {
             "provider": FUNCTION_PROVIDER_NATIVE,
             "name": name,
             "visibility": visibility,
+            "kind": driver_class.FUNCTION_KIND,
+            **driver_class.get_remote_function_fields(function.spec),
         }
 
-        spec = function.spec
-
-        if isinstance(spec, cvataa.DetectionFunctionSpec):
-            remote_function["kind"] = AgentDetectionFunctionDriver.FUNCTION_KIND
-            remote_function["labels_v2"] = []
-
-            for label_spec in spec.labels:
-                remote_function["labels_v2"].append(self._dump_sublabel_spec(label_spec))
-
-                if sublabels := getattr(label_spec, "sublabels", None):
-                    remote_function["labels_v2"][-1]["sublabels"] = [
-                        self._dump_sublabel_spec(sublabel) for sublabel in sublabels
-                    ]
-        elif isinstance(spec, cvataa.TrackingFunctionSpec):
-            remote_function["kind"] = AgentTrackingFunctionDriver.FUNCTION_KIND
-            remote_function["supported_shape_types"] = sorted(spec.supported_shape_types)
-        else:
-            raise cvataa.BadFunctionError(f"Unsupported function spec type: {type(spec).__name__}")
-
         _, response = client.api_client.call_api(
             "/api/functions",
             "POST",

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

@@ -4,27 +4,23 @@
 # SPDX-License-Identifier: MIT
 
 import argparse
-import getpass
 import importlib
 import importlib.util
 import logging
-import os
 import sys
-import textwrap
-from collections.abc import Callable
 from http.client import HTTPConnection
 from pathlib import Path
 from typing import Any
 
 import attrs
 import cvat_sdk.auto_annotation as cvataa
-from cvat_sdk.core.client import (
-    AccessTokenCredentials,
-    Client,
-    Config,
-    Credentials,
-    PasswordCredentials,
+from cvat_sdk.core.auth import (
+    ClientAuthParameters,
+    configure_client_auth_arguments,
+    make_client_from_cli,
 )
+from cvat_sdk.core.client import Client
+from cvat_sdk.core.exceptions import AuthStoreError
 
 from ..version import VERSION
 from .parsers import BuildDictAction, parse_function_parameter
@@ -35,82 +31,9 @@ class CriticalError(Exception):
     pass
 
 
-CVAT_ACCESS_TOKEN_ENV_VAR = "CVAT_ACCESS_TOKEN"  # nosec - a variable name declaration
-
-
-def default_auth_factory() -> Callable[[str], Credentials]:
-    """
-    Try to read the CVAT_ACCESS_TOKEN environment variable for a Personal Access Token (PAT).
-    If there is no value, try using the current user and asking for the password.
-    """
-
-    token = os.getenv(CVAT_ACCESS_TOKEN_ENV_VAR)
-    if token is not None:
-        return lambda _: AccessTokenCredentials(token)
-
-    return get_auth_factory(getpass.getuser())
-
-
-def get_auth_factory(s: str) -> Callable[[str], Credentials]:
-    """
-    Parse a USER[:PASS] string and return a callable that takes the server URL
-    and returns auth credentials for that URL.
-    The callable will prompt the user for the password if none was initially supplied in the
-    input string and in the PASS env variable.
-    """
-
-    user, _, password = s.partition(":")
-    if not password:
-        password = os.environ.get("PASS")
-
-    if password:
-        return lambda _: PasswordCredentials(user, password)
-    else:
-        return lambda url: PasswordCredentials(
-            user, getpass.getpass(f"Password for {user} at {url}: ")
-        )
-
-
 def configure_common_arguments(parser: argparse.ArgumentParser) -> None:
     parser.add_argument("--version", action="version", version=VERSION)
-    parser.add_argument(
-        "--insecure",
-        action="store_true",
-        help="Allows to disable SSL certificate check",
-    )
-
-    parser.add_argument(
-        "--auth",
-        type=get_auth_factory,
-        metavar="USER[:PASS]",
-        default=default_auth_factory(),
-        help=textwrap.dedent("""\
-            User and password to use for authentication;
-            defaults to the current user and supports the PASS
-            environment variable or password prompt.
-            A Personal Access Token (PAT) can be generated on the server
-            and specified in the {} environment variable instead.
-            (default user: {}).
-        """).format(CVAT_ACCESS_TOKEN_ENV_VAR, getpass.getuser()),
-    )
-    parser.add_argument(
-        "--server-host", type=str, default="http://localhost", help="host (default: %(default)s)"
-    )
-    parser.add_argument(
-        "--server-port",
-        type=int,
-        default=None,
-        help="port (default: 80 for http and 443 for https connections)",
-    )
-    parser.add_argument(
-        "--organization",
-        "--org",
-        metavar="SLUG",
-        help="""short name (slug) of the organization
-                to use when listing or creating resources;
-                set to blank string to use the personal workspace
-                (default: list all accessible objects, create in personal workspace)""",
-    )
+    configure_client_auth_arguments(parser)
     parser.add_argument(
         "--debug",
         action="store_const",
@@ -119,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:
@@ -135,24 +59,16 @@ def configure_logger(logger: logging.Logger, parsed_args: argparse.Namespace) ->
 
 
 def build_client(parsed_args: argparse.Namespace, logger: logging.Logger) -> Client:
-    config = Config(verify_ssl=not popattr(parsed_args, "insecure"))
-
-    url = popattr(parsed_args, "server_host")
-    if server_port := popattr(parsed_args, "server_port"):
-        url += f":{server_port}"
+    auth_args = ClientAuthParameters.from_namespace(parsed_args)
+    for field in attrs.fields(ClientAuthParameters):
+        popattr(parsed_args, field.name)
 
-    client = Client(
-        url=url,
-        logger=logger,
-        config=config,
-        check_server_version=False,  # version is checked after auth to support versions < 2.3
-    )
+    try:
+        client = make_client_from_cli(auth_args, logger=logger)
+    except AuthStoreError as e:
+        raise CriticalError(str(e)) from e
 
-    client.login(popattr(parsed_args, "auth")(client.api_client.configuration.host))
     client.check_server_version(fail_if_unsupported=False)
-
-    client.organization_slug = popattr(parsed_args, "organization")
-
     return client
 
 

cvat_cli-2.71.0/src/cvat_cli/version.py

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

{cvat_cli-2.69.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.69.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.69.0
+Requires-Dist: cvat-sdk==2.71.0
 Requires-Dist: attrs>=24.2.0
 Requires-Dist: Pillow>=10.3.0
 

{cvat_cli-2.69.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.69.0 → cvat_cli-2.71.0}/src/cvat_cli.egg-info/requires.txt

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

cvat_cli-2.69.0/src/cvat_cli/version.py

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