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

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

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

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

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

{cvat_cli-2.69.0 → cvat_cli-2.70.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.70.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.69.0 → cvat_cli-2.70.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.70.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.70.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",
@@ -135,24 +58,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.70.0/src/cvat_cli/version.py

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

{cvat_cli-2.69.0 → cvat_cli-2.70.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.70.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.70.0
 Requires-Dist: attrs>=24.2.0
 Requires-Dist: Pillow>=10.3.0
 

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

@@ -1,3 +1,3 @@
-cvat-sdk==2.69.0
+cvat-sdk==2.70.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"